effect-cf 0.30.0 → 0.32.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # effect-cf
 
+## 0.32.0
+
+### Minor Changes
+
+- [#119](https://github.com/danieljvdm/effect-cf/pull/119) [`34b1abf`](https://github.com/danieljvdm/effect-cf/commit/34b1abfab7ee963b9d28c143ad29c678ee88483e) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Add hibernation-aware Durable Object Effect RPC WebSockets that restore idle connections, reset lost non-resumable operations instead of hanging, and use Cloudflare auto-responses for idle heartbeats. Applications can opt specific cursor-backed streams into logical subscription reconstruction on the same socket and Effect request ID. Declaration schemas validate persisted resume state before reconstruction. Explicit application checkpoints establish the replay boundary, report attachment persistence failures in the typed error channel, and prevent stale stock acknowledgements from advancing a reconstructed stream.
+
+## 0.31.0
+
+### Minor Changes
+
+- [#116](https://github.com/danieljvdm/effect-cf/pull/116) [`98d343b`](https://github.com/danieljvdm/effect-cf/commit/98d343ba7d5a427789ec8e7fc030668987eab1ea) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Move the optional `effect-cf/vitest` peer from `@cloudflare/vitest-pool-workers` to `@cloudflare/vitest-plugin` `^1.0.0`. The package API is unchanged: keep using `cloudflareTest()` and `cloudflare:test`.
+
+- [#118](https://github.com/danieljvdm/effect-cf/pull/118) [`80730a8`](https://github.com/danieljvdm/effect-cf/commit/80730a82b26728e824ba6e4ed8bdbe290428baa6) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Pin the Cloudflare Workers runtime stack to workerd `1.20260820.1` (`@cloudflare/workers-types@^5.20260820.1`, wrangler `4.125.0`, recommended `compatibility_date` `2026-08-20`).
+
+  Images gains text rasterization (`text` / `process` text input), hosted `createDirectUpload` and `signedUrl`, and `response(options?)` for extra headers. Workflow instances gain `delete`, optional `terminate({ rollback })`, and `create`/`createBatch` `locationHint` via the updated types. `Worker.WorkerContext` now wraps the non-experimental `ExecutionContext.abort`.
+
 ## 0.30.0
 
 ### Minor Changes

package/README.md

@@ -4,7 +4,8 @@ Effect-native Cloudflare primitives for Workers, Durable Objects, Containers, bi
 
 ## Install
 
-`effect-cf` targets Effect `^4.0.0-beta.105`.
+`effect-cf` targets Effect `^4.0.0-beta.105` and Cloudflare workerd `1.20260820.1`
+(`@cloudflare/workers-types@5.20260820.1`, recommended `compatibility_date` `2026-08-20`).
 
 ```bash
 bun add effect-cf "effect@^4.0.0-beta.105"
@@ -72,12 +73,12 @@ Runtime creation belongs at Cloudflare entrypoints, not inside binding helpers.
 - `Rpc` - Cloudflare RPC type helpers and scoped disposal utilities
 - `WebTransport` - truthful WebTransport/HTTP-3 boundary: typed runtime capabilities and decoded inbound protocol metadata
 - `WorkerConfig` - Effect `Config` helpers backed by Cloudflare `env`
-- `effect-cf/vitest` - Effect-native runners and scoped test helpers for Cloudflare's Vitest Workers pool
+- `effect-cf/vitest` - Effect-native runners and scoped test helpers for Cloudflare's Workers Vitest plugin
 
-## Vitest Workers Pool
+## Vitest Workers Plugin
 
-Install and configure a `^0.21.3` release of
-[`@cloudflare/vitest-pool-workers`](https://github.com/cloudflare/workers-sdk/tree/main/packages/vitest-pool-workers#readme),
+Install and configure a `^1.0.0` release of
+[`@cloudflare/vitest-plugin`](https://github.com/cloudflare/workers-sdk/tree/main/packages/vitest-plugin#readme),
 then import the test-only helpers from `effect-cf/vitest`. The `fetch` runner
 constructs the Worker with the current test environment and waits for all
 `waitUntil` work before completing the Effect.
@@ -109,7 +110,7 @@ it.effect("reads Wrangler vars", () =>
 ```
 
 Queue consumers can be invoked with typed message bodies while retaining the
-pool's acknowledgement and retry result:
+plugin's acknowledgement and retry result:
 
 ```ts
 it.effect("acknowledges a job", () =>
@@ -130,7 +131,7 @@ it.effect("acknowledges a job", () =>
 
 Scheduled handlers and Pages Functions use the same lifecycle behavior: their
 Effects complete only after the event's `waitUntil` work has settled. Pages
-tests must configure the `ASSETS` binding required by Pool Workers.
+tests must configure the `ASSETS` binding required by the Workers Vitest plugin.
 
 ```ts
 it.effect("runs the cron handler", () =>
@@ -719,10 +720,26 @@ export const resizeAvatar = (image: Images.ImageInputValue) =>
       },
     );
 
-    return yield* result.response;
+    return yield* result.response();
   });
 ```
 
+## Cloudflare runtime pin
+
+`effect-cf` develops and tests against a fixed Cloudflare Workers runtime stack. Keep consumer
+`compatibility_date` and optional `@cloudflare/workers-types` peers at or above this pin:
+
+| Pin                                         | Version        |
+| ------------------------------------------- | -------------- |
+| workerd                                     | `1.20260820.1` |
+| `@cloudflare/workers-types` (optional peer) | `5.20260820.1` |
+| wrangler (repo catalog / examples)          | `4.125.0`      |
+| Recommended `compatibility_date`            | `2026-08-20`   |
+
+The date in the `workerd` / `@cloudflare/workers-types` version is the API surface this package wraps.
+Repo catalog pins live in the root `package.json` `catalog` field (`@cloudflare/workers-types`, `wrangler`).
+`wrangler@4.125.0` pulls `workerd@1.20260820.1` and peers `@cloudflare/workers-types@^5.20260820.1`.
+
 ## Email Example
 
 Email tags expose Cloudflare Email Service `send_email` bindings as Effect-wrapped `send(...)` operations. Structured messages are validated against documented Email Sending limits before reaching the binding, and Cloudflare's `E_*` error codes are surfaced on `EmailOperationError.code`.
@@ -962,7 +979,100 @@ if (Worker.isWebSocketUpgrade(request)) {
 }
 ```
 
-Use `DurableObjectRpcWebSocket.layer(...)` for Effect RPC-over-WebSocket transports. It owns protocol parsing and RPC client bookkeeping; use `DurableWebSocket` for general application sockets, rooms, presence, and broadcast flows.
+### Hibernation-aware Effect RPC WebSockets
+
+`DurableObjectRpcWebSocket.layer(...)` adapts Effect RPC to Cloudflare's hibernatable WebSocket API. Build the layer in the Durable Object runtime and forward all three WebSocket lifecycle events:
+
+```ts
+import { Effect, Layer } from "effect";
+import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
+import { DurableObject, DurableObjectRpcWebSocket, Worker } from "effect-cf";
+
+const RpcLive = RpcServer.layer(MyRpcs).pipe(
+  Layer.provideMerge(DurableObjectRpcWebSocket.layer({ tag: "my-rpc" })),
+  Layer.provide(MyRpcHandlers),
+  Layer.provide(RpcSerialization.layerJson),
+);
+
+const MyObjectLive = DurableObject.make(RpcLive, {
+  fetch: Effect.gen(function* () {
+    const request = yield* Worker.NativeRequest;
+
+    if (!Worker.isWebSocketUpgrade(request)) {
+      return new Response("Expected WebSocket upgrade", { status: 426 });
+    }
+
+    const transport = yield* DurableObjectRpcWebSocket.DurableObjectRpcWebSocket;
+    const upgrade = yield* transport.acceptUpgrade({
+      tags: ["room:general"],
+      attachment: { roomId: "general" },
+    });
+
+    return upgrade.response;
+  }),
+  webSocketMessage: (socket, message) =>
+    Effect.gen(function* () {
+      const transport = yield* DurableObjectRpcWebSocket.DurableObjectRpcWebSocket;
+
+      yield* transport.message(socket, message);
+    }),
+  webSocketClose: (socket) =>
+    Effect.gen(function* () {
+      const transport = yield* DurableObjectRpcWebSocket.DurableObjectRpcWebSocket;
+
+      yield* transport.close(socket);
+    }),
+  webSocketError: (socket, cause) =>
+    Effect.gen(function* () {
+      const transport = yield* DurableObjectRpcWebSocket.DurableObjectRpcWebSocket;
+
+      yield* transport.error(socket, cause);
+    }),
+});
+
+export class MyDurableObject extends MyObjectLive {}
+```
+
+`DurableObject.make` builds a new managed runtime whenever Cloudflare constructs or reconstructs the object. During that build, the RPC layer calls `getWebSockets(tag)` and registers tagged sockets before the triggering lifecycle handler runs. A completed finite call can therefore be followed by idle hibernation and another finite call on the same physical socket.
+
+This is a hibernation-aware RPC transport, not a durable RPC runtime. The adapter stores versioned state under the `attachmentKey` namespace, which defaults to `effectCloudflareRpcClientId`, and shallow-merges it with application-owned object fields. Its RPC tag is added alongside application tags. Application code that later replaces an attachment must preserve the reserved namespace; the adapter requires object-shaped attachments. Keep resume descriptors compact because Cloudflare caps the entire serialized attachment, including application fields, at 16,384 bytes. Legacy numeric client-ID metadata is migrated when read.
+
+Each non-notification request stays marked pending until its terminal `Exit` is sent or the request is interrupted. If a new constructor finds a pending non-resumable request, it quarantines the socket and closes it with WebSocket code `1012` before dispatching the event that woke the object. Effect's stock socket protocol reports this as an `RpcClientError` containing `SocketCloseError`, so the affected call or stream fails instead of hanging. The socket transport may reconnect for later calls, but the adapter never replays a non-resumable request. Retrying a mutation requires application-level idempotency or deduplication. Notifications are also not durable and have no delivery acknowledgement.
+
+The default `heartbeat: "auto-response"` policy installs Cloudflare's exact text Ping/Pong auto-response while at least one RPC socket exists and no non-resumable RPC operation is active. The stock Effect client's five-second Ping therefore does not run Durable Object JavaScript while the socket is idle or while an explicitly resumable subscription waits for data. The adapter creates no timer. A non-resumable call or stream removes the global auto-response so a Ping wakes a newly reconstructed object and triggers its pending-operation reset. Cloudflare provides only one auto-response pair per Durable Object, across every accepted socket. Use `"passthrough"` if unrelated WebSocket protocols share the same object.
+
+Use `heartbeat: "passthrough"` for a non-text serialization or when the application owns a different auto-response pair. That mode does not alter the pair; the application is responsible for ensuring a lost pending operation still wakes and resets. With the default policy, a conflicting application pair fails layer construction instead of being overwritten.
+
+Streams are non-resumable unless their RPC tag matches a declaration passed in `resumableStreams`. Constructor recreation resets an ordinary active stream with code `1012`.
+
+An explicitly resumable stream persists its original Effect request ID, RPC tag, application subscription key, compact resume descriptor, and last application checkpoint in the socket attachment. Each declaration supplies `resumeDescriptorSchema` and `checkpointSchema`; a new constructor validates both persisted values before it rebuilds anything. Invalid state resets that socket with code `1012` instead of reaching application reconstruction. Valid state becomes an encoded request written through the new `RpcServer.Protocol` with the original request ID. Effect runs request decoding, middleware, authorization, and the handler again. The physical socket stays open, so the stock Effect client routes later `Chunk` messages into the existing client `Stream`.
+
+This reconstructs a declared logical subscription. It does not restore the original Effect fiber, scope, stream, queue, or middleware context. The application must keep a durable event log and rebuild the stream after its cursor. Delivery is at least once. If hibernation lands after a chunk reaches the client but before its checkpoint is stored, the rebuilt handler emits that chunk again. Apply events idempotently by cursor, then call a finite checkpoint RPC. Retention, cursor expiry, snapshots, and resync remain application concerns. This transport does not provide exactly-once delivery or generic stream resumption.
+
+The declaration also gives the transport a stable token for each encoded chunk value. A cursor/token must identify one logical event for the full lifetime of that subscription. Distinct events must not share it; a replay of the same event reuses it. The adapter ignores stock request-ID-only stream `Ack` messages for resumable requests. It persists the matching explicit checkpoint before releasing the current server chunk latch, and an acknowledgement left over from an earlier activation cannot release a later chunk. If attachment serialization fails, `checkpoint` fails with `DurableWebSocketAttachmentError` and the transport resets the socket with code `1012`; it never releases or sends a chunk whose replay state was not stored. Interrupt and terminal `Exit` remove the persisted descriptor.
+
+The compiled [`ResumableEventLog.example.ts`](../../examples/todo-rpc-ws/durable-objects/todo-store/src/ResumableEventLog.example.ts) defines a standard `RpcGroup`, cursor-backed Durable Object SQL event log, `RpcServer.layer`, resumable declaration, checkpoint handler using `Rpc.ServerClient.id`, and complete constructor/event wiring. Its client-side ordering is the important part:
+
+```ts
+import { Effect, Stream } from "effect";
+
+client.SubscribeEvents({ subscriptionKey, topic, after }).pipe(
+  Stream.runForEach((event) =>
+    applyEventIfNew(event).pipe(
+      Effect.andThen(
+        client.CheckpointSubscription({
+          subscriptionKey,
+          cursor: event.cursor,
+        }),
+      ),
+    ),
+  ),
+);
+```
+
+Checkpoint only after `applyEventIfNew` commits. A replayed cursor must make that function a no-op. `CheckpointSubscription` is an ordinary non-resumable finite RPC, so make it idempotent and safe for the client to retry. Map `DurableWebSocketAttachmentError` into that RPC's declared error channel. The checkpoint call must be able to run while stream handlers are active. Keep Effect's default unbounded RPC server concurrency, or set a bound above the maximum number of simultaneously open streams so checkpoint calls retain capacity. If the activation disappears after checkpoint persistence but before that RPC sends its `Exit`, the socket resets with `1012`. The client reconnects and starts a new subscription after its durably applied cursor. Register the same declaration on every constructor activation and keep its `id`, schemas, and checkpoint token semantics stable for stored attachments.
+
+`accept(socket, tags)` remains available for a manually created, not-yet-accepted server socket. Prefer `transport.acceptUpgrade(...)` for new upgrades so the socket is accepted exactly once. Use the general `DurableObjectWebSocket` module instead for rooms, presence, broadcasts, or other non-RPC protocols.
 
 ## WebTransport and HTTP/3
 

package/dist/ComputerWorkspace.d.mts

@@ -1,5 +1,5 @@
 import { ComputerArtifactsClient } from "./ComputerArtifacts.mjs";
-import { t as DurableObjectState } from "./DurableObjectState-D3k-WRnd.mjs";
+import { t as DurableObjectState } from "./DurableObjectState-B0A0Y1ef.mjs";
 import { Context, Effect, Layer, Schema, Scope, Stream } from "effect";
 import { CommitView, GitClient, GitCloneOptions, GitCommitOptions, GitDiffOptions, GitFetchOptions, GitLogOptions, GitUpdateRefOptions } from "@cloudflare/computer/git";
 import { ExecSyncResult, RuntimeExecOptions, RuntimeGetOptions, RuntimeKillOptions, ShellValue, SkippedEntry, ThinkWorkspaceCompatibility, WorkspaceClient, WorkspaceRuntimeResult, WorkspaceRuntimeValue as WorkspaceRuntimeValue$1 } from "@cloudflare/computer";

package/dist/ComputerWorkspace.mjs

@@ -1,4 +1,4 @@
-import { t as DurableObjectState } from "./DurableObjectState-CepagPkX.mjs";
+import { t as DurableObjectState } from "./DurableObjectState-D1Ibr6k0.mjs";
 import { fromClient } from "./ComputerArtifacts.mjs";
 import { t as lookup } from "./ComputerWorkspaceHostRegistry-CY5Fv4Ng.mjs";
 import { Context, Effect, Layer, Predicate, Schema, Stream } from "effect";

package/dist/{DurableObjectState-D3k-WRnd.d.mts → DurableObjectState-B0A0Y1ef.d.mts}

@@ -834,6 +834,8 @@ interface WorkerContextService {
   waitUntil<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: WorkerContextWaitUntilOptions<E, R2>): Effect.Effect<void, never, R | R2>;
   waitUntilPropagating<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: Omit<WorkerContextWaitUntilOptions<E, R2>, "mode">): Effect.Effect<void, never, R | R2>;
   readonly passThroughOnException: Effect.Effect<void>;
+  /** Abort the current stateless Worker invocation (`ExecutionContext.abort`). */
+  abort(reason?: string): Effect.Effect<void>;
 }
 declare const WorkerContext_base: Context.ServiceClass<WorkerContext, "effect-cf/WorkerContext", WorkerContextService>;
 /**
@@ -1038,4 +1040,4 @@ declare class DurableObjectState extends DurableObjectState_base {}
  */
 declare const fromDurableObjectState: (state: globalThis.DurableObjectState) => DurableObjectStateService;
 //#endregion
-export { Rpc_d_exports as C, StorageOperationError as D, DurableObjectStorage_d_exports as E, Provider as S, DurableWebSocket as T, Definition$3 as _, NativeRequest as a, RpcDefinition_d_exports as b, WorkerDefinition_d_exports as c, AsyncMethodCloudflareReturn as d, AsyncMethodKey as f, QueueBinding_d_exports as g, QueueDefinition_d_exports as h, ExecutionContext as i, ServiceBinding_d_exports as l, Queue_d_exports as m, DurableObjectStateService as n, WorkerContext as o, AsyncMethodSuccess as p, DurableObjectState_d_exports as r, Worker_d_exports as s, DurableObjectState as t, AsyncMethodArgs as u, Method$2 as v, DurableObjectWebSocket_d_exports as w, ServiceFreeSchema$1 as x, ReservedMethodName$3 as y };
+export { StorageOperationError as A, Rpc_d_exports as C, DurableWebSocket as D, DurableObjectWebSocket_d_exports as E, DurableWebSocketAttachmentError as O, Provider as S, AcceptedUpgrade as T, Definition$3 as _, NativeRequest as a, RpcDefinition_d_exports as b, WorkerDefinition_d_exports as c, AsyncMethodCloudflareReturn as d, AsyncMethodKey as f, QueueBinding_d_exports as g, QueueDefinition_d_exports as h, ExecutionContext as i, DurableObjectStorage_d_exports as k, ServiceBinding_d_exports as l, Queue_d_exports as m, DurableObjectStateService as n, WorkerContext as o, AsyncMethodSuccess as p, DurableObjectState_d_exports as r, Worker_d_exports as s, DurableObjectState as t, AsyncMethodArgs as u, Method$2 as v, AcceptUpgradeOptions as w, ServiceFreeSchema$1 as x, ReservedMethodName$3 as y };

package/dist/{DurableObjectState-CepagPkX.mjs → DurableObjectState-D1Ibr6k0.mjs}

@@ -308,7 +308,8 @@ const fromExecutionContext = (ctx, runPromiseExit = (effect) => Effect.runPromis
 		raw: ctx,
 		waitUntil: (effect, options) => schedule(effect, options, options?.mode ?? "observe"),
 		waitUntilPropagating: (effect, options) => schedule(effect, options, "propagate"),
-		passThroughOnException: Effect.sync(() => ctx.passThroughOnException())
+		passThroughOnException: Effect.sync(() => ctx.passThroughOnException()),
+		abort: (reason) => Effect.sync(() => ctx.abort(reason))
 	};
 };
 //#endregion
@@ -351,4 +352,4 @@ const runPromiseExitPreservingTypedFailures = async (context, effect) => {
 	return exit;
 };
 //#endregion
-export { DurableObjectWebSocket_exports as a, fromExecutionContext as i, DurableObjectState_exports as n, fromWebSocket as o, fromDurableObjectState as r, DurableObjectStorage_exports as s, DurableObjectState as t };
+export { DurableObjectWebSocket_exports as a, DurableObjectStorage_exports as c, fromExecutionContext as i, DurableObjectState_exports as n, DurableWebSocketAttachmentError as o, fromDurableObjectState as r, fromWebSocket as s, DurableObjectState as t };

package/dist/Vitest.d.mts

@@ -1,12 +1,12 @@
 import { c as WorkerEnvironment, s as WorkerEnv } from "./Binding-xJJJPmiD.mjs";
-import { n as DurableObjectStateService, t as DurableObjectState } from "./DurableObjectState-D3k-WRnd.mjs";
-import { o as WorkflowInstanceStatusName } from "./WorkflowBinding-CtrmxfdT.mjs";
+import { n as DurableObjectStateService, t as DurableObjectState } from "./DurableObjectState-B0A0Y1ef.mjs";
+import { o as WorkflowInstanceStatusName } from "./WorkflowBinding-B9_S8tX2.mjs";
 import { Effect, Layer, Schema } from "effect";
 import { DurableObject } from "cloudflare:workers";
 import { adminSecretsStore as adminSecretsStore$1, getQueueResult, introspectWorkflow as introspectWorkflow$1, introspectWorkflowInstance as introspectWorkflowInstance$1 } from "cloudflare:test";
 //#region src/Vitest.d.ts
 /**
- * Provides the Workers pool environment as both {@link WorkerEnvironment} and
+ * Provides the Workers test environment as both {@link WorkerEnvironment} and
  * the active Effect `ConfigProvider`.
  */
 declare const layer: Layer.Layer<WorkerEnvironment>;
@@ -54,7 +54,7 @@ type PagesEventContextInitData<Context> = Context extends globalThis.EventContex
 } : {
   readonly data: Data;
 } : never;
-/** Initialization accepted by Pool Workers for a Pages Function. */
+/** Initialization accepted by the Workers Vitest plugin for a Pages Function. */
 type PagesEventContextInit<Function extends AnyPagesFunction> = PagesEventContextInitBase & PagesEventContextInitParams<Parameters<Function>[0]> & PagesEventContextInitData<Parameters<Function>[0]>;
 /**
  * Invokes a Pages Function with a typed event context and drains its
@@ -64,7 +64,7 @@ declare const pages: <Function extends AnyPagesFunction>(handler: Function, init
 interface QueueWorker {
   queue(batch: globalThis.MessageBatch): Promise<void>;
 }
-/** Input message accepted by Pool Workers' `createMessageBatch` helper. */
+/** Input message accepted by the Workers Vitest plugin's `createMessageBatch` helper. */
 type QueueMessage<Body> = {
   readonly id: string;
   readonly timestamp: Date;
@@ -74,7 +74,7 @@ type QueueMessage<Body> = {
 } | {
   readonly serializedBody: ArrayBuffer | ArrayBufferView;
 });
-/** Acknowledgement and retry result returned by Pool Workers. */
+/** Acknowledgement and retry result returned by the Workers Vitest plugin. */
 type QueueResult = Awaited<ReturnType<typeof getQueueResult>>;
 /** Result of invoking a queue consumer through {@link queue}. */
 interface QueueRunResult<Body> {
@@ -83,7 +83,7 @@ interface QueueRunResult<Body> {
 }
 /**
  * Invokes an Effect-backed queue consumer, drains its `waitUntil` work, and
- * returns Pool Workers' acknowledgement and retry result.
+ * returns the Workers Vitest plugin's acknowledgement and retry result.
  */
 declare const queue: <Body, Instance extends QueueWorker>(Worker: WorkerConstructor<Instance>, queueName: string, messages: readonly QueueMessage<Body>[], workerEnv?: Cloudflare.Env | undefined) => Effect.Effect<QueueRunResult<Body>, never, never>;
 /**
@@ -110,7 +110,7 @@ declare const reset: () => Effect.Effect<void, never, never>;
 declare const abortAllDurableObjects: () => Effect.Effect<void, never, never>;
 /** Gracefully evicts all running Durable Objects while preserving durable storage. */
 declare const evictAllDurableObjects: (options?: DurableObjectEvictionOptions | undefined) => Effect.Effect<void, never, never>;
-/** A D1 migration accepted by Pool Workers. */
+/** A D1 migration accepted by the Workers Vitest plugin. */
 interface D1Migration {
   readonly name: string;
   readonly queries: ReadonlyArray<string>;
@@ -125,7 +125,7 @@ interface SecretsStoreSecret {
     readonly uuid: string;
   };
 }
-/** Effect-native wrapper around Pool Workers' Secrets Store admin API. */
+/** Effect-native wrapper around the Workers Vitest plugin's Secrets Store admin API. */
 interface SecretsStoreAdmin {
   readonly raw: NativeSecretsStoreAdmin;
   readonly create: (value: string) => Effect.Effect<string>;

package/dist/Vitest.mjs

@@ -1,18 +1,18 @@
 import { a as WorkerEnvironment, i as WorkerConfig } from "./ErrorMessage-BM0K-Nik.mjs";
-import { r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-CepagPkX.mjs";
+import { r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-D1Ibr6k0.mjs";
 import { ConfigProvider, Effect, Exit, Layer } from "effect";
 import { env } from "cloudflare:workers";
 import { abortAllDurableObjects as abortAllDurableObjects$1, adminSecretsStore as adminSecretsStore$1, applyD1Migrations as applyD1Migrations$1, createExecutionContext, createMessageBatch, createPagesEventContext, createScheduledController, evictAllDurableObjects as evictAllDurableObjects$1, evictDurableObject as evictDurableObject$1, getQueueResult, introspectWorkflow as introspectWorkflow$1, introspectWorkflowInstance as introspectWorkflowInstance$1, listDurableObjectIds as listDurableObjectIds$1, reset as reset$1, runDurableObjectAlarm as runDurableObjectAlarm$1, runInDurableObject as runInDurableObject$1, waitOnExecutionContext } from "cloudflare:test";
 //#region src/Vitest.ts
 /**
-* Effect-native helpers for tests running in Cloudflare's Vitest Workers pool.
+* Effect-native helpers for tests running in Cloudflare's Workers Vitest plugin.
 *
 * Import this module through the `effect-cf/vitest` subpath. It is intended to
 * run inside the Workers test runtime, where `cloudflare:test` is available.
 */
 const currentEnv = env;
 /**
-* Provides the Workers pool environment as both {@link WorkerEnvironment} and
+* Provides the Workers test environment as both {@link WorkerEnvironment} and
 * the active Effect `ConfigProvider`.
 */
 const layer = Layer.mergeAll(Layer.succeed(WorkerEnvironment, currentEnv), ConfigProvider.layer(WorkerConfig.providerFromEnv(currentEnv)));
@@ -50,7 +50,7 @@ const pages = Effect.fn("effect-cf/vitest/pages")(function* (handler, init) {
 });
 /**
 * Invokes an Effect-backed queue consumer, drains its `waitUntil` work, and
-* returns Pool Workers' acknowledgement and retry result.
+* returns the Workers Vitest plugin's acknowledgement and retry result.
 */
 const queue = Effect.fn("effect-cf/vitest/queue")(function* (Worker, queueName, messages, workerEnv = currentEnv) {
 	return yield* withExecutionContext(Effect.fnUntraced(function* (context) {
@@ -146,7 +146,7 @@ const runWorkflowModifier = Effect.fnUntraced(function* (register, use) {
 			if (callbackExit !== void 0 && Exit.isFailure(callbackExit)) return callbackExit;
 			throw cause;
 		}
-		if (callbackExit === void 0) throw new Error("Pool Workers did not invoke the Workflow modifier callback");
+		if (callbackExit === void 0) throw new Error("The Workers Vitest plugin did not invoke the Workflow modifier callback");
 		return callbackExit;
 	});
 });

package/dist/{WorkflowBinding-CtrmxfdT.d.mts → WorkflowBinding-B9_S8tX2.d.mts}

@@ -1,14 +1,16 @@
 import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-xJJJPmiD.mjs";
-import { x as ServiceFreeSchema } from "./DurableObjectState-D3k-WRnd.mjs";
+import { x as ServiceFreeSchema } from "./DurableObjectState-B0A0Y1ef.mjs";
 import { Context, Effect, Option, Schema } from "effect";
 declare namespace WorkflowBinding_d_exports {
-  export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };
+  export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceLocationHint, WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowInstanceTerminateOptions, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };
 }
 type WorkflowInstanceCreateOptions<Payload> = Omit<CloudflareWorkflowInstanceCreateOptions<Payload>, "params">;
 type WorkflowInstanceCreateBatchOptions<Payload, EncodedPayload = unknown> = ReadonlyArray<{
   readonly payload: Payload;
 } & WorkflowInstanceCreateOptions<EncodedPayload>>;
 type WorkflowInstanceRestartOptions = CloudflareWorkflowInstanceRestartOptions;
+type WorkflowInstanceTerminateOptions = CloudflareWorkflowInstanceTerminateOptions;
+type WorkflowInstanceLocationHint = CloudflareWorkflowInstanceLocationHint;
 type WorkflowInstanceStatusName = CloudflareInstanceStatus["status"];
 interface WorkflowInstanceStatus<Result> {
   readonly status: WorkflowInstanceStatusName;
@@ -23,8 +25,9 @@ interface WorkflowInstance<Result> {
   readonly id: string;
   readonly pause: Effect.Effect<void, WorkflowOperationError>;
   readonly resume: Effect.Effect<void, WorkflowOperationError>;
-  readonly terminate: Effect.Effect<void, WorkflowOperationError>;
+  readonly terminate: (options?: WorkflowInstanceTerminateOptions) => Effect.Effect<void, WorkflowOperationError>;
   readonly restart: (options?: WorkflowInstanceRestartOptions) => Effect.Effect<void, WorkflowOperationError>;
+  readonly delete: Effect.Effect<void, WorkflowOperationError>;
   readonly status: Effect.Effect<WorkflowInstanceStatus<Result>, WorkflowOperationError | WorkflowResultDecodeError>;
   readonly sendEvent: (event: WorkflowInstanceEvent) => Effect.Effect<void, WorkflowOperationError>;
 }

package/dist/index.d.mts

@@ -1,14 +1,15 @@
 import { a as Environment_d_exports, c as WorkerEnvironment, i as Binding_d_exports, n as BindingService, o as WorkerConfig, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-xJJJPmiD.mjs";
 import { l as Artifacts_d_exports } from "./Artifacts-DnHQA-Ax.mjs";
-import { C as Rpc_d_exports, D as StorageOperationError, E as DurableObjectStorage_d_exports, S as Provider, T as DurableWebSocket, _ as Definition$4, a as NativeRequest, b as RpcDefinition_d_exports, c as WorkerDefinition_d_exports, d as AsyncMethodCloudflareReturn, f as AsyncMethodKey, g as QueueBinding_d_exports, h as QueueDefinition_d_exports, i as ExecutionContext, l as ServiceBinding_d_exports, m as Queue_d_exports, o as WorkerContext, p as AsyncMethodSuccess, r as DurableObjectState_d_exports, s as Worker_d_exports, t as DurableObjectState, u as AsyncMethodArgs, v as Method$2, w as DurableObjectWebSocket_d_exports, x as ServiceFreeSchema$1, y as ReservedMethodName$2 } from "./DurableObjectState-D3k-WRnd.mjs";
+import { A as StorageOperationError, C as Rpc_d_exports, D as DurableWebSocket, E as DurableObjectWebSocket_d_exports, O as DurableWebSocketAttachmentError, S as Provider, T as AcceptedUpgrade, _ as Definition$4, a as NativeRequest, b as RpcDefinition_d_exports, c as WorkerDefinition_d_exports, d as AsyncMethodCloudflareReturn, f as AsyncMethodKey, g as QueueBinding_d_exports, h as QueueDefinition_d_exports, i as ExecutionContext, k as DurableObjectStorage_d_exports, l as ServiceBinding_d_exports, m as Queue_d_exports, o as WorkerContext, p as AsyncMethodSuccess, r as DurableObjectState_d_exports, s as Worker_d_exports, t as DurableObjectState, u as AsyncMethodArgs, v as Method$2, w as AcceptUpgradeOptions, x as ServiceFreeSchema$1, y as ReservedMethodName$2 } from "./DurableObjectState-B0A0Y1ef.mjs";
 import { t as Hyperdrive_d_exports } from "./Hyperdrive-z-9fFz15.mjs";
 import { t as ContainerNamespace_d_exports } from "./ContainerNamespace-CFjiLw8b.mjs";
-import { a as WorkflowInstanceCreateOptions, i as WorkflowInstanceCreateBatchOptions, n as WorkflowBinding_d_exports, r as WorkflowInstance, s as WorkflowOperationError, t as WorkflowBindingClient } from "./WorkflowBinding-CtrmxfdT.mjs";
+import { a as WorkflowInstanceCreateOptions, i as WorkflowInstanceCreateBatchOptions, n as WorkflowBinding_d_exports, r as WorkflowInstance, s as WorkflowOperationError, t as WorkflowBindingClient } from "./WorkflowBinding-B9_S8tX2.mjs";
 import { Cause, Config, Context, Data, DateTime, Duration, Effect, Layer, Option, Predicate, Redacted, Schema, Scope } from "effect";
 import { Headers as Headers$1, HttpClient, HttpClientResponse } from "effect/unstable/http";
 import { OtlpExporter, OtlpResource } from "effect/unstable/observability";
 import { D1Client } from "@effect/sql-d1";
 import { DurableObject, WorkflowEntrypoint, WorkflowEvent, WorkflowSleepDuration, WorkflowStep, WorkflowStepConfig, WorkflowStepContext, WorkflowStepEvent, WorkflowTimeoutDuration } from "cloudflare:workers";
+import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";
 import { SqliteClient } from "@effect/sql-sqlite-do";
@@ -1331,16 +1332,77 @@ declare class DurableObjectAlarm extends DurableObjectAlarm_base {
   static readonly layer: Layer.Layer<DurableObjectAlarm, never, DurableObjectState>;
 }
 declare namespace DurableObjectRpcWebSocket_d_exports {
-  export { DurableObjectRpcWebSocket, DurableObjectRpcWebSocketService, LayerOptions$7 as LayerOptions, NativeWebSocketMessage, layer$6 as layer };
+  export { DurableObjectRpcWebSocket, DurableObjectRpcWebSocketService, HeartbeatPolicy, LayerOptions$7 as LayerOptions, NativeWebSocketMessage, ResumableStreamDeclaration, RpcWebSocketAttachment, layer$6 as layer, resumableStream };
+}
+/** Heartbeat handling for Effect's application-level RPC Ping messages. */
+type HeartbeatPolicy = "auto-response" | "passthrough";
+/** Object-shaped application attachment fields that can coexist with adapter metadata. */
+type RpcWebSocketAttachment = object;
+/** A resumable RPC stream declaration understood by the websocket transport. */
+interface ResumableStreamDeclaration<ResumeDescriptor = unknown, Checkpoint = unknown> {
+  /** Stable declaration identifier. Change it when the persisted representation changes. */
+  readonly id: string;
+  /** RPC tag matched against encoded client requests. */
+  readonly rpcTag: string;
+  /** Validates a resume descriptor restored from a websocket attachment. */
+  readonly resumeDescriptorSchema: Schema.Decoder<ResumeDescriptor>;
+  /** Validates an acknowledged checkpoint restored from a websocket attachment. */
+  readonly checkpointSchema: Schema.Decoder<Checkpoint>;
+  /**
+   * Extracts compact persisted state from an initial encoded request. Do not
+   * recycle a subscription key for an unrelated logical subscription while a
+   * delayed checkpoint for the previous subscription can still arrive.
+   */
+  readonly identify: (request: RpcMessage.RequestEncoded) => Option.Option<{
+    readonly subscriptionKey: string;
+    readonly resumeDescriptor: ResumeDescriptor;
+    readonly acknowledgedCheckpoint: Checkpoint;
+  }>;
+  /** Rebuilds the encoded request fields used to restart a handler. */
+  readonly rebuild: (options: {
+    readonly subscriptionKey: string;
+    readonly resumeDescriptor: ResumeDescriptor;
+    readonly acknowledgedCheckpoint: Checkpoint;
+  }) => {
+    readonly payload: unknown;
+    readonly headers?: ReadonlyArray<readonly [string, string]> | undefined;
+    readonly traceId?: string | undefined;
+    readonly spanId?: string | undefined;
+    readonly sampled?: boolean | undefined;
+  };
+  /** Extracts the durable checkpoint represented by one encoded stream value. */
+  readonly checkpointFromValue: (value: RpcMessage.ResponseChunkEncoded["values"][number]) => Option.Option<Checkpoint>;
+  /**
+   * Produces the checkpoint wire token. A logical event must keep the same
+   * token when replayed, and unrelated events must never reuse it during the
+   * lifetime of a subscription key.
+   */
+  readonly checkpointToken: (checkpoint: Checkpoint) => string;
 }
+type AnyResumableStreamDeclaration = ResumableStreamDeclaration<any, any>;
+/** Declares an explicitly resumable RPC stream. */
+declare const resumableStream: <ResumeDescriptor, Checkpoint>(declaration: ResumableStreamDeclaration<ResumeDescriptor, Checkpoint>) => ResumableStreamDeclaration<ResumeDescriptor, Checkpoint>;
 /**
  * Configuration for {@link layer}.
  */
 interface LayerOptions$7 {
   /** Tag used to select hibernated sockets. */
   readonly tag?: string | undefined;
-  /** Socket attachment key used to persist client ids across hibernation. */
+  /** Socket attachment namespace used to persist adapter metadata across hibernation. */
   readonly attachmentKey?: string | undefined;
+  /**
+   * Heartbeat behavior. `"auto-response"` (the default) installs Cloudflare's
+   * hibernation-safe text Ping/Pong response while an RPC socket exists and no
+   * non-resumable RPC operation is active, then removes it while one is pending.
+   * `"passthrough"` leaves the Durable Object's existing auto-response
+   * configuration unchanged and makes the application responsible for waking a
+   * lost pending operation.
+   * Cloudflare's pair is global to the Durable Object, so use `"passthrough"`
+   * when RPC and unrelated websocket protocols share one object.
+   */
+  readonly heartbeat?: HeartbeatPolicy | undefined;
+  /** Explicit stream declarations that may be reconstructed after activation loss. */
+  readonly resumableStreams?: ReadonlyArray<AnyResumableStreamDeclaration> | undefined;
 }
 /** Native websocket event payload accepted by Cloudflare Durable Objects. */
 type NativeWebSocketMessage = string | ArrayBuffer;
@@ -1348,10 +1410,28 @@ type NativeWebSocketMessage = string | ArrayBuffer;
  * Service API used to wire websocket lifecycle events to Effect RPC server protocol.
  */
 interface DurableObjectRpcWebSocketService {
-  readonly accept: (socket: DurableWebSocket) => Effect.Effect<void>;
+  /** Accepts a new, not-yet-accepted socket with the RPC tag and any application tags. */
+  readonly accept: (socket: DurableWebSocket, tags?: ReadonlyArray<string>) => Effect.Effect<void>;
+  /**
+   * Creates and accepts a websocket upgrade without double-accepting the server
+   * socket. Application attachment fields are shallow-merged with the adapter's
+   * metadata namespace.
+   */
+  readonly acceptUpgrade: <Attachment extends RpcWebSocketAttachment = RpcWebSocketAttachment>(options?: AcceptUpgradeOptions<Attachment>) => Effect.Effect<AcceptedUpgrade<Attachment>, DurableWebSocketAttachmentError>;
   readonly message: (socket: DurableWebSocket, message: NativeWebSocketMessage) => Effect.Effect<void>;
   readonly close: (socket: DurableWebSocket) => Effect.Effect<void>;
   readonly error: (socket: DurableWebSocket, cause: unknown) => Effect.Effect<void>;
+  /**
+   * Persists forward checkpoint progress for a resumable stream. Returns `true`
+   * only when the checkpoint advances the current pending chunk batch. A failed
+   * websocket attachment write resets the connection and fails with
+   * `DurableWebSocketAttachmentError`.
+   */
+  readonly checkpoint: <ResumeDescriptor, Checkpoint>(declaration: ResumableStreamDeclaration<ResumeDescriptor, Checkpoint>, options: {
+    readonly clientId: number;
+    readonly subscriptionKey: string;
+    readonly checkpoint: Checkpoint;
+  }) => Effect.Effect<boolean, DurableWebSocketAttachmentError>;
 }
 declare const DurableObjectRpcWebSocket_base: Context.ServiceClass<DurableObjectRpcWebSocket, "effect-cf/DurableObjectRpcWebSocket", DurableObjectRpcWebSocketService>;
 /**
@@ -1359,7 +1439,13 @@ declare const DurableObjectRpcWebSocket_base: Context.ServiceClass<DurableObject
  */
 declare class DurableObjectRpcWebSocket extends DurableObjectRpcWebSocket_base {}
 /**
- * Builds a layer that bridges Durable Object websocket events to `RpcServer.Protocol`.
+ * Builds a hibernation-aware transport that bridges Durable Object websocket
+ * events to `RpcServer.Protocol`.
+ *
+ * The layer restores idle tagged sockets and explicitly declared resumable
+ * streams after constructor recreation. A socket that lost any other in-flight
+ * request is closed with code 1012, which the stock Effect socket protocol
+ * reports as an `RpcClientError` containing `SocketCloseError`.
  */
 declare const layer$6: (options?: LayerOptions$7) => Layer.Layer<RpcServer.Protocol | DurableObjectRpcWebSocket, never, DurableObjectState | RpcSerialization.RpcSerialization>;
 declare namespace DurableObjectSqlite_d_exports {
@@ -1491,7 +1577,7 @@ declare const layer$4: <Self>(tag: Context.Service<Self, EmailClient>, definitio
 declare const make$5: <Id extends string>(id: Id) => TagClass$6<EmailService<Id>, Id>;
 declare const Tag$7: <Self>() => <Id extends string>(id: Id) => TagClass$6<Self, Id>;
 declare namespace Images_d_exports {
-  export { DrawStepOptions, HostedImagesClient, ImageDrawOptions, ImageHandleClient, ImageInfoResponse, ImageInputOptions, ImageInputValue, ImageList, ImageListOptions, ImageMetadata, ImageOutputOptions, ImageTransform, ImageTransformationOutputOptions, ImageTransformationResult, ImageUpdateOptions, ImageUploadOptions, ImageUploadValue, ImagesClient, ImagesDefinition, ImagesOperationError, ImagesRuntimeBinding, ImagesService, ImagesTransformationResultClient, LayerOptions$5 as LayerOptions, ProcessOptions, Step, Steps, Tag$6 as Tag, TagClass$5 as TagClass, TypeId, draw, empty, isImagesBinding, layer$3 as layer, make$4 as make, makeClient$3 as makeClient, transform };
+  export { DrawStepOptions, HostedImagesClient, ImageDirectUploadOptions, ImageDirectUploadResult, ImageDrawOptions, ImageHandleClient, ImageInfoResponse, ImageInputOptions, ImageInputValue, ImageList, ImageListOptions, ImageMetadata, ImageOutputOptions, ImageSignedUrlOptions, ImageTransform, ImageTransformationOutputOptions, ImageTransformationResponseOptions, ImageTransformationResult, ImageUpdateOptions, ImageUploadOptions, ImageUploadValue, ImagesClient, ImagesDefinition, ImagesOperationError, ImagesRuntimeBinding, ImagesService, ImagesTransformationResultClient, LayerOptions$5 as LayerOptions, ProcessOptions, Step, Steps, Tag$6 as Tag, TagClass$5 as TagClass, TextOptions, TypeId, draw, empty, isImagesBinding, layer$3 as layer, make$4 as make, makeClient$3 as makeClient, transform };
 }
 declare const TypeId: "~effect-cf/Images/Steps";
 type TypeId = typeof TypeId;
@@ -1517,12 +1603,17 @@ type ImageDrawOptions = CloudflareImageDrawOptions;
 type ImageInputOptions = CloudflareImageInputOptions;
 type ImageOutputOptions = CloudflareImageOutputOptions;
 type ImageTransformationOutputOptions = CloudflareImageTransformationOutputOptions;
+type ImageTransformationResponseOptions = CloudflareImageTransformationResponseOptions;
 type ImageTransformationResult = CloudflareImageTransformationResult;
 type ImageUploadOptions = CloudflareImageUploadOptions;
 type ImageUpdateOptions = CloudflareImageUpdateOptions;
 type ImageListOptions = CloudflareImageListOptions;
 type ImageList = CloudflareImageList;
 type ImageMetadata = CloudflareImageMetadata;
+type ImageSignedUrlOptions = CloudflareImageSignedUrlOptions;
+type ImageDirectUploadOptions = CloudflareImageDirectUploadOptions;
+type ImageDirectUploadResult = CloudflareImageDirectUploadResult;
+type TextOptions = CloudflareTextOptions;
 type ImageInputValue = ReadableStream<Uint8Array> | ArrayBuffer;
 type ImageUploadValue = ReadableStream<Uint8Array> | ArrayBuffer;
 interface DrawStepOptions {
@@ -1598,14 +1689,18 @@ interface Steps {
   readonly [TypeId]: typeof TypeId;
   readonly steps: ReadonlyArray<Step>;
 }
-interface ProcessOptions {
+type ProcessOptions = {
   readonly stream: ImageInputValue;
   readonly inputOptions?: ImageInputOptions;
   readonly outputOptions: ImageOutputOptions;
-}
+} | {
+  readonly text: string;
+  readonly textOptions: TextOptions;
+  readonly outputOptions: ImageOutputOptions;
+};
 interface ImagesTransformationResultClient {
   readonly raw: CloudflareImageTransformationResult;
-  readonly response: Effect.Effect<CloudflareResponse, ImagesOperationError>;
+  readonly response: (options?: ImageTransformationResponseOptions) => Effect.Effect<CloudflareResponse, ImagesOperationError>;
   readonly contentType: Effect.Effect<string, ImagesOperationError>;
   readonly image: (options?: ImageTransformationOutputOptions) => Effect.Effect<ReadableStream<Uint8Array>, ImagesOperationError>;
 }
@@ -1613,6 +1708,7 @@ interface ImageHandleClient {
   readonly raw: CloudflareImageHandle;
   readonly details: Effect.Effect<Option.Option<ImageMetadata>, ImagesOperationError>;
   readonly bytes: Effect.Effect<Option.Option<ReadableStream<Uint8Array>>, ImagesOperationError>;
+  readonly signedUrl: (options: ImageSignedUrlOptions) => Effect.Effect<string, ImagesOperationError>;
   readonly update: (options: ImageUpdateOptions) => Effect.Effect<ImageMetadata, ImagesOperationError>;
   readonly delete: Effect.Effect<boolean, ImagesOperationError>;
 }
@@ -1620,16 +1716,19 @@ interface HostedImagesClient {
   readonly image: (imageId: string) => ImageHandleClient;
   readonly upload: (image: ImageUploadValue, options?: ImageUploadOptions) => Effect.Effect<ImageMetadata, ImagesOperationError>;
   readonly list: (options?: ImageListOptions) => Effect.Effect<ImageList, ImagesOperationError>;
+  readonly createDirectUpload: (options?: ImageDirectUploadOptions) => Effect.Effect<ImageDirectUploadResult, ImagesOperationError>;
   readonly rawUnsafe: Effect.Effect<CloudflareHostedImagesBinding>;
 }
 interface ImagesRuntimeBinding {
   readonly info: (image: ImageInputValue, options?: ImageInputOptions) => Promise<ImageInfoResponse>;
   readonly input: (image: ImageInputValue, options?: ImageInputOptions) => CloudflareImageTransformer;
+  readonly text?: (content: string, options: TextOptions) => CloudflareImageTransformer;
   readonly hosted?: CloudflareHostedImagesBinding;
 }
 interface ImagesClient {
   readonly info: (image: ImageInputValue, options?: ImageInputOptions) => Effect.Effect<ImageInfoResponse, ImagesOperationError>;
   readonly input: (image: ImageInputValue, options?: ImageInputOptions) => Effect.Effect<CloudflareImageTransformer, ImagesOperationError>;
+  readonly text: (content: string, options: TextOptions) => Effect.Effect<CloudflareImageTransformer, ImagesOperationError>;
   readonly process: (steps: Steps, options: ProcessOptions) => Effect.Effect<ImagesTransformationResultClient, ImagesOperationError>;
   readonly hosted: Option.Option<HostedImagesClient>;
   readonly rawUnsafe: Effect.Effect<ImagesRuntimeBinding>;