Merge branch 'jun/do/ft-srs-ga-2' of github.com:cloudflare/cloudflare-docs into jun/do/ft-srs-ga-2

Author: Oxyjun

src/content/changelog/durable-objects/2025-04-07-durable-objects-free-tier.mdx

@@ -7,7 +7,7 @@ products:
 date: 2025-04-07T06:00:00Z
 ---
 
-Durable Objects can now be used with zero commitment on the [Workers Free plan](/workers/platform/pricing/) allowing you to build AI agents with [Agents SDK](/agents), collaboration tools, and real-time applications like chat or multiplayer games. 
+Durable Objects can now be used with zero commitment on the [Workers Free plan](/workers/platform/pricing/) allowing you to build AI agents with [Agents SDK](/agents/), collaboration tools, and real-time applications like chat or multiplayer games. 
 
 Durable Objects let you build stateful, serverless applications with millions of tiny coordination instances that run your application code alongside (in the same thread!) your durable storage. Each Durable Object can access its own SQLite database through a [Storage API](/durable-objects/best-practices/access-durable-objects-storage/). A Durable Object class is defined in a Worker script encapsulating the Durable Object's behavior when accessed from a Worker. To try the code below, click the button: 
 

src/content/changelog/durable-objects/2025-04-07-sqlite-in-durable-objects-ga.mdx

@@ -1,6 +1,6 @@
 ---
 title: SQLite in Durable Objects GA
-description: SQLite-bakced Durable Objects are generally available.
+description: SQLite-backed Durable Objects are generally available.
 products:
   - durable-objects
   - workers 
@@ -9,7 +9,7 @@ date: 2025-04-07T06:00:00Z
 
 SQLite in Durable Objects is now generally available (GA). Since the [public beta](https://blog.cloudflare.com/sqlite-in-durable-objects/) in September 2024, we've added feature parity and robustness for the SQLite storage backend compared to the preexisting key-value (KV) storage backend for Durable Objects. 
 
-SQLite-backed Durable Objects are recommended for all new Durable Object classes, using `new_sqlite_classes` [Wrangler configuration](/durable-objects/best-practices/access-durable-objects-storage/#create-sqlite-backed-durable-object-class). Only SQLite-backed Durable Objects have access to Storage API's [SQL](/durable-objects/api/storage-api/#sql-api) and [point-in-time recovery](/durable-objects/api/storage-api/#pitr-point-in-time-recovery-api) methods, which provide relational data modelling, SQL querying, and better data management.
+SQLite-backed Durable Objects are recommended for all new Durable Object classes, using `new_sqlite_classes` [Wrangler configuration](/durable-objects/best-practices/access-durable-objects-storage/#create-sqlite-backed-durable-object-class). Only SQLite-backed Durable Objects have access to Storage API's [SQL](/durable-objects/api/storage-api/#sql-api) and [point-in-time recovery](/durable-objects/api/storage-api/#pitr-point-in-time-recovery-api) methods, which provide relational data modeling, SQL querying, and better data management.
 
 ```js
 export class MyDurableObject extends DurableObject {
@@ -21,7 +21,7 @@ export class MyDurableObject extends DurableObject {
 
   async sayHello() {
     let result = this.sql
-      .exec("SELECT 'Hello, World!' as greeting")
+      .exec("SELECT 'Hello, World!' AS greeting")
       .one();
     return result.greeting;
   }

src/content/docs/durable-objects/api/storage-api.mdx

@@ -67,11 +67,11 @@ export class Counter extends DurableObject {
 ```
 </TypeScriptExample>
 
-JavaScript is a single-threaded and event-driven programming language. This means that JavaScript runtimes, by default, allow requests to interleave with each other which can lead to concurrency bugs. The Durable Objects runtime uses a combination of <GlossaryTooltip term="input gate">input gates</GlossaryTooltip> and <GlossaryTooltip term="output gate">output gates</GlossaryTooltip> to avoid this type of concurrency bug when performing storage operations. Learn more with our [blog post](https://blog.cloudflare.com/durable-objects-easy-fast-correct-choose-three/)
+JavaScript is a single-threaded and event-driven programming language. This means that JavaScript runtimes, by default, allow requests to interleave with each other which can lead to concurrency bugs. The Durable Objects runtime uses a combination of <GlossaryTooltip term="input gate">input gates</GlossaryTooltip> and <GlossaryTooltip term="output gate">output gates</GlossaryTooltip> to avoid this type of concurrency bug when performing storage operations. Learn more in our [blog post](https://blog.cloudflare.com/durable-objects-easy-fast-correct-choose-three/).
 
 ## SQL API
 
-The `SqlStorage` interface encapsulates methods that modify the SQLite database embedded within a Durable Object. The `SqlStorage` interface is accessible via the [`sql` property](/durable-objects/api/storage-api/#) of `DurableObjectStorage` class.
+The `SqlStorage` interface encapsulates methods that modify the SQLite database embedded within a Durable Object. The `SqlStorage` interface is accessible via the [`sql` property](/durable-objects/api/storage-api/#sql) of `DurableObjectStorage` class.
 
 For example, using `sql.exec()`, a user can create a table, then insert rows into the table.
 
@@ -141,7 +141,7 @@ if (!rawResult.done) {
 console.log(cursor.toArray()); // prints [{ artistid: 456, artistname: 'Bob' },{ artistid: 789, artistname: 'Charlie' }]
 ```
 
-`SqlStorageCursor` had the following properties:
+`SqlStorageCursor` has the following properties:
 
 * `columnNames`: <Type text='string[]' />
   * The column names of the query in the order they appear in each row array returned by the `raw` iterator.
@@ -186,7 +186,7 @@ let size = ctx.storage.sql.databaseSize;
 
 For [SQLite-backed Durable Objects](/durable-objects/best-practices/access-durable-objects-storage/#create-sqlite-backed-durable-object-class), the following point-in-time-recovery (PITR) API methods are available to restore a Durable Object's embedded SQLite database to any point in time in the past 30 days. These methods apply to the entire SQLite database contents, including both the object's stored SQL data and stored key-value data using the key-value `put()` API. The PITR API is not supported in local development because a durable log of data changes is not stored locally.
 
-The PITR API represents points in times using 'bookmarks'. A bookmark is a mostly alphanumeric string like `0000007b-0000b26e-00001538-0c3e87bb37b3db5cc52eedb93cd3b96b`. Bookmarks are designed to be lexically comparable: a bookmark representing an earlier point in time compares less than one representing a later point, using regular string comparison.
+The PITR API represents points in time using 'bookmarks'. A bookmark is a mostly alphanumeric string like `0000007b-0000b26e-00001538-0c3e87bb37b3db5cc52eedb93cd3b96b`. Bookmarks are designed to be lexically comparable: a bookmark representing an earlier point in time compares less than one representing a later point, using regular string comparison.
 
 ### `getCurrentBookmark`
 
@@ -377,7 +377,7 @@ The `put()` method returns a `Promise`, but most applications can discard this p
   - For Durable Objects with a key-value storage backend, an in-progress `deleteAll()` operation can fail, which may leave a subset of data undeleted. Durable Objects with a SQLite storage backend do not have a partial `deleteAll()` issue because `deleteAll()` operations are atomic (all or nothing).
   - `deleteAll()` does not proactively delete [alarms](/durable-objects/api/alarms/). Use [`deleteAlarm()`](/durable-objects/api/alarms/#deletealarm) to delete an alarm.
 
-  ### `transaction`
+### `transaction`
 
 - `transaction(closureFunction(txn))`: <Type text='Promise' />
 
@@ -389,7 +389,7 @@ The `put()` method returns a `Promise`, but most applications can discard this p
 
   - Provides access to the `put()`, `get()`, `delete()` and `list()` methods documented above to run in the current transaction context. In order to get transactional behavior within a transaction closure, you must call the methods on the `txn` Object instead of on the top-level `ctx.storage` Object.<br/><br/>Also supports a `rollback()` function that ensures any changes made during the transaction will be rolled back rather than committed. After `rollback()` is called, any subsequent operations on the `txn` Object will fail with an exception. `rollback()` takes no parameters and returns nothing to the caller.
 
-  * When using [the SQLite-backed storage engine](/durable-objects/best-practices/access-durable-objects-storage/#sqlite-storage-backend), the `txn` object is obsolete. Any storage operations performed directly on the `ctx.storage` object, including SQL queries using [`ctx.storage.sql.exec()`](/durable-objects/api/storage-api/#exec), will be considered part of the transaction.
+  - When using [the SQLite-backed storage engine](/durable-objects/best-practices/access-durable-objects-storage/#sqlite-storage-backend), the `txn` object is obsolete. Any storage operations performed directly on the `ctx.storage` object, including SQL queries using [`ctx.storage.sql.exec()`](/durable-objects/api/storage-api/#exec), will be considered part of the transaction.
 
 ### `sync`
 

src/content/docs/durable-objects/best-practices/access-durable-objects-storage.mdx

@@ -118,10 +118,10 @@ type User = {
 }
 ```
 
-This type can then be passed as the type parameter to a `sql.exec` call:
+This type can then be passed as the type parameter to a `sql.exec()` call:
 
 ```ts
-// The type parameter is passed between the "pointy brackets" before the function argument:
+// The type parameter is passed between angle brackets before the function argument:
 const result = this.ctx.storage.sql.exec<User>("SELECT id, name, email_address, version FROM users WHERE id = ?", user_id).one()
 // result will now have a type of "User"
 
@@ -147,7 +147,8 @@ for (let row of cursor) {
 }
 ```
 
-You can represent the shape of any result type you wish, including more complex types. If you are performing a JOIN across multiple tables, you can compose a type that reflects the results of your queries.
+You can represent the shape of any result type you wish, including more complex types. If you are performing a 
+`JOIN` across multiple tables, you can compose a type that reflects the results of your queries.
 
 ## Indexes in SQLite
 

src/content/docs/durable-objects/best-practices/websockets.mdx

@@ -9,7 +9,7 @@ import { Tabs, TabItem, GlossaryTooltip, Type } from "~/components";
 
 This guide covers how to use Durable Objects as WebSocket servers that can connect thousands of clients (per instance), as well as a WebSocket client to connect to other servers or even Durable Objects.
 
-There are two sets of WebSockets API
+There are two sets of WebSockets API:
 
 1. Native Durable Object WebSocket API, which allows your Durable Object to hibernate without disconnecting clients when not actively doing work **(recommended)**.
 2. Web Standard WebSocket APIs, using the familiar `addEventListener` event pattern.

src/content/docs/durable-objects/platform/pricing.mdx

@@ -18,7 +18,7 @@ Durable Objects can incur two types of billing: compute and storage.
 These examples exclude the costs for the Workers calling the Durable Objects. When modelling the costs of a Durable Object, note that:
 
 * Inactive objects receiving no requests do not incur any duration charges.
-* The [WebSocket Hibernation API](/durable-objects/best-practices/websockets#websocket-hibernation-api) can dramatically reduce duration-related charges for Durable Objects communicating with clients over the WebSocket protocol, especially if messages are only transmitted occasionally at sparse intervals.
+* The [WebSocket Hibernation API](/durable-objects/best-practices/websockets/#websocket-hibernation-api) can dramatically reduce duration-related charges for Durable Objects communicating with clients over the WebSocket protocol, especially if messages are only transmitted occasionally at sparse intervals.
 
 ### Example 1
 

src/content/docs/durable-objects/reference/environments.mdx

@@ -65,7 +65,7 @@ durable_objects.bindings = [
 
 Local development sessions create a standalone, local-only environment that mirrors the production environment, so that you can test your Worker and Durable Objects before you deploy to production.
 
-An existing Durable Object binding of DB would be available to your Worker when running locally.
+An existing Durable Object binding of `DB` would be available to your Worker when running locally.
 
 Refer to Workers [Local development](/workers/local-development/#supported-resource-bindings-in-different-environments).
 

src/content/docs/durable-objects/what-are-durable-objects.mdx

@@ -108,6 +108,6 @@ Finally, the following blog posts may help you learn some of the technical imple
 
 ## Get started
 
-Get started now by following the ["Tutorial with SQL API"](/durable-objects/get-started/) to create your first application using Durable Objects.
+Get started now by following the ["Get started" guide](/durable-objects/get-started/) to create your first application using Durable Objects.
 
 [^1]: Storage per Durable Object with SQLite is currently 1 GB. This will be raised to 10 GB for general availability.

src/content/partials/durable-objects/durable-objects-pricing.mdx

@@ -36,7 +36,7 @@ await durableObjectStub.cat(); // billed as a request
 
 <sup>3</sup> Application level auto-response messages handled by [`state.setWebSocketAutoResponse()`](/durable-objects/best-practices/websockets/) will not incur additional wall-clock time, and so they will not be charged.
 
-<sup>4</sup> Duration is billed in wall-clock time as long as the Object is active, but is shared across all requests active on an Object at once. Calling `accept()` on a WebSocket in an Object will incur duration charges for the entire time the WebSocket is connected. Note that the request context for a Durable Object extends for 10 seconds after the last client disconnects. The request context of a Durable Object is evaluated every 70 seconds and the context is ended if it has been active for 70 seconds. If you prefer, use the [WebSocket hibernation API](/durable-objects/best-practices/websockets/#websocket-hibernation-api) to avoid incurring duration charges once all event handlers finish running.
+<sup>4</sup> Duration is billed in wall-clock time as long as the Object is active, but is shared across all requests active on an Object at once. Calling `accept()` on a WebSocket in an Object will incur duration charges for the entire time the WebSocket is connected. Note that the request context for a Durable Object extends for 10 seconds after the last client disconnects. The request context of a Durable Object is evaluated every 70 seconds and the context is ended if it has been active for 70 seconds. If you prefer, use the [WebSocket Hibernation API](/durable-objects/best-practices/websockets/#websocket-hibernation-api) to avoid incurring duration charges once all event handlers finish running.
 
 <sup>5</sup> Duration billing charges for the 128 MB of memory your Durable Object is allocated, regardless of actual usage. If your account creates many instances of a single Durable Object class, Durable Objects may run in the same isolate on the same physical machine and share the 128 MB of memory. These Durable Objects are still billed as if they are allocated a full 128 MB of memory.
 
@@ -45,7 +45,7 @@ await durableObjectStub.cat(); // billed as a request
 { props.product === "durable-objects" && <><AnchorHeading title="Storage billing" depth={2}/></> }
 { props.product === "workers" && <><AnchorHeading title="Storage billing" depth={3}/></> }
 
-The [Durable Objects Storage API](/durable-objects/api/storage-api) is only accessible from within Durable Objects. Pricing depends on the type of storage your Durable Objects use.
+The [Durable Objects Storage API](/durable-objects/api/storage-api/) is only accessible from within Durable Objects. Pricing depends on the type of storage your Durable Objects use.
 
 - **SQLite-backed Durable Objects (recommended)**: This is the recommended storage for new Durable Object classes. Workers Free plan can only create and access SQLite-backed Durable Objects.
 - **Key-value storage backed Durable Objects**: This is only available on the Workers Paid plan.
@@ -69,7 +69,7 @@ The [Durable Objects Storage API](/durable-objects/api/storage-api) is only acce
 
 <sup>3</sup>  Each `setAlarm()` is billed as a single row written.
 
-<sup>4</sup>  Deletes are counted as rows_written.
+<sup>4</sup>  Deletes are counted as rows written.
 
 <sup>5</sup>  Durable Objects will be billed for stored data until the data is removed. Once the data is removed, the object will be cleaned up automatically by the system.
 

src/content/partials/durable-objects/storage-intro-text.mdx

@@ -11,7 +11,7 @@ The Durable Object Storage API comes with several methods, including [SQL API](/
 
 Each method is implicitly wrapped inside a transaction, such that its results are atomic and isolated from all other storage operations, even when accessing multiple key-value pairs.
 
-| Type of storage API | SQLite backed Durable Object | KV backed Durable Object |
+| Type of storage API | SQLite-backed Durable Object | KV-backed Durable Object |
 | ------------------- | ---------------------------- | ------------------------ |
 | SQL API             | ✅                           | ❌                       |
 | PITR API            | ✅                           | ❌                       |