effect-cf 0.39.1 → 0.40.1

package/dist/DurableObjectState.mjs

@@ -0,0 +1,47 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { runNativeCallback } from "./internal/NativeCallback.mjs";
+import { fromDurableObjectStorage } from "./DurableObjectStorage.mjs";
+import { fromWebSocket } from "./DurableObjectWebSocket.mjs";
+import { makeWaitUntilScheduler } from "./internal/WorkerContext.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+//#region src/DurableObjectState.ts
+var DurableObjectState_exports = /* @__PURE__ */ __exportAll({
+	DurableObjectState: () => DurableObjectState,
+	fromDurableObjectState: () => fromDurableObjectState
+});
+var DurableObjectState = class extends Context.Service()("effect-cf/DurableObjectState") {};
+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) => runNativeCallback((run) => state.blockConcurrencyWhile(() => runExitPreservingTypedFailures(run, effect))).pipe(Effect.orDie, Effect.flatten),
+		blockConcurrencyWhileOrReset: (effect) => runNativeCallback((run) => state.blockConcurrencyWhile(async () => {
+			const exit = await run(effect);
+			if (Exit.isFailure(exit)) throw Cause.squash(exit.cause);
+			return exit.value;
+		})).pipe(Effect.orDie),
+		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, options) => Effect.sync(() => state.abort(reason, options))
+	};
+};
+const runExitPreservingTypedFailures = async (run, effect) => {
+	const exit = await run(effect);
+	if (Exit.isFailure(exit) && (Cause.hasDies(exit.cause) || Cause.hasInterrupts(exit.cause))) throw Cause.squash(exit.cause);
+	return exit;
+};
+//#endregion
+export { DurableObjectState, DurableObjectState_exports, fromDurableObjectState };

package/dist/DurableObjectStorage.d.mts

@@ -0,0 +1,112 @@
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import * as Option from "effect/Option";
+import * as Cause from "effect/Cause";
+import * as Duration from "effect/Duration";
+declare namespace DurableObjectStorage_d_exports {
+  export { DurableObjectStorage, DurableObjectTransaction, SchemaBackedSyncKvStorage, SqlCursor, SqlStorage, SqlStorageValue, StorageOperationError, SyncKvDefinition, SyncKvStorage, fromDurableObjectStorage };
+}
+type SqlStorageValue = globalThis.SqlStorageValue;
+declare const StorageOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+  readonly _tag: "StorageOperationError";
+} & Readonly<A>;
+declare class StorageOperationError extends StorageOperationError_base<{
+  readonly operation: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+type StorageEffect<A> = Effect.Effect<A, StorageOperationError>;
+interface SqlCursor<T extends Record<string, SqlStorageValue>> {
+  next(): StorageEffect<{
+    done?: false;
+    value: T;
+  } | {
+    done: true;
+    value?: never;
+  }>;
+  toArray(): StorageEffect<Array<T>>;
+  one(): StorageEffect<T>;
+  raw<U extends Array<SqlStorageValue>>(): StorageEffect<IterableIterator<U>>;
+  readonly columnNames: Array<string>;
+  readonly rowsRead: StorageEffect<number>;
+  readonly rowsWritten: StorageEffect<number>;
+}
+interface SqlStorage {
+  exec<T extends Record<string, SqlStorageValue>>(query: string, ...bindings: Array<SqlStorageValue>): StorageEffect<SqlCursor<T>>;
+  readonly databaseSize: number;
+}
+interface SyncKvDefinition<Key, Value, EncodedValue> {
+  readonly key: S.Codec<Key, string>;
+  readonly value: S.Codec<Value, EncodedValue>;
+}
+/**
+ * Sync KV wrapper that transparently encodes keys/values through Effect Schema.
+ */
+interface SchemaBackedSyncKvStorage<Key, Value> {
+  get(key: Key): Effect.Effect<Option.Option<Value>, unknown>;
+  put(key: Key, value: Value): Effect.Effect<void, unknown>;
+  delete(key: Key): Effect.Effect<boolean, unknown>;
+  list(options?: globalThis.SyncKvListOptions): Effect.Effect<Array<[Key, Value]>, unknown>;
+}
+interface SyncKvStorage {
+  get<T = unknown>(key: string): StorageEffect<T | undefined>;
+  put<T>(key: string, value: T): StorageEffect<void>;
+  delete(key: string): StorageEffect<boolean>;
+  list<T = unknown>(options?: globalThis.SyncKvListOptions): StorageEffect<Array<[string, T]>>;
+  schema<Key, Value, EncodedValue>(definition: SyncKvDefinition<Key, Value, EncodedValue>): SchemaBackedSyncKvStorage<Key, Value>;
+}
+/**
+ * Effect wrapper around Cloudflare transaction callbacks.
+ */
+interface DurableObjectTransaction {
+  get<T = unknown>(key: string, options?: globalThis.DurableObjectGetOptions): StorageEffect<T | undefined>;
+  get<T = unknown>(keys: Array<string>, options?: globalThis.DurableObjectGetOptions): StorageEffect<Map<string, T>>;
+  list<T = unknown>(options?: globalThis.DurableObjectListOptions): StorageEffect<Map<string, T>>;
+  put<T>(key: string, value: T, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
+  put<T>(entries: Record<string, T>, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
+  delete(key: string, options?: globalThis.DurableObjectPutOptions): StorageEffect<boolean>;
+  delete(keys: Array<string>, options?: globalThis.DurableObjectPutOptions): StorageEffect<number>;
+  rollback(): StorageEffect<void>;
+  getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
+  setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
+  setAlarmAfter(delay: Duration.Input, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
+  deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
+}
+interface DurableObjectStorage {
+  get<T = unknown>(key: string, options?: globalThis.DurableObjectGetOptions): StorageEffect<T | undefined>;
+  put<T>(key: string, value: T, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
+  delete(key: string, options?: globalThis.DurableObjectPutOptions): StorageEffect<boolean>;
+  /**
+   * Deletes all stored data. On compatibility dates before 2026-02-24, Cloudflare
+   * documents that active alarms must be deleted separately with `deleteAlarm()`.
+   */
+  deleteAll(options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
+  getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
+  setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
+  setAlarmAfter(delay: Duration.Input, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
+  deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
+  /**
+   * SQLite-backed Durable Object storage only.
+   *
+   * The callback Effect must complete synchronously. If it requires asynchronous
+   * work, use `transaction` instead so Cloudflare can run the async transaction
+   * callback under the platform's transaction contract.
+   */
+  transactionSync<A, E, R>(closure: () => Effect.Effect<A, E, R>): Effect.Effect<A, E | StorageOperationError, R>;
+  /**
+   * Runs an async transaction and exposes a typed transaction wrapper.
+   */
+  transaction<A, E, R>(closure: (txn: DurableObjectTransaction) => Effect.Effect<A, E, R>): Effect.Effect<A, E | StorageOperationError, R>;
+  /** Flushes pending writes to disk. */
+  sync(): StorageEffect<void>;
+  /** Requires SQLite-backed Durable Object storage. */
+  getCurrentBookmark(): StorageEffect<string>;
+  /** Requires SQLite-backed Durable Object storage. */
+  onNextSessionRestoreBookmark(bookmark: string): StorageEffect<string>;
+  readonly sql: SqlStorage;
+  readonly kv: SyncKvStorage;
+}
+declare const fromDurableObjectStorage: (storage: globalThis.DurableObjectStorage) => DurableObjectStorage;
+//#endregion
+export { DurableObjectStorage, DurableObjectStorage_d_exports, DurableObjectTransaction, SchemaBackedSyncKvStorage, SqlCursor, SqlStorage, SqlStorageValue, StorageOperationError, SyncKvDefinition, SyncKvStorage, fromDurableObjectStorage };

package/dist/{DurableObjectState-DLL0YgBd.mjs → DurableObjectStorage.mjs}

@@ -1,7 +1,17 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { t as causeMessage } from "./ErrorMessage-Byx2OgNd.mjs";
-import { n as makeWaitUntilScheduler, r as runNativeCallback } from "./WorkerContext-Yobnfw-K.mjs";
-import { Cause, Clock, Context, Data, Duration, Effect, Exit, Fiber, Option, Predicate, Result, Schema } from "effect";
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { causeMessage } from "./internal/ErrorMessage.mjs";
+import { runNativeCallback } from "./internal/NativeCallback.mjs";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import * as Predicate from "effect/Predicate";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import * as Clock from "effect/Clock";
+import * as Duration from "effect/Duration";
+import * as Fiber from "effect/Fiber";
 //#region src/DurableObjectStorage.ts
 var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
 	StorageOperationError: () => StorageOperationError,
@@ -47,10 +57,10 @@ const fromSqlStorage = (sql) => ({
 	}
 });
 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);
+	const encodeKey = S.encodeEffect(definition.key);
+	const decodeKey = S.decodeUnknownEffect(definition.key);
+	const encodeValue = S.encodeEffect(definition.value);
+	const decodeValue = S.decodeUnknownEffect(definition.value);
 	return {
 		get: (key) => Effect.gen(function* () {
 			const encodedKey = yield* encodeKey(key);
@@ -140,152 +150,4 @@ const fromDurableObjectStorage = (storage) => ({
 	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
-});
-var DurableWebSocketSendError = class extends Data.TaggedError("DurableWebSocketSendError") {
-	get message() {
-		return `Durable Object websocket send failed: ${causeMessage(this.cause)}`;
-	}
-};
-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 fromWebSocket = (raw) => ({
-	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
-		})
-	})
-});
-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
-		})
-	};
-});
-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
-	};
-};
-const handlers = (options) => ({
-	webSocketMessage: options.message,
-	webSocketClose: options.close,
-	webSocketError: options.error
-});
-//#endregion
-//#region src/DurableObjectState.ts
-var DurableObjectState_exports = /* @__PURE__ */ __exportAll({
-	DurableObjectState: () => DurableObjectState,
-	fromDurableObjectState: () => fromDurableObjectState
-});
-var DurableObjectState = class extends Context.Service()("effect-cf/DurableObjectState") {};
-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) => runNativeCallback((run) => state.blockConcurrencyWhile(() => runExitPreservingTypedFailures(run, effect))).pipe(Effect.orDie, Effect.flatten),
-		blockConcurrencyWhileOrReset: (effect) => runNativeCallback((run) => state.blockConcurrencyWhile(async () => {
-			const exit = await run(effect);
-			if (Exit.isFailure(exit)) throw Cause.squash(exit.cause);
-			return exit.value;
-		})).pipe(Effect.orDie),
-		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, options) => Effect.sync(() => state.abort(reason, options))
-	};
-};
-const runExitPreservingTypedFailures = async (run, effect) => {
-	const exit = await run(effect);
-	if (Exit.isFailure(exit) && (Cause.hasDies(exit.cause) || Cause.hasInterrupts(exit.cause))) throw Cause.squash(exit.cause);
-	return exit;
-};
-//#endregion
-export { DurableWebSocketAttachmentError as a, StorageOperationError as c, DurableObjectWebSocket_exports as i, DurableObjectState_exports as n, fromWebSocket as o, fromDurableObjectState as r, DurableObjectStorage_exports as s, DurableObjectState as t };
+export { DurableObjectStorage_exports, StorageOperationError, fromDurableObjectStorage };

package/dist/DurableObjectWebSocket.d.mts

@@ -0,0 +1,83 @@
+import { DurableObjectState } from "./DurableObjectState.mjs";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import * as Option from "effect/Option";
+declare namespace DurableObjectWebSocket_d_exports {
+  export { AcceptUpgradeOptions, AcceptedUpgrade, AttachmentInvalidPolicy, AttachmentRehydrateOptions, DurableWebSocket, DurableWebSocketAttachment, DurableWebSocketAttachmentError, DurableWebSocketCloseError, DurableWebSocketHandlers, DurableWebSocketSendData, DurableWebSocketSendError, RehydratedDurableWebSocket, acceptUpgrade, attachment, fromWebSocket, handlers };
+}
+type DurableWebSocketSendData = string | ArrayBuffer | ArrayBufferView;
+declare const DurableWebSocketSendError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "DurableWebSocketSendError";
+} & Readonly<A>;
+declare class DurableWebSocketSendError extends DurableWebSocketSendError_base<{
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const DurableWebSocketCloseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "DurableWebSocketCloseError";
+} & Readonly<A>;
+declare class DurableWebSocketCloseError extends DurableWebSocketCloseError_base<{
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const DurableWebSocketAttachmentError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "DurableWebSocketAttachmentError";
+} & Readonly<A>;
+/** Error raised when serializing or deserializing a websocket attachment fails. */
+declare class DurableWebSocketAttachmentError extends DurableWebSocketAttachmentError_base<{
+  readonly operation: "serialize" | "deserialize";
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+interface DurableWebSocket<Attachment = unknown> {
+  readonly raw: WebSocket;
+  send(data: DurableWebSocketSendData): Effect.Effect<void, DurableWebSocketSendError>;
+  close(code?: number, reason?: string): Effect.Effect<void, DurableWebSocketCloseError>;
+  /** Serializes hibernation attachment metadata onto the socket. */
+  serializeAttachment<A extends Attachment = Attachment>(value: A): Effect.Effect<void, DurableWebSocketAttachmentError>;
+  /** Deserializes hibernation attachment metadata from the socket. */
+  readonly deserializeAttachment: Effect.Effect<unknown, DurableWebSocketAttachmentError>;
+}
+declare const fromWebSocket: <Attachment = unknown>(raw: WebSocket) => DurableWebSocket<Attachment>;
+interface AcceptUpgradeOptions<Attachment = unknown> {
+  readonly tags?: ReadonlyArray<string> | undefined;
+  /** Optional attachment serialized onto the server socket. */
+  readonly attachment?: Attachment | undefined;
+}
+interface AcceptedUpgrade<Attachment = unknown> {
+  readonly client: WebSocket;
+  readonly server: DurableWebSocket<Attachment>;
+  readonly response: Response;
+}
+declare const acceptUpgrade: <Attachment = unknown>(options?: AcceptUpgradeOptions<Attachment> | undefined) => Effect.Effect<AcceptedUpgrade<Attachment>, DurableWebSocketAttachmentError, DurableObjectState>;
+type AttachmentInvalidPolicy = "ignore" | "ignore-and-close" | "fail";
+interface AttachmentRehydrateOptions {
+  readonly tag?: string | undefined;
+  readonly onInvalid?: AttachmentInvalidPolicy | undefined;
+}
+interface RehydratedDurableWebSocket<Attachment> {
+  readonly socket: DurableWebSocket<Attachment>;
+  readonly attachment: Attachment;
+}
+interface DurableWebSocketAttachment<Attachment, Encoded> {
+  serialize(socket: DurableWebSocket<unknown>, value: Attachment): Effect.Effect<void, DurableWebSocketAttachmentError>;
+  deserialize(socket: DurableWebSocket<unknown>): Effect.Effect<Option.Option<Attachment>, DurableWebSocketAttachmentError>;
+  rehydrate(options?: AttachmentRehydrateOptions): Effect.Effect<Array<RehydratedDurableWebSocket<Attachment>>, DurableWebSocketAttachmentError, DurableObjectState>;
+  readonly schema: S.Codec<Attachment, Encoded, never, never>;
+}
+declare const attachment: <const AttachmentSchema extends S.Codec<any, any, never, never>>(schema: AttachmentSchema) => DurableWebSocketAttachment<S.Schema.Type<AttachmentSchema>, S.Codec.Encoded<AttachmentSchema>>;
+interface DurableWebSocketHandlers<R = never, E = unknown> {
+  readonly message?: (socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, E, R>;
+  readonly close?: (socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, E, R>;
+  readonly error?: (socket: DurableWebSocket, cause: unknown) => Effect.Effect<void, E, R>;
+}
+declare const handlers: <R = never, E = unknown>(options: DurableWebSocketHandlers<R, E>) => {
+  webSocketMessage: ((socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, E, R>) | undefined;
+  webSocketClose: ((socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, E, R>) | undefined;
+  webSocketError: ((socket: DurableWebSocket, cause: unknown) => Effect.Effect<void, E, R>) | undefined;
+};
+//#endregion
+export { AcceptUpgradeOptions, AcceptedUpgrade, AttachmentInvalidPolicy, AttachmentRehydrateOptions, DurableObjectWebSocket_d_exports, DurableWebSocket, DurableWebSocketAttachment, DurableWebSocketAttachmentError, DurableWebSocketCloseError, DurableWebSocketHandlers, DurableWebSocketSendData, DurableWebSocketSendError, RehydratedDurableWebSocket, acceptUpgrade, attachment, fromWebSocket, handlers };

package/dist/DurableObjectWebSocket.mjs

@@ -0,0 +1,120 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { causeMessage } from "./internal/ErrorMessage.mjs";
+import { DurableObjectState } from "./DurableObjectState.mjs";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+//#region src/DurableObjectWebSocket.ts
+var DurableObjectWebSocket_exports = /* @__PURE__ */ __exportAll({
+	DurableWebSocketAttachmentError: () => DurableWebSocketAttachmentError,
+	DurableWebSocketCloseError: () => DurableWebSocketCloseError,
+	DurableWebSocketSendError: () => DurableWebSocketSendError,
+	acceptUpgrade: () => acceptUpgrade,
+	attachment: () => attachment,
+	fromWebSocket: () => fromWebSocket,
+	handlers: () => handlers
+});
+var DurableWebSocketSendError = class extends Data.TaggedError("DurableWebSocketSendError") {
+	get message() {
+		return `Durable Object websocket send failed: ${causeMessage(this.cause)}`;
+	}
+};
+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 fromWebSocket = (raw) => ({
+	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
+		})
+	})
+});
+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
+		})
+	};
+});
+const attachment = (schema) => {
+	const serialize = (socket, value) => S.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* S.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
+	};
+};
+const handlers = (options) => ({
+	webSocketMessage: options.message,
+	webSocketClose: options.close,
+	webSocketError: options.error
+});
+//#endregion
+export { DurableObjectWebSocket_exports, DurableWebSocketAttachmentError, DurableWebSocketCloseError, DurableWebSocketSendError, acceptUpgrade, attachment, fromWebSocket, handlers };

package/dist/Email.d.mts

@@ -0,0 +1,106 @@
+import { WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
+import * as Context$1 from "effect/Context";
+import * as Effect from "effect/Effect";
+import { Layer } from "effect";
+declare namespace Email_d_exports {
+  export { EmailAddress, EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult, EmailService, EmailValidationError, EmailViolation, LayerOptions, Tag, TagClass, emailErrorCodes, isEmailBinding, layer, make, makeClient, sendLimits, validateMessage };
+}
+declare const sendLimits: {
+  readonly maxRecipients: 50;
+  readonly maxAttachments: 32;
+  readonly maxMessageBytes: number;
+  readonly maxHeaderNameBytes: 100;
+  readonly maxHeaderValueBytes: 2048;
+  readonly maxHeadersBytes: number;
+  readonly maxAllowlistHeaders: 20;
+};
+/**
+ * Error codes reported by Cloudflare Email Sending.
+ *
+ * Surfaced on {@link EmailOperationError} `code` on a best-effort basis: the
+ * runtime attaches them as a non-standard `code` property on thrown errors,
+ * which may be missing depending on the runtime or dev-time proxying
+ * (miniflare remote bindings serialize errors and can strip it).
+ */
+declare const emailErrorCodes: readonly ["E_VALIDATION_ERROR", "E_FIELD_MISSING", "E_TOO_MANY_RECIPIENTS", "E_TOO_MANY_ATTACHMENTS", "E_SENDER_NOT_VERIFIED", "E_RECIPIENT_NOT_ALLOWED", "E_RECIPIENT_SUPPRESSED", "E_SENDER_DOMAIN_NOT_AVAILABLE", "E_CONTENT_TOO_LARGE", "E_DELIVERY_FAILED", "E_RATE_LIMIT_EXCEEDED", "E_DAILY_LIMIT_EXCEEDED", "E_INTERNAL_SERVER_ERROR", "E_HEADER_NOT_ALLOWED", "E_HEADER_USE_API_FIELD", "E_HEADER_VALUE_INVALID", "E_HEADER_VALUE_TOO_LONG", "E_HEADER_NAME_INVALID", "E_HEADERS_TOO_LARGE", "E_HEADERS_TOO_MANY"];
+type EmailErrorCode = (typeof emailErrorCodes)[number];
+declare const EmailOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "EmailOperationError";
+} & Readonly<A>;
+declare class EmailOperationError extends EmailOperationError_base<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+  /**
+   * Cloudflare error code taken from the thrown error, when present.
+   *
+   * Best-effort: may be `undefined` depending on the runtime or dev-time
+   * proxying — miniflare remote bindings (`"remote": true`) serialize thrown
+   * errors and can strip the non-standard `code` property.
+   */
+  readonly code?: EmailErrorCode | (string & {});
+}> {
+  get message(): string;
+}
+interface EmailViolation {
+  readonly path: string;
+  readonly message: string;
+  readonly limit?: number;
+  readonly actual?: number;
+}
+declare const EmailValidationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "EmailValidationError";
+} & Readonly<A>;
+declare class EmailValidationError extends EmailValidationError_base<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly violations: ReadonlyArray<EmailViolation>;
+}> {
+  get message(): string;
+}
+interface EmailDefinition {
+  readonly binding: string;
+}
+type EmailAddress = CloudflareEmailAddress;
+type EmailAttachment = CloudflareEmailAttachment;
+type EmailMessageBuilder = Parameters<CloudflareSendEmail["send"]>[0];
+type EmailSendResult = CloudflareEmailSendResult;
+type EmailBinding = CloudflareSendEmail;
+type EmailRecipients = string | EmailAddress | ReadonlyArray<string | EmailAddress>;
+type EmailSendError = EmailOperationError | EmailValidationError;
+interface EmailSendOptions {
+  readonly validate?: boolean;
+}
+interface EmailClient {
+  readonly send: (message: EmailMessageBuilder) => Effect.Effect<EmailSendResult, EmailSendError>;
+  readonly rawUnsafe: Effect.Effect<EmailBinding>;
+  readonly definition: EmailDefinition;
+}
+declare const EmailServiceTypeId: unique symbol;
+interface EmailService<Id extends string> {
+  readonly [EmailServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions = {
+  readonly binding: string;
+  readonly send?: EmailSendOptions;
+};
+interface TagClass<Self, Id extends string> extends Context$1.ServiceClass<Self, Id, EmailClient> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+/**
+ * Validates a structured message against documented Cloudflare Email Sending
+ * limits and returns every violation found. Total message size is not checked
+ * because the encoded MIME size is only known once Cloudflare composes it.
+ */
+declare const validateMessage: (message: EmailMessageBuilder) => ReadonlyArray<EmailViolation>;
+declare const isEmailBinding: <Candidate>(value: Candidate) => value is Candidate & EmailBinding;
+declare const makeClient: (definition: EmailDefinition, options?: EmailSendOptions) => (email: EmailBinding) => EmailClient;
+declare const layer: <Self>(tag: Context$1.Service<Self, EmailClient>, definition: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make: <Id extends string>(id: Id) => TagClass<EmailService<Id>, Id>;
+declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
+//#endregion
+export { EmailAddress, EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult, EmailService, EmailValidationError, EmailViolation, Email_d_exports, LayerOptions, Tag, TagClass, emailErrorCodes, isEmailBinding, layer, make, makeClient, sendLimits, validateMessage };