effect-cf 0.23.0 → 0.24.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # effect-cf
 
+## 0.24.0
+
+### Minor Changes
+
+- [#82](https://github.com/danieljvdm/effect-cf/pull/82) [`877f289`](https://github.com/danieljvdm/effect-cf/commit/877f289a19ff15bdca1e7f9320aee3be1cffb3de) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Add an `effect-cf/vitest` entrypoint with Effect-native Workers environment, fetch, queue, execution-context, and scoped Workflow testing helpers for Cloudflare's Vitest Workers pool.
+
+- [#84](https://github.com/danieljvdm/effect-cf/pull/84) [`9bbd554`](https://github.com/danieljvdm/effect-cf/commit/9bbd5543ca463447d0eb6a08d6441c7b72086b40) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Add Effect-native scheduled and Pages runners, Durable Object test controls, D1 migrations, binding reset helpers, Workflow introspectors, and a Secrets Store admin client to `effect-cf/vitest`. The optional `@cloudflare/vitest-pool-workers` peer dependency now requires `^0.21.3`.
+
+## 0.23.1
+
+### Patch Changes
+
+- [#80](https://github.com/danieljvdm/effect-cf/pull/80) [`cd83c7c`](https://github.com/danieljvdm/effect-cf/commit/cd83c7cc86bb8edfcd1449c17cca1c26aecc8a06) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Stop failing workflow status reads with `WorkflowResultDecodeError` when Cloudflare reports `output: null` for a non-complete instance. The wrapped `WorkflowInstance.status` now returns the real status (e.g. `errored`) with `Option.none()` output and the preserved `error`, while a completed workflow with a `Schema.Null` result still decodes `null` as `Option.some(null)`.
+
 ## 0.23.0
 
 ### Minor Changes

package/README.md

@@ -43,6 +43,157 @@ Runtime creation belongs at Cloudflare entrypoints, not inside binding helpers.
 - `Workflow` - typed Workflow entrypoints, steps, starter clients, and instance types
 - `Rpc` - Cloudflare RPC type helpers and scoped disposal utilities
 - `WorkerConfig` - Effect `Config` helpers backed by Cloudflare `env`
+- `effect-cf/vitest` - Effect-native runners and scoped test helpers for Cloudflare's Vitest Workers pool
+
+## Vitest Workers Pool
+
+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),
+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.
+
+```ts
+import { assert, it } from "@effect/vitest";
+import { Config, Effect } from "effect";
+import * as PoolWorkers from "effect-cf/vitest";
+
+import WorkerEntrypoint from "../src/index";
+
+it.effect("serves a request", () =>
+  Effect.gen(function* () {
+    const response = yield* PoolWorkers.fetch(
+      WorkerEntrypoint,
+      new Request("https://worker.test/health"),
+    );
+
+    assert.strictEqual(response.status, 200);
+  }),
+);
+
+it.effect("reads Wrangler vars", () =>
+  Config.string("APP_NAME").pipe(
+    Effect.tap((appName) => assert.strictEqual(appName, "test-app")),
+    Effect.provide(PoolWorkers.layer),
+  ),
+);
+```
+
+Queue consumers can be invoked with typed message bodies while retaining the
+pool's acknowledgement and retry result:
+
+```ts
+it.effect("acknowledges a job", () =>
+  Effect.gen(function* () {
+    const { result } = yield* PoolWorkers.queue(MyQueueConsumer, "jobs", [
+      {
+        id: "job-1",
+        timestamp: new Date(),
+        attempts: 1,
+        body: { accountId: "account-1" },
+      },
+    ]);
+
+    assert.deepStrictEqual(result.explicitAcks, ["job-1"]);
+  }),
+);
+```
+
+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.
+
+```ts
+it.effect("runs the cron handler", () =>
+  PoolWorkers.scheduled(worker.scheduled, {
+    cron: "30 * * * *",
+    scheduledTime: new Date("2030-01-01T00:00:00Z"),
+  }),
+);
+
+it.effect("runs a Pages Function", () =>
+  Effect.gen(function* () {
+    const response = yield* PoolWorkers.pages(onRequest, {
+      request: new Request("https://pages.test/users/dan"),
+      params: { user: "dan" },
+      data: { authenticated: true },
+    });
+
+    assert.strictEqual(response.status, 200);
+  }),
+);
+```
+
+`runInDurableObject` carries the test's Effect context into the Durable Object
+I/O context and provides the same wrapped `DurableObjectState` service used by
+production handlers. Typed failures remain in the Effect error channel.
+
+```ts
+it.effect("seeds a Durable Object", () =>
+  Effect.gen(function* () {
+    const stub = env.COUNTERS.getByName("home");
+
+    yield* PoolWorkers.runInDurableObject(stub, () =>
+      Effect.gen(function* () {
+        const state = yield* DurableObjectState;
+        yield* state.storage.put("count", 41);
+      }),
+    );
+
+    assert.strictEqual(yield* PoolWorkers.runDurableObjectAlarm(stub), true);
+
+    // Recreate in-memory state while preserving Durable Object storage.
+    yield* PoolWorkers.evictDurableObject(stub);
+  }),
+);
+```
+
+The subpath also exposes Effects for `listDurableObjectIds`, `reset`,
+`abortAllDurableObjects`, `evictAllDurableObjects`, and `applyD1Migrations`.
+`adminSecretsStore` returns an Effect-native admin client whose `create`,
+`update`, `duplicate`, `delete`, `list`, and `get` operations are Effects.
+
+`withExecutionContext` supports lower-level tests that need a native
+`ExecutionContext`. Workflow introspectors and all of their modifiers and query
+operations are Effect-native. They are disposed with the current Effect scope,
+and modifier callbacks carry the caller's Effect context and typed failures.
+
+```ts
+it.effect("controls a Workflow instance", () =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const instanceId = crypto.randomUUID();
+      const instance = yield* PoolWorkers.introspectWorkflowInstance(
+        env.REPORT_WORKFLOW,
+        instanceId,
+      );
+
+      yield* instance.modify((modifier) =>
+        Effect.gen(function* () {
+          yield* modifier.disableSleeps();
+          yield* modifier.mockStepResult({ name: "render-report" }, "reports/test.json");
+        }),
+      );
+      yield* Effect.promise(() =>
+        env.REPORT_WORKFLOW.create({
+          id: instanceId,
+          params: { reportId: "test", requestedBy: "dan@example.com" },
+        }),
+      );
+
+      yield* instance.waitForStatus("complete");
+      assert.deepStrictEqual(yield* instance.getOutput, {
+        objectKey: "reports/test.json",
+        notified: true,
+      });
+    }),
+  ),
+);
+```
+
+Use `introspectWorkflow` when the instance ID is not known before creation. Its
+`modifyAll` and `get` operations are Effects, and each instance returned by
+`get` uses the same Effect-native interface shown above.
 
 ## Worker Example
 

package/dist/{Hyperdrive-COyg7R26.d.mts → Binding-Bq_FPzlt.d.mts}

@@ -88,7 +88,7 @@ declare namespace WorkerConfig {
   const layerWith: (makeProvider: (env: WorkerEnv) => ConfigProvider.ConfigProvider) => Layer.Layer<never, never, WorkerEnvironment>;
 }
 declare namespace Binding_d_exports {
-  export { BindingNotFoundError, BindingService, BindingValidationError, Service, TypeId, ValidationOptions, layer$1 as layer };
+  export { BindingNotFoundError, BindingService, BindingValidationError, Service, TypeId, ValidationOptions, layer };
 }
 /** Internal type id marker used by binding helper services. */
 declare const TypeId: "~effect-cf/Binding";
@@ -127,43 +127,11 @@ interface BindingService<Self, Id extends string, Service> extends Context.Servi
   readonly binding: string;
   readonly layer: Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
-declare function layer$1<Self, Resource>(tag: Context.Service<Self, Resource>, binding: string, isResource: (value: unknown) => value is Resource, wrap?: undefined, options?: ValidationOptions): Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare function layer$1<Self, Resource, Service>(tag: Context.Service<Self, Service>, binding: string, isResource: (value: unknown) => value is Resource, wrap: (resource: Resource) => Service, options?: ValidationOptions): Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare function layer<Self, Resource>(tag: Context.Service<Self, Resource>, binding: string, isResource: (value: unknown) => value is Resource, wrap?: undefined, options?: ValidationOptions): Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare function layer<Self, Resource, Service>(tag: Context.Service<Self, Service>, binding: string, isResource: (value: unknown) => value is Resource, wrap: (resource: Resource) => Service, options?: ValidationOptions): Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const Service: <Self>() => {
   <Id extends string, Resource>(id: Id, binding: string, isResource: (value: unknown) => value is Resource, wrap?: undefined, options?: ValidationOptions): BindingService<Self, Id, Resource>;
   <Id extends string, Resource, Service>(id: Id, binding: string, isResource: (value: unknown) => value is Resource, wrap: (resource: Resource) => Service, options?: ValidationOptions): BindingService<Self, Id, Service>;
 };
-declare namespace Hyperdrive_d_exports {
-  export { HyperdriveClient, HyperdriveDefinition, HyperdriveService, LayerOptions, Tag, TagClass, isHyperdrive, layer, make, makeClient };
-}
-/** Typed Hyperdrive binding definition. */
-interface HyperdriveDefinition {
-  /** Binding name as configured in `wrangler.jsonc`. */
-  readonly binding: string;
-}
-interface HyperdriveClient {
-  readonly connectionString: string;
-  readonly rawUnsafe: Effect.Effect<Hyperdrive>;
-  readonly definition: HyperdriveDefinition;
-}
-declare const HyperdriveServiceTypeId: unique symbol;
-/** Nominal service marker for Hyperdrive services created with {@link make}. */
-interface HyperdriveService<Id extends string> {
-  readonly [HyperdriveServiceTypeId]: {
-    readonly id: Id;
-  };
-}
-type LayerOptions = {
-  readonly binding: string;
-};
-interface TagClass<Self, Id extends string> extends Context.ServiceClass<Self, Id, HyperdriveClient> {
-  readonly id: Id;
-  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-}
-declare const isHyperdrive: (value: unknown) => value is Hyperdrive;
-declare const makeClient: (definition: HyperdriveDefinition) => (hyperdrive: Hyperdrive) => HyperdriveClient;
-declare const layer: <Self>(tag: Context.Service<Self, HyperdriveClient>, definition: HyperdriveDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make: <Id extends string>(id: Id) => TagClass<HyperdriveService<Id>, Id>;
-declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { BindingService as a, Environment_d_exports as c, WorkerEnvironment as d, BindingNotFoundError as i, WorkerConfig as l, LayerOptions as n, BindingValidationError as o, TagClass as r, Binding_d_exports as s, Hyperdrive_d_exports as t, WorkerEnv as u };
+export { Environment_d_exports as a, WorkerEnvironment as c, Binding_d_exports as i, BindingService as n, WorkerConfig as o, BindingValidationError as r, WorkerEnv as s, BindingNotFoundError as t };

package/dist/DurableObjectState-8sgBJB0s.mjs

@@ -0,0 +1,384 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Cause, Config, ConfigProvider, Context, Data, Effect, Exit, Option, Result, Schema } from "effect";
+//#region src/Environment.ts
+var Environment_exports = /* @__PURE__ */ __exportAll({
+	WorkerConfig: () => WorkerConfig,
+	WorkerEnvironment: () => WorkerEnvironment
+});
+/**
+* Context service for reading worker bindings from the current `env` object.
+*/
+var WorkerEnvironment = class extends Context.Service()("effect-cf/WorkerEnvironment") {};
+let WorkerConfig;
+(function(_WorkerConfig) {
+	_WorkerConfig.string = (name) => Config.string(name);
+	_WorkerConfig.redacted = (name) => Config.redacted(name);
+	_WorkerConfig.number = (name) => Config.number(name);
+	_WorkerConfig.integer = (name) => Config.int(name);
+	_WorkerConfig.boolean = (name) => Config.boolean(name);
+	const providerFromEnv = _WorkerConfig.providerFromEnv = (env, options) => ConfigProvider.fromUnknown(env, options);
+	const providerWith = _WorkerConfig.providerWith = (makeProvider) => Effect.map(WorkerEnvironment, makeProvider);
+	const provider = _WorkerConfig.provider = providerWith(providerFromEnv);
+	_WorkerConfig.layer = _WorkerConfig.providerLayer = ConfigProvider.layer(provider);
+	_WorkerConfig.layerWith = (makeProvider) => ConfigProvider.layer(providerWith(makeProvider));
+})(WorkerConfig || (WorkerConfig = {}));
+//#endregion
+//#region src/internal/ErrorMessage.ts
+/**
+* Renders the most useful human-readable description of an unknown `cause`
+* for use in tagged error `message` getters.
+*/
+const causeMessage = (cause) => {
+	if (typeof cause === "object" && cause !== null) {
+		const message = Reflect.get(cause, "message");
+		if (typeof message === "string" && message.length > 0) return message;
+	}
+	try {
+		return String(cause);
+	} catch {
+		return "unknown cause";
+	}
+};
+/** Renders a violation list as a single `path: message; ...` line. */
+const violationsMessage = (violations) => violations.map((violation) => `${violation.path}: ${violation.message}`).join("; ");
+//#endregion
+//#region src/DurableObjectStorage.ts
+var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
+	StorageOperationError: () => StorageOperationError,
+	fromDurableObjectStorage: () => fromDurableObjectStorage
+});
+/** Error type used when a storage operation throws or rejects. */
+var StorageOperationError = class extends Data.TaggedError("StorageOperationError") {
+	get message() {
+		return `Durable Object storage ${this.operation} failed: ${causeMessage(this.cause)}`;
+	}
+};
+const storageError = (operation, cause) => new StorageOperationError({
+	operation,
+	cause
+});
+const tryStorageSync = (operation, evaluate) => Effect.try({
+	try: evaluate,
+	catch: (cause) => storageError(operation, cause)
+});
+const tryStoragePromise = (operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => storageError(operation, cause)
+});
+const fromSqlCursor = (cursor) => ({
+	next: () => tryStorageSync("sql.next", () => cursor.next()),
+	toArray: () => tryStorageSync("sql.toArray", () => cursor.toArray()),
+	one: () => tryStorageSync("sql.one", () => cursor.one()),
+	raw: () => tryStorageSync("sql.raw", () => cursor.raw()),
+	get columnNames() {
+		return cursor.columnNames;
+	},
+	rowsRead: tryStorageSync("sql.rowsRead", () => cursor.rowsRead),
+	rowsWritten: tryStorageSync("sql.rowsWritten", () => cursor.rowsWritten)
+});
+const fromSqlStorage = (sql) => ({
+	exec: (query, ...bindings) => tryStorageSync("sql.exec", () => fromSqlCursor(sql.exec(query, ...bindings))),
+	get databaseSize() {
+		return sql.databaseSize;
+	}
+});
+const schemaBackedSyncKvStorage = (kv, definition) => {
+	const encodeKey = Schema.encodeEffect(definition.key);
+	const decodeKey = Schema.decodeUnknownEffect(definition.key);
+	const encodeValue = Schema.encodeEffect(definition.value);
+	const decodeValue = Schema.decodeUnknownEffect(definition.value);
+	return {
+		get: (key) => Effect.gen(function* () {
+			const encodedKey = yield* encodeKey(key);
+			const encodedValue = yield* tryStorageSync("kv.get", () => kv.get(encodedKey));
+			if (encodedValue === void 0) return Option.none();
+			return yield* decodeValue(encodedValue).pipe(Effect.map(Option.some));
+		}),
+		put: (key, value) => Effect.gen(function* () {
+			const encodedKey = yield* encodeKey(key);
+			const encodedValue = yield* encodeValue(value);
+			yield* tryStorageSync("kv.put", () => kv.put(encodedKey, encodedValue));
+		}),
+		delete: (key) => Effect.gen(function* () {
+			const encodedKey = yield* encodeKey(key);
+			return yield* tryStorageSync("kv.delete", () => kv.delete(encodedKey));
+		}),
+		list: (options) => Effect.gen(function* () {
+			const entries = Array.from(yield* tryStorageSync("kv.list", () => kv.list(options)));
+			const decoded = [];
+			for (const [key, value] of entries) decoded.push([yield* decodeKey(key), yield* decodeValue(value)]);
+			return decoded;
+		})
+	};
+};
+const fromSyncKvStorage = (kv) => ({
+	get: (key) => tryStorageSync("kv.get", () => kv.get(key)),
+	put: (key, value) => tryStorageSync("kv.put", () => kv.put(key, value)),
+	delete: (key) => tryStorageSync("kv.delete", () => kv.delete(key)),
+	list: (options) => tryStorageSync("kv.list", () => Array.from(kv.list(options))),
+	schema: (definition) => schemaBackedSyncKvStorage(kv, definition)
+});
+const fromDurableObjectTransaction = (txn) => ({
+	get: (keyOrKeys, options) => Array.isArray(keyOrKeys) ? tryStoragePromise("transaction.get", () => txn.get(keyOrKeys, options)) : tryStoragePromise("transaction.get", () => txn.get(keyOrKeys, options)),
+	list: (options) => tryStoragePromise("transaction.list", () => txn.list(options)),
+	put: (keyOrEntries, valueOrOptions, maybeOptions) => tryStoragePromise("transaction.put", () => typeof keyOrEntries === "string" ? txn.put(keyOrEntries, valueOrOptions, maybeOptions) : txn.put(keyOrEntries, valueOrOptions)),
+	delete: (keyOrKeys, options) => Array.isArray(keyOrKeys) ? tryStoragePromise("transaction.delete", () => txn.delete(keyOrKeys, options)) : tryStoragePromise("transaction.delete", () => txn.delete(keyOrKeys, options)),
+	rollback: () => tryStorageSync("transaction.rollback", () => txn.rollback()),
+	getAlarm: (options) => tryStoragePromise("transaction.getAlarm", () => txn.getAlarm(options)),
+	setAlarm: (scheduledTime, options) => tryStoragePromise("transaction.setAlarm", () => txn.setAlarm(scheduledTime, options)),
+	deleteAlarm: (options) => tryStoragePromise("transaction.deleteAlarm", () => txn.deleteAlarm(options))
+});
+/**
+* Wraps native Cloudflare storage APIs as Effect-returning helpers.
+*/
+const fromDurableObjectStorage = (storage) => ({
+	get: (key, options) => tryStoragePromise("get", () => storage.get(key, options)),
+	put: (key, value, options) => tryStoragePromise("put", () => storage.put(key, value, options)),
+	delete: (key, options) => tryStoragePromise("delete", () => storage.delete(key, options)),
+	deleteAll: (options) => tryStoragePromise("deleteAll", () => storage.deleteAll(options)),
+	getAlarm: (options) => tryStoragePromise("getAlarm", () => storage.getAlarm(options)),
+	setAlarm: (scheduledTime, options) => tryStoragePromise("setAlarm", () => storage.setAlarm(scheduledTime, options)),
+	deleteAlarm: (options) => tryStoragePromise("deleteAlarm", () => storage.deleteAlarm(options)),
+	transactionSync: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.suspend(() => {
+		try {
+			return Effect.succeed(storage.transactionSync(() => {
+				const exit = Effect.runSyncExitWith(context)(closure());
+				if (Exit.isSuccess(exit)) return exit.value;
+				throw exit;
+			}));
+		} catch (cause) {
+			if (Exit.isExit(cause) && Exit.isFailure(cause)) return Effect.failCause(cause.cause);
+			return Effect.fail(storageError("transactionSync", cause));
+		}
+	}))),
+	transaction: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.callback((resume) => {
+		storage.transaction(async (txn) => {
+			const exit = await Effect.runPromiseExitWith(context)(closure(fromDurableObjectTransaction(txn)));
+			if (Exit.isSuccess(exit)) return exit.value;
+			throw exit;
+		}).then((value) => resume(Effect.succeed(value)), (cause) => {
+			if (Exit.isExit(cause) && Exit.isFailure(cause)) resume(Effect.failCause(cause.cause));
+			else resume(Effect.fail(storageError("transaction", cause)));
+		});
+	}))),
+	sync: () => tryStoragePromise("sync", () => storage.sync()),
+	getCurrentBookmark: () => tryStoragePromise("getCurrentBookmark", () => storage.getCurrentBookmark()),
+	onNextSessionRestoreBookmark: (bookmark) => tryStoragePromise("onNextSessionRestoreBookmark", () => storage.onNextSessionRestoreBookmark(bookmark)),
+	sql: fromSqlStorage(storage.sql),
+	kv: fromSyncKvStorage(storage.kv)
+});
+//#endregion
+//#region src/DurableObjectWebSocket.ts
+var DurableObjectWebSocket_exports = /* @__PURE__ */ __exportAll({
+	DurableWebSocketAttachmentError: () => DurableWebSocketAttachmentError,
+	DurableWebSocketCloseError: () => DurableWebSocketCloseError,
+	DurableWebSocketSendError: () => DurableWebSocketSendError,
+	acceptUpgrade: () => acceptUpgrade,
+	attachment: () => attachment,
+	fromWebSocket: () => fromWebSocket,
+	handlers: () => handlers
+});
+/** Error raised when sending on a Durable Object websocket fails. */
+var DurableWebSocketSendError = class extends Data.TaggedError("DurableWebSocketSendError") {
+	get message() {
+		return `Durable Object websocket send failed: ${causeMessage(this.cause)}`;
+	}
+};
+/** Error raised when closing a Durable Object websocket fails. */
+var DurableWebSocketCloseError = class extends Data.TaggedError("DurableWebSocketCloseError") {
+	get message() {
+		return `Durable Object websocket close failed: ${causeMessage(this.cause)}`;
+	}
+};
+/** Error raised when serializing or deserializing a websocket attachment fails. */
+var DurableWebSocketAttachmentError = class extends Data.TaggedError("DurableWebSocketAttachmentError") {
+	get message() {
+		return `Durable Object websocket attachment ${this.operation} failed: ${causeMessage(this.cause)}`;
+	}
+};
+const wrappers = /* @__PURE__ */ new WeakMap();
+/** Wraps a native Cloudflare websocket in the Effect-native Durable Object API. */
+const fromWebSocket = (raw) => {
+	const existing = wrappers.get(raw);
+	if (existing !== void 0) return existing;
+	const socket = {
+		raw,
+		send: (data) => Effect.try({
+			try: () => raw.send(data),
+			catch: (cause) => new DurableWebSocketSendError({ cause })
+		}),
+		close: (code, reason) => Effect.try({
+			try: () => raw.close(code, reason),
+			catch: (cause) => new DurableWebSocketCloseError({ cause })
+		}),
+		serializeAttachment: (value) => Effect.try({
+			try: () => raw.serializeAttachment(value),
+			catch: (cause) => new DurableWebSocketAttachmentError({
+				operation: "serialize",
+				cause
+			})
+		}),
+		deserializeAttachment: Effect.try({
+			try: () => raw.deserializeAttachment(),
+			catch: (cause) => new DurableWebSocketAttachmentError({
+				operation: "deserialize",
+				cause
+			})
+		})
+	};
+	wrappers.set(raw, socket);
+	return socket;
+};
+/**
+* Accepts a websocket upgrade and registers the server socket on `DurableObjectState`.
+*
+* @example
+* ```ts
+* const response = yield* DurableObjectWebSocket.acceptUpgrade({
+*   tags: ["room:general"],
+* });
+*
+* return response.response;
+* ```
+*/
+const acceptUpgrade = Effect.fn("DurableObjectWebSocket.acceptUpgrade")(function* (options = {}) {
+	const state = yield* DurableObjectState;
+	const pair = new WebSocketPair();
+	const client = pair[0];
+	const server = fromWebSocket(pair[1]);
+	if (options.attachment !== void 0) yield* server.serializeAttachment(options.attachment);
+	yield* state.acceptWebSocket(server, options.tags === void 0 ? void 0 : [...options.tags]);
+	return {
+		client,
+		server,
+		response: new Response(null, {
+			status: 101,
+			webSocket: client
+		})
+	};
+});
+/** Creates typed attachment helpers for accepted and rehydrated sockets. */
+const attachment = (schema) => {
+	const serialize = (socket, value) => Schema.encodeEffect(schema)(value).pipe(Effect.mapError((cause) => new DurableWebSocketAttachmentError({
+		operation: "serialize",
+		cause
+	})), Effect.flatMap((encoded) => socket.serializeAttachment(encoded)));
+	const deserialize = (socket) => Effect.gen(function* () {
+		const value = yield* socket.deserializeAttachment;
+		if (value === null || value === void 0) return Option.none();
+		return Option.some(yield* Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError((cause) => new DurableWebSocketAttachmentError({
+			operation: "deserialize",
+			cause
+		}))));
+	});
+	const rehydrate = (options = {}) => Effect.gen(function* () {
+		const sockets = yield* (yield* DurableObjectState).getWebSockets(options.tag);
+		const restored = [];
+		const onInvalid = options.onInvalid ?? "ignore";
+		for (const socket of sockets) {
+			const decoded = yield* Effect.result(deserialize(socket));
+			if (Result.isSuccess(decoded) && Option.isSome(decoded.success)) {
+				restored.push({
+					socket,
+					attachment: decoded.success.value
+				});
+				continue;
+			}
+			if (Result.isFailure(decoded) && onInvalid === "fail") return yield* Effect.fail(decoded.failure);
+			if (Result.isFailure(decoded) && onInvalid === "ignore-and-close") yield* socket.close(1008, "invalid websocket attachment").pipe(Effect.ignore);
+		}
+		return restored;
+	});
+	return {
+		serialize,
+		deserialize,
+		rehydrate,
+		schema
+	};
+};
+/** Maps compact websocket lifecycle handler names to `DurableObject.make` options. */
+const handlers = (options) => ({
+	webSocketMessage: options.message,
+	webSocketClose: options.close,
+	webSocketError: options.error
+});
+//#endregion
+//#region src/internal/WorkerContext.ts
+const causeError = (cause) => {
+	const squashed = Cause.squash(cause);
+	return squashed instanceof Error ? squashed : new Error(Cause.pretty(cause), { cause: squashed });
+};
+const failureHandler = (label, cause, options) => (options?.onFailure?.(cause) ?? Effect.logError(`${label} failed`, Cause.pretty(cause))).pipe(Effect.catchCause((handlerCause) => Effect.logError(`${label} failure handler failed`, Cause.pretty(cause), Cause.pretty(handlerCause))));
+/**
+* Builds a `waitUntil` scheduler for any Cloudflare lifecycle that accepts
+* background promises (`ExecutionContext`, `DurableObjectState`).
+*
+* Background effects capture the calling fiber's context via `Effect.context`
+* before being registered, so the default module-level `Effect.runPromiseExit`
+* runner is sufficient; entrypoints may still pass a runtime-bound runner.
+*/
+const makeWaitUntilScheduler = (label, register, runPromiseExit = (effect) => Effect.runPromiseExit(effect)) => {
+	return (effect, options, mode) => Effect.context().pipe(Effect.flatMap((context) => Effect.sync(() => {
+		const runHandler = (cause) => runPromiseExit(Effect.scoped(Effect.provideContext(failureHandler(label, cause, options), context))).then((exit) => {
+			if (Exit.isFailure(exit)) console.error(`${label} failure handler failed`, Cause.pretty(exit.cause));
+		});
+		register(runPromiseExit(Effect.scoped(Effect.provideContext(effect, context))).then(async (exit) => {
+			if (Exit.isSuccess(exit)) return;
+			await runHandler(exit.cause);
+			if (mode === "propagate") throw causeError(exit.cause);
+		}));
+	})));
+};
+/**
+* Builds the `WorkerContext` service from a native `ExecutionContext`.
+*/
+const fromExecutionContext = (ctx, runPromiseExit = (effect) => Effect.runPromiseExit(effect)) => {
+	const schedule = makeWaitUntilScheduler("WorkerContext.waitUntil", (promise) => ctx.waitUntil(promise), runPromiseExit);
+	return {
+		raw: ctx,
+		waitUntil: (effect, options) => schedule(effect, options, options?.mode ?? "observe"),
+		waitUntilPropagating: (effect, options) => schedule(effect, options, "propagate"),
+		passThroughOnException: Effect.sync(() => ctx.passThroughOnException())
+	};
+};
+//#endregion
+//#region src/DurableObjectState.ts
+var DurableObjectState_exports = /* @__PURE__ */ __exportAll({
+	DurableObjectState: () => DurableObjectState,
+	fromDurableObjectState: () => fromDurableObjectState
+});
+/**
+* Context tag for accessing the current Durable Object state service.
+*/
+var DurableObjectState = class extends Context.Service()("effect-cf/DurableObjectState") {};
+/**
+* Wraps a native Cloudflare `DurableObjectState` as a {@link DurableObjectStateService}.
+*/
+const fromDurableObjectState = (state) => {
+	const scheduleWaitUntil = makeWaitUntilScheduler("DurableObjectState.waitUntil", (promise) => state.waitUntil(promise));
+	const waitUntil = ((input, options) => Effect.isEffect(input) ? scheduleWaitUntil(input, options, options?.mode ?? "observe") : Effect.sync(() => state.waitUntil(input)));
+	return {
+		raw: state,
+		id: state.id,
+		storage: fromDurableObjectStorage(state.storage),
+		waitUntil,
+		blockConcurrencyWhile: (effect) => Effect.context().pipe(Effect.flatMap((context) => Effect.promise(() => state.blockConcurrencyWhile(() => runPromiseExitPreservingTypedFailures(context, effect)))), Effect.flatten),
+		blockConcurrencyWhileOrReset: (effect) => Effect.context().pipe(Effect.flatMap((context) => Effect.promise(() => state.blockConcurrencyWhile(() => Effect.runPromiseWith(context)(effect))))),
+		acceptWebSocket: (ws, tags) => Effect.sync(() => state.acceptWebSocket(ws.raw, tags)),
+		getWebSockets: (tag) => Effect.sync(() => state.getWebSockets(tag).map((socket) => fromWebSocket(socket))),
+		setWebSocketAutoResponse: (pair) => Effect.sync(() => state.setWebSocketAutoResponse(pair)),
+		getWebSocketAutoResponse: Effect.sync(() => state.getWebSocketAutoResponse()),
+		getWebSocketAutoResponseTimestamp: (ws) => Effect.sync(() => state.getWebSocketAutoResponseTimestamp(ws.raw)),
+		setHibernatableWebSocketEventTimeout: (timeoutMs) => Effect.sync(() => state.setHibernatableWebSocketEventTimeout(timeoutMs)),
+		getHibernatableWebSocketEventTimeout: Effect.sync(() => state.getHibernatableWebSocketEventTimeout()),
+		getTags: (ws) => Effect.sync(() => state.getTags(ws.raw)),
+		abort: (reason) => Effect.sync(() => state.abort(reason))
+	};
+};
+const runPromiseExitPreservingTypedFailures = async (context, effect) => {
+	const exit = await Effect.runPromiseExitWith(context)(effect);
+	if (Exit.isFailure(exit) && (Cause.hasDies(exit.cause) || Cause.hasInterrupts(exit.cause))) throw Cause.squash(exit.cause);
+	return exit;
+};
+//#endregion
+export { DurableObjectWebSocket_exports as a, causeMessage as c, WorkerConfig as d, WorkerEnvironment as f, fromExecutionContext as i, violationsMessage as l, DurableObjectState_exports as n, fromWebSocket as o, fromDurableObjectState as r, DurableObjectStorage_exports as s, DurableObjectState as t, Environment_exports as u };

package/dist/Hyperdrive-pEMnh3W6.d.mts

@@ -0,0 +1,36 @@
+import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-Bq_FPzlt.mjs";
+import { Context, Effect, Layer } from "effect";
+declare namespace Hyperdrive_d_exports {
+  export { HyperdriveClient, HyperdriveDefinition, HyperdriveService, LayerOptions, Tag, TagClass, isHyperdrive, layer, make, makeClient };
+}
+/** Typed Hyperdrive binding definition. */
+interface HyperdriveDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+interface HyperdriveClient {
+  readonly connectionString: string;
+  readonly rawUnsafe: Effect.Effect<Hyperdrive>;
+  readonly definition: HyperdriveDefinition;
+}
+declare const HyperdriveServiceTypeId: unique symbol;
+/** Nominal service marker for Hyperdrive services created with {@link make}. */
+interface HyperdriveService<Id extends string> {
+  readonly [HyperdriveServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions = {
+  readonly binding: string;
+};
+interface TagClass<Self, Id extends string> extends Context.ServiceClass<Self, Id, HyperdriveClient> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+declare const isHyperdrive: (value: unknown) => value is Hyperdrive;
+declare const makeClient: (definition: HyperdriveDefinition) => (hyperdrive: Hyperdrive) => HyperdriveClient;
+declare const layer: <Self>(tag: Context.Service<Self, HyperdriveClient>, definition: HyperdriveDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make: <Id extends string>(id: Id) => TagClass<HyperdriveService<Id>, Id>;
+declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
+//#endregion
+export { LayerOptions as n, TagClass as r, Hyperdrive_d_exports as t };

package/dist/HyperdrivePg.d.mts

@@ -1,4 +1,5 @@
-import { d as WorkerEnvironment, i as BindingNotFoundError, n as LayerOptions, o as BindingValidationError, r as TagClass } from "./Hyperdrive-COyg7R26.mjs";
+import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-Bq_FPzlt.mjs";
+import { n as LayerOptions, r as TagClass } from "./Hyperdrive-pEMnh3W6.mjs";
 import { Layer } from "effect";
 import { PgClient } from "@effect/sql-pg";
 import { SqlClient, SqlError } from "effect/unstable/sql";