effect-cf 0.39.1 → 0.40.1

package/dist/DurableObjectNamespace.d.mts

@@ -0,0 +1,154 @@
+import { WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
+import { Provider } from "./Rpc.mjs";
+import { Definition, Method as Method$1 } from "./RpcDefinition.mjs";
+import { AsyncMethodArgs, AsyncMethodCloudflareReturn, AsyncMethodKey, AsyncMethodSuccess } from "./internal/RpcInvocation.mjs";
+import { Definition as Definition$1, ReservedMethodName as ReservedMethodName$1 } from "./DurableObjectDefinition.mjs";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+import { Context, Layer, Scope } from "effect";
+declare namespace DurableObjectNamespace_d_exports {
+  export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectRpcError, DurableObjectStubClient, isDurableObjectNamespaceClient, layer, makeClient, makeDirectMethods };
+}
+interface DurableObjectFetcher {
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+}
+type RpcClient<Api> = { readonly [Key in keyof Api as Key extends string ? Api[Key] extends ((...args: Array<any>) => any) ? Key : never : never]: Api[Key]; };
+type ReservedMethodName = ReservedMethodName$1 | "fetch";
+type NamespaceCandidate = Parameters<typeof Predicate.isUnknown>[0];
+/**
+ * Cloudflare Durable Object stub, optionally enriched with RPC methods.
+ */
+type DurableObjectStubClient<Api extends object> = DurableObjectFetcher & RpcClient<Provider<Api, ReservedMethodName>> & {
+  readonly id: globalThis.DurableObjectId;
+  readonly name?: string;
+};
+interface DurableObjectNamespaceClient<Api extends object> {
+  newUniqueId(options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions): globalThis.DurableObjectId;
+  idFromName(name: string): globalThis.DurableObjectId;
+  idFromString(id: string): globalThis.DurableObjectId;
+  get(id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions): DurableObjectStubClient<Api>;
+  getByName(name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions): DurableObjectStubClient<Api>;
+  jurisdiction(jurisdiction: globalThis.DurableObjectJurisdiction): DurableObjectNamespaceClient<Api>;
+}
+/**
+ * Minimal namespace binding metadata.
+ */
+interface DurableObjectNamespaceDefinition {
+  readonly binding: string;
+}
+/**
+ * Namespace binding metadata with optional RPC schema.
+ */
+interface DurableObjectNamespaceBindingDefinition<Definition extends Definition$1.Any | undefined = undefined> {
+  readonly binding: string;
+  readonly definition?: Definition;
+  /** Append live trace context only when the receiver also enables rpcTracing. */
+  readonly rpcTracing?: boolean;
+}
+declare const DurableObjectRpcError_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: "DurableObjectRpcError";
+} & Readonly<A>;
+/**
+ * Failure raised when invoking an RPC method on a Durable Object stub.
+ */
+declare class DurableObjectRpcError extends DurableObjectRpcError_base<{
+  readonly binding: string;
+  readonly method: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const DurableObjectFetchError_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: "DurableObjectFetchError";
+} & Readonly<A>;
+/**
+ * Failure raised when forwarding a request to a Durable Object stub.
+ */
+declare class DurableObjectFetchError extends DurableObjectFetchError_base<{
+  readonly binding: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+type StubMethodKey<Api> = AsyncMethodKey<Api>;
+type StubMethodArgs<Api, Method extends keyof Api> = AsyncMethodArgs<Api, Method>;
+type StubMethodSuccess<Api, Method extends keyof Api> = AsyncMethodSuccess<Api, Method>;
+type StubMethodCloudflareReturn<Api, Method extends keyof Api> = AsyncMethodCloudflareReturn<Api, Method>;
+type StubCall<R, Api extends object> = <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, R>;
+type DefinitionNamespaceDirectMethods<R, Api extends object, Definition$3 extends Definition$1.Any> = { readonly [Method in Definition.MethodNames<Definition$3>]: (stub: DurableObjectStubClient<Api>, ...args: Method$1.Args<Definition$3["methods"][Method]>) => Effect.Effect<Method$1.Success<Definition$3["methods"][Method]>, DurableObjectRpcError, R>; };
+type DefinitionDurableObjectDirectClient<R, Definition$2 extends Definition$1.Any> = {
+  readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
+} & { readonly [Method in Definition.MethodNames<Definition$2>]: (...args: Method$1.Args<Definition$2["methods"][Method]>) => Effect.Effect<Method$1.Success<Definition$2["methods"][Method]>, DurableObjectRpcError, R>; };
+type DefinitionNamespaceDirectClientMethods<R, Definition extends Definition$1.Any> = {
+  readonly byName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => DefinitionDurableObjectDirectClient<R, Definition>;
+  readonly byId: (id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => DefinitionDurableObjectDirectClient<R, Definition>;
+};
+type DirectMethods<R, Api extends object, Definition> = Definition extends Definition$1.Any ? DefinitionNamespaceDirectMethods<R, Api, Definition> & DefinitionNamespaceDirectClientMethods<R, Definition> : {};
+type DurableObjectNamespaceEffectClient<Api extends object, Definition extends Definition$1.Any | undefined = undefined> = DirectMethods<never, Api, Definition> & {
+  readonly newUniqueId: (options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions) => Effect.Effect<globalThis.DurableObjectId>;
+  readonly idFromName: (name: string) => Effect.Effect<globalThis.DurableObjectId>;
+  readonly idFromString: (id: string) => Effect.Effect<globalThis.DurableObjectId>;
+  readonly get: (id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>>;
+  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>>;
+  readonly jurisdiction: (jurisdiction: globalThis.DurableObjectJurisdiction) => Effect.Effect<DurableObjectNamespaceClient<Api>>;
+  readonly fetch: (stub: DurableObjectStubClient<Api>, input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, DurableObjectFetchError>;
+  /**
+   * Invokes a Durable Object RPC method and returns Cloudflare's raw RPC result.
+   *
+   * This preserves Cloudflare RPC behavior such as promise-like pipelining and
+   * transferable / disposable result objects. It does not resolve the returned
+   * promise-like value and it does not decode definition-backed success schemas.
+   *
+   * Most application code should use {@link call} instead.
+   */
+  readonly rpc: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError>;
+  /**
+   * Invokes a Durable Object RPC method, resolves Cloudflare's RPC result, and
+   * decodes the success value when the namespace was created from a definition.
+   *
+   * This is the normal choice when application code wants the final typed value.
+   */
+  readonly call: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError>;
+  /**
+   * Invokes a Durable Object RPC method in the current `Scope`, resolves
+   * Cloudflare's RPC result, decodes definition-backed success values, and
+   * disposes the resolved result when the scope closes if it implements
+   * `Symbol.dispose`.
+   *
+   * Use this for RPC methods that return Cloudflare RPC resources or other
+   * disposable objects whose lifetime should be tied to an Effect scope.
+   */
+  readonly scopedCall: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, DurableObjectRpcError, Scope.Scope>;
+  /**
+   * Exposes the underlying native Durable Object namespace binding.
+   *
+   * Prefer the typed helpers above unless Cloudflare exposes a platform feature
+   * that is not wrapped by effect-cf yet.
+   */
+  readonly rawUnsafe: Effect.Effect<DurableObjectNamespaceClient<Api>>;
+};
+type DurableObjectNamespaceStaticClient<R, Api extends object, Definition extends Definition$1.Any | undefined = undefined> = DirectMethods<R, Api, Definition> & {
+  readonly newUniqueId: (options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions) => Effect.Effect<globalThis.DurableObjectId, never, R>;
+  readonly idFromName: (name: string) => Effect.Effect<globalThis.DurableObjectId, never, R>;
+  readonly idFromString: (id: string) => Effect.Effect<globalThis.DurableObjectId, never, R>;
+  readonly get: (id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
+  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
+  readonly jurisdiction: (jurisdiction: globalThis.DurableObjectJurisdiction) => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
+  readonly fetch: (stub: DurableObjectStubClient<Api>, input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
+  readonly rpc: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError, R>;
+  readonly call: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, R>;
+  readonly scopedCall: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, DurableObjectRpcError, Scope.Scope | R>;
+  readonly rawUnsafe: () => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
+};
+declare const isDurableObjectNamespaceClient: <Api extends object>(value: NamespaceCandidate) => value is DurableObjectNamespaceClient<Api>;
+declare const makeClient: <Api extends object, const Definition extends Definition$1.Any | undefined = undefined>(definition: DurableObjectNamespaceBindingDefinition<Definition>) => ((namespace: DurableObjectNamespaceClient<Api>) => DurableObjectNamespaceEffectClient<Api, Definition>);
+declare const layer: <Self, Api extends object, const Definition extends Definition$1.Any | undefined = undefined>(tag: Context.Service<Self, DurableObjectNamespaceEffectClient<Api, Definition>>, definition: DurableObjectNamespaceBindingDefinition<Definition>) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const makeDirectMethods: <R, Api extends object, Definition extends Definition$1.Any | undefined>(rpcDefinition: Definition | undefined, helpers: {
+  readonly call: StubCall<R, Api>;
+  readonly fetch: (stub: DurableObjectStubClient<Api>, input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
+  readonly get: (id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
+  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
+}) => DirectMethods<R, Api, Definition>;
+//#endregion
+export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectNamespace_d_exports, DurableObjectRpcError, DurableObjectStubClient, isDurableObjectNamespaceClient, layer, makeClient, makeDirectMethods };

package/dist/DurableObjectNamespace.mjs

@@ -0,0 +1,144 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { layer as layer$1 } from "./Binding.mjs";
+import { causeMessage } from "./internal/ErrorMessage.mjs";
+import { decodeSuccess, encodeArgs } from "./RpcDefinition.mjs";
+import { withRpcClientSpan, withRpcTraceContext } from "./RpcTracing.mjs";
+import { invokeRpcMethod } from "./internal/RpcInvocation.mjs";
+import { resolve, scoped } from "./Rpc.mjs";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+//#region src/DurableObjectNamespace.ts
+var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
+	DurableObjectFetchError: () => DurableObjectFetchError,
+	DurableObjectRpcError: () => DurableObjectRpcError,
+	isDurableObjectNamespaceClient: () => isDurableObjectNamespaceClient,
+	layer: () => layer,
+	makeClient: () => makeClient,
+	makeDirectMethods: () => makeDirectMethods
+});
+const expectedDurableObjectNamespace = "Durable Object namespace binding with getByName(), get(), idFromName(), idFromString(), newUniqueId(), and jurisdiction()";
+/**
+* Failure raised when invoking an RPC method on a Durable Object stub.
+*/
+var DurableObjectRpcError = class extends Data.TaggedError("DurableObjectRpcError") {
+	get message() {
+		return `Durable Object RPC method "${this.method}" failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
+/**
+* Failure raised when forwarding a request to a Durable Object stub.
+*/
+var DurableObjectFetchError = class extends Data.TaggedError("DurableObjectFetchError") {
+	get message() {
+		return `Durable Object fetch failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
+const hasFunction = (value, key) => Predicate.hasProperty(value, key) && Predicate.isFunction(value[key]);
+const isDurableObjectNamespaceClient = (value) => hasFunction(value, "getByName") && hasFunction(value, "get") && hasFunction(value, "idFromName") && hasFunction(value, "idFromString") && hasFunction(value, "newUniqueId") && hasFunction(value, "jurisdiction");
+const makeClient = (definition) => {
+	return (namespace) => {
+		const newUniqueId = (options) => Effect.sync(() => namespace.newUniqueId(options));
+		const idFromName = (name) => Effect.sync(() => namespace.idFromName(name));
+		const idFromString = (id) => Effect.sync(() => namespace.idFromString(id));
+		const get = (id, options) => Effect.sync(() => namespace.get(id, options));
+		const getByName = (name, options) => Effect.sync(() => namespace.getByName(name, options));
+		const jurisdiction = (value) => Effect.sync(() => namespace.jurisdiction(value));
+		const fetch = (stub, input, init) => Effect.tryPromise({
+			try: (signal) => {
+				const callerSignal = init?.signal !== void 0 ? init.signal : input instanceof Request ? input.signal : void 0;
+				return stub.fetch(input, {
+					...init,
+					signal: callerSignal === null || callerSignal === void 0 ? signal : AbortSignal.any([callerSignal, signal])
+				});
+			},
+			catch: (cause) => new DurableObjectFetchError({
+				binding: definition.binding,
+				cause
+			})
+		});
+		const rpc = Effect.fnUntraced(function* (stub, method, ...args) {
+			const methodName = String(method);
+			const encodedArgs = definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			})));
+			const nativeArgs = definition.rpcTracing ? yield* withRpcTraceContext(encodedArgs) : encodedArgs;
+			return yield* invokeRpcMethod(stub, method, nativeArgs, (cause) => new DurableObjectRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			}));
+		});
+		const decodeSuccess$1 = Effect.fnUntraced(function* (methodName, value) {
+			if (definition.definition === void 0) return value;
+			return yield* decodeSuccess(definition.definition, methodName, value).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			})));
+		});
+		const call = Effect.fnUntraced(function* (stub, method, ...args) {
+			const methodName = String(method);
+			const value = yield* resolve(yield* rpc(stub, method, ...args)).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			})));
+			return yield* decodeSuccess$1(methodName, value);
+		}, (effect, ...args) => withRpcClientSpan(effect, definition.binding, String(args[1])));
+		const scopedCall = Effect.fnUntraced(function* (stub, method, ...args) {
+			const methodName = String(method);
+			const result = yield* rpc(stub, method, ...args);
+			const value = yield* scoped(result).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			})));
+			return yield* decodeSuccess$1(methodName, value);
+		}, (effect, ...args) => withRpcClientSpan(effect, definition.binding, String(args[1])));
+		const directMethods = makeDirectMethods(definition.definition, {
+			call,
+			fetch,
+			get,
+			getByName
+		});
+		return Object.assign(directMethods, {
+			newUniqueId,
+			idFromName,
+			idFromString,
+			get,
+			getByName,
+			jurisdiction,
+			fetch,
+			rpc,
+			call,
+			scopedCall,
+			rawUnsafe: Effect.succeed(namespace)
+		});
+	};
+};
+const layer = (tag, definition) => layer$1(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient(definition), { expected: expectedDurableObjectNamespace });
+const makeDirectMethods = (rpcDefinition, helpers) => {
+	const methods = {};
+	if (rpcDefinition !== void 0) {
+		for (const methodName of Object.keys(rpcDefinition.methods)) methods[methodName] = (stub, ...args) => helpers.call(stub, methodName, ...args);
+		const makeClient = (getStub) => {
+			const client = { fetch: (input, init) => Effect.gen(function* () {
+				const stub = yield* getStub();
+				return yield* helpers.fetch(stub, input, init);
+			}) };
+			for (const methodName of Object.keys(rpcDefinition.methods)) client[methodName] = (...args) => Effect.gen(function* () {
+				const stub = yield* getStub();
+				return yield* helpers.call(stub, methodName, ...args);
+			});
+			return client;
+		};
+		methods.byName = (name, options) => makeClient(() => helpers.getByName(name, options));
+		methods.byId = (id, options) => makeClient(() => helpers.get(id, options));
+	}
+	return methods;
+};
+//#endregion
+export { DurableObjectFetchError, DurableObjectNamespace_exports, DurableObjectRpcError, isDurableObjectNamespaceClient, layer, makeClient, makeDirectMethods };

package/dist/DurableObjectRpcWebSocket.d.mts

@@ -0,0 +1,112 @@
+import { AcceptUpgradeOptions, AcceptedUpgrade, DurableWebSocket, DurableWebSocketAttachmentError } from "./DurableObjectWebSocket.mjs";
+import { DurableObjectState } from "./DurableObjectState.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import * as RpcServer from "effect/unstable/rpc/RpcServer";
+declare namespace DurableObjectRpcWebSocket_d_exports {
+  export { DurableObjectRpcWebSocket, DurableObjectRpcWebSocketService, HeartbeatPolicy, LayerOptions, NativeWebSocketMessage, ResumableStreamDeclaration, RpcWebSocketAttachment, layer, resumableStream };
+}
+/** Heartbeat handling for Effect's application-level RPC Ping messages. */
+type HeartbeatPolicy = "auto-response" | "passthrough";
+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;
+  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;
+  }>;
+  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 {
+  readonly tag?: string | undefined;
+  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;
+  readonly resumableStreams?: ReadonlyArray<AnyResumableStreamDeclaration> | undefined;
+}
+type NativeWebSocketMessage = string | ArrayBuffer;
+interface DurableObjectRpcWebSocketService {
+  /** Accept a server socket that has not already been accepted. */
+  readonly accept: (socket: DurableWebSocket, tags?: ReadonlyArray<string>) => Effect.Effect<void>;
+  /** Shallow-merges application attachment fields 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>;
+declare class DurableObjectRpcWebSocket extends DurableObjectRpcWebSocket_base {}
+/**
+ * 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: (options?: LayerOptions) => Layer.Layer<RpcServer.Protocol | DurableObjectRpcWebSocket, never, DurableObjectState | RpcSerialization.RpcSerialization>;
+//#endregion
+export { DurableObjectRpcWebSocket, DurableObjectRpcWebSocketService, DurableObjectRpcWebSocket_d_exports, HeartbeatPolicy, LayerOptions, NativeWebSocketMessage, ResumableStreamDeclaration, RpcWebSocketAttachment, layer, resumableStream };