effect-cf 0.40.0 → 0.40.2

package/dist/ContainerNamespace.mjs

@@ -0,0 +1,165 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { layer as layer$1 } from "./Binding.mjs";
+import { causeMessage } from "./internal/ErrorMessage.mjs";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import * as Predicate from "effect/Predicate";
+//#region src/ContainerNamespace.ts
+var ContainerNamespace_exports = /* @__PURE__ */ __exportAll({
+	ContainerNamespace: () => ContainerNamespace,
+	ContainerOperationError: () => ContainerOperationError,
+	ContainerState: () => ContainerState,
+	Tag: () => Tag,
+	isContainerNamespaceResource: () => isContainerNamespaceResource,
+	layer: () => layer,
+	make: () => make,
+	makeClient: () => makeClient
+});
+const expectedContainerNamespace = "Container namespace binding with getByName()";
+/** Serializable state reported by a Cloudflare Container instance. */
+const ContainerState = S.Union([S.Struct({
+	lastChange: S.Finite,
+	status: S.Literals([
+		"running",
+		"stopping",
+		"stopped",
+		"healthy"
+	])
+}), S.Struct({
+	lastChange: S.Finite,
+	status: S.Literal("stopped_with_code"),
+	exitCode: S.optionalKey(S.Int)
+})]);
+var ContainerOperationError = class extends Data.TaggedError("ContainerOperationError") {
+	get message() {
+		return `Container ${this.operation} failed for binding "${this.binding}" instance "${this.instance}": ${causeMessage(this.cause)}`;
+	}
+};
+const tryContainerPromise = (definition, instance, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => new ContainerOperationError({
+		binding: definition.binding,
+		instance,
+		operation,
+		cause
+	})
+});
+const makeInstanceClient = (definition, instance, stub) => {
+	const spanOptions = (operation) => ({ attributes: {
+		binding: definition.binding,
+		instance,
+		operation
+	} });
+	const hostListOperation = (operation) => Effect.fn(`ContainerNamespace.${operation}`, spanOptions(operation))(function* (hosts) {
+		return yield* tryContainerPromise(definition, instance, operation, () => stub[operation]([...hosts]));
+	});
+	const hostnameOperation = (operation) => Effect.fn(`ContainerNamespace.${operation}`, spanOptions(operation))(function* (hostname) {
+		return yield* tryContainerPromise(definition, instance, operation, () => stub[operation](hostname));
+	});
+	return {
+		rawUnsafe: Effect.succeed(stub),
+		state: tryContainerPromise(definition, instance, "state", () => stub.getState()).pipe(Effect.flatMap(S.decodeUnknownEffect(ContainerState)), Effect.mapError((cause) => cause instanceof ContainerOperationError ? cause : new ContainerOperationError({
+			binding: definition.binding,
+			instance,
+			operation: "state",
+			cause
+		})), Effect.withSpan("ContainerNamespace.state", spanOptions("state"))),
+		fetch: Effect.fn("ContainerNamespace.fetch", spanOptions("fetch"))(function* (input, init) {
+			return yield* tryContainerPromise(definition, instance, "fetch", () => stub.fetch(input, init));
+		}),
+		start: Effect.fn("ContainerNamespace.start", spanOptions("start"))(function* (options, waitOptions) {
+			return yield* tryContainerPromise(definition, instance, "start", () => stub.start(options, waitOptions));
+		}),
+		startAndWaitForPorts: Effect.fn("ContainerNamespace.startAndWaitForPorts", spanOptions("startAndWaitForPorts"))(function* (options) {
+			return yield* tryContainerPromise(definition, instance, "startAndWaitForPorts", () => stub.startAndWaitForPorts(options));
+		}),
+		waitForPort: Effect.fn("ContainerNamespace.waitForPort", spanOptions("waitForPort"))(function* (options) {
+			return yield* tryContainerPromise(definition, instance, "waitForPort", () => stub.waitForPort(options));
+		}),
+		stop: Effect.fn("ContainerNamespace.stop", spanOptions("stop"))(function* (signal) {
+			return yield* tryContainerPromise(definition, instance, "stop", () => stub.stop(signal));
+		}),
+		destroy: tryContainerPromise(definition, instance, "destroy", () => stub.destroy()).pipe(Effect.withSpan("ContainerNamespace.destroy", spanOptions("destroy"))),
+		setAllowedHosts: hostListOperation("setAllowedHosts"),
+		setDeniedHosts: hostListOperation("setDeniedHosts"),
+		allowHost: hostnameOperation("allowHost"),
+		denyHost: hostnameOperation("denyHost"),
+		removeAllowedHost: hostnameOperation("removeAllowedHost"),
+		removeDeniedHost: hostnameOperation("removeDeniedHost")
+	};
+};
+const isContainerNamespaceResource = (value) => Predicate.hasProperty(value, "getByName") && Predicate.isFunction(value.getByName);
+const makeClient = (definition) => (namespace) => {
+	const getByName = (name, options) => Effect.try({
+		try: () => makeInstanceClient(definition, name, namespace.getByName(name, options)),
+		catch: (cause) => new ContainerOperationError({
+			binding: definition.binding,
+			instance: name,
+			operation: "getByName",
+			cause
+		})
+	});
+	const byName = (name, options) => {
+		const instance = getByName(name, options);
+		return {
+			rawUnsafe: Effect.flatMap(instance, (client) => client.rawUnsafe),
+			state: Effect.flatMap(instance, (client) => client.state),
+			fetch: (input, init) => Effect.flatMap(instance, (client) => client.fetch(input, init)),
+			start: (startOptions, waitOptions) => Effect.flatMap(instance, (client) => client.start(startOptions, waitOptions)),
+			startAndWaitForPorts: (startOptions) => Effect.flatMap(instance, (client) => client.startAndWaitForPorts(startOptions)),
+			waitForPort: (waitOptions) => Effect.flatMap(instance, (client) => client.waitForPort(waitOptions)),
+			stop: (signal) => Effect.flatMap(instance, (client) => client.stop(signal)),
+			destroy: Effect.flatMap(instance, (client) => client.destroy),
+			setAllowedHosts: (hosts) => Effect.flatMap(instance, (client) => client.setAllowedHosts(hosts)),
+			setDeniedHosts: (hosts) => Effect.flatMap(instance, (client) => client.setDeniedHosts(hosts)),
+			allowHost: (hostname) => Effect.flatMap(instance, (client) => client.allowHost(hostname)),
+			denyHost: (hostname) => Effect.flatMap(instance, (client) => client.denyHost(hostname)),
+			removeAllowedHost: (hostname) => Effect.flatMap(instance, (client) => client.removeAllowedHost(hostname)),
+			removeDeniedHost: (hostname) => Effect.flatMap(instance, (client) => client.removeDeniedHost(hostname))
+		};
+	};
+	return {
+		definition,
+		getByName,
+		byName,
+		rawUnsafe: Effect.succeed(namespace)
+	};
+};
+const layer = (tag, definition) => layer$1(tag, definition.binding, (value) => isContainerNamespaceResource(value), makeClient(definition), { expected: expectedContainerNamespace });
+const make = (id) => Tag()(id);
+const Tag = () => (id) => {
+	const tag = Context.Service()(`effect-cf/Container/${id}`);
+	const makeLayer = (definition) => layer(tag, definition);
+	const getByName = Effect.fnUntraced(function* (name, options) {
+		return yield* (yield* tag).getByName(name, options);
+	});
+	const byName = (name, options) => ({
+		state: Effect.flatMap(getByName(name, options), (instance) => instance.state),
+		fetch: (input, init) => Effect.flatMap(getByName(name, options), (instance) => instance.fetch(input, init)),
+		start: (startOptions, waitOptions) => Effect.flatMap(getByName(name, options), (instance) => instance.start(startOptions, waitOptions)),
+		startAndWaitForPorts: (startOptions) => Effect.flatMap(getByName(name, options), (instance) => instance.startAndWaitForPorts(startOptions)),
+		waitForPort: (waitOptions) => Effect.flatMap(getByName(name, options), (instance) => instance.waitForPort(waitOptions)),
+		stop: (signal) => Effect.flatMap(getByName(name, options), (instance) => instance.stop(signal)),
+		destroy: Effect.flatMap(getByName(name, options), (instance) => instance.destroy),
+		setAllowedHosts: (hosts) => Effect.flatMap(getByName(name, options), (instance) => instance.setAllowedHosts(hosts)),
+		setDeniedHosts: (hosts) => Effect.flatMap(getByName(name, options), (instance) => instance.setDeniedHosts(hosts)),
+		allowHost: (hostname) => Effect.flatMap(getByName(name, options), (instance) => instance.allowHost(hostname)),
+		denyHost: (hostname) => Effect.flatMap(getByName(name, options), (instance) => instance.denyHost(hostname)),
+		removeAllowedHost: (hostname) => Effect.flatMap(getByName(name, options), (instance) => instance.removeAllowedHost(hostname)),
+		removeDeniedHost: (hostname) => Effect.flatMap(getByName(name, options), (instance) => instance.removeDeniedHost(hostname)),
+		rawUnsafe: Effect.flatMap(getByName(name, options), (instance) => instance.rawUnsafe)
+	});
+	const rawUnsafe = Effect.flatMap(tag, (namespace) => namespace.rawUnsafe);
+	return Object.assign(tag, {
+		id,
+		layer: makeLayer,
+		getByName,
+		byName,
+		rawUnsafe
+	});
+};
+const ContainerNamespace = Tag;
+//#endregion
+export { ContainerNamespace, ContainerNamespace_exports, ContainerOperationError, ContainerState, Tag, isContainerNamespaceResource, layer, make, makeClient };

package/dist/D1.d.mts

@@ -0,0 +1,33 @@
+import { WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingService, BindingValidationError } from "./Binding.mjs";
+import * as Layer$1 from "effect/Layer";
+import { D1Client } from "@effect/sql-d1";
+import { Config } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+declare namespace D1_d_exports {
+  export { D1Definition, D1Service, D1SqlLayerOptions, Service, TypeId, make };
+}
+declare const TypeId: "~effect-cf/D1";
+type TypeId = typeof TypeId;
+interface D1Definition {
+  readonly binding: string;
+}
+type D1SqlLayerOptions = Omit<D1Client.D1ClientConfig, "db">;
+declare const D1ServiceTypeId: unique symbol;
+interface D1Service<Id extends string> {
+  readonly [D1ServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+declare const make: <Id extends string>(id: Id, definition: D1Definition) => BindingService<D1Service<Id>, Id, D1Database> & {
+  "~effect-cf/D1": "~effect-cf/D1";
+  definition: D1Definition;
+  sqlLayer: (options?: D1SqlLayerOptions) => Layer$1.Layer<D1Client.D1Client | SqlClient.SqlClient, Config.ConfigError | BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+};
+declare const Service: <Self>() => <Id extends string>(id: Id, definition: D1Definition) => BindingService<Self, Id, D1Database> & {
+  "~effect-cf/D1": "~effect-cf/D1";
+  definition: D1Definition;
+  sqlLayer: (options?: D1SqlLayerOptions) => Layer$1.Layer<D1Client.D1Client | SqlClient.SqlClient, Config.ConfigError | BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+};
+//#endregion
+export { D1Definition, D1Service, D1SqlLayerOptions, D1_d_exports, Service, TypeId, make };

package/dist/D1.mjs

@@ -0,0 +1,32 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { Service as Service$1 } from "./Binding.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
+import { D1Client } from "@effect/sql-d1";
+//#region src/D1.ts
+var D1_exports = /* @__PURE__ */ __exportAll({
+	Service: () => Service,
+	make: () => make
+});
+const TypeId = "~effect-cf/D1";
+const expectedD1Database = "D1 database binding with prepare(), batch(), and exec()";
+const isD1Database = (value) => Predicate.hasProperty(value, "prepare") && Predicate.isFunction(value.prepare) && Predicate.hasProperty(value, "batch") && Predicate.isFunction(value.batch) && Predicate.hasProperty(value, "exec") && Predicate.isFunction(value.exec);
+const make = (id, definition) => Service()(id, definition);
+const Service = () => (id, definition) => {
+	const tag = Service$1()(id, definition.binding, isD1Database, void 0, { expected: expectedD1Database });
+	const sqlLayer = (options) => Layer.unwrap(Effect.gen(function* () {
+		const db = yield* tag;
+		return D1Client.layer({
+			...options,
+			db
+		});
+	})).pipe(Layer.provide(tag.layer));
+	return Object.assign(tag, {
+		[TypeId]: TypeId,
+		definition,
+		sqlLayer
+	});
+};
+//#endregion
+export { D1_exports, Service, make };

package/dist/DurableObject.d.mts

@@ -0,0 +1,103 @@
+import { WorkerEnv, WorkerEnvironment } from "./Environment.mjs";
+import { DurableWebSocket } from "./DurableObjectWebSocket.mjs";
+import { ReceiverOptions, RpcInvocationInfo } from "./RpcTracing.mjs";
+import { NativeRequest } from "./Worker.mjs";
+import { DurableObjectState } from "./DurableObjectState.mjs";
+import { AlarmRegistration, AlarmService, DurableObjectAlarm } from "./DurableObjectAlarm.mjs";
+import { Api, Definition, HandlerEffect, Handlers, LayerOptions, Method, Methods, NoReservedMethods, Options, ReservedMethodName, ServerApi, ServiceFreeSchema, Tag, TagClass, implement, method } from "./DurableObjectDefinition.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer$1 from "effect/Layer";
+import { DurableObject } from "cloudflare:workers";
+import { Scope } from "effect";
+declare namespace DurableObject_d_exports {
+  export { Api, Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcApi, DurableObjectRpcApi as DurableObjectRpcShape, HandlerEffect, Handlers, LayerOptions, Method, Methods, NoReservedMethods, Options, ReservedMethodName, RpcHandlers, RunOptions, RunSymbol, RuntimeContext, ServerApi, ServiceFreeSchema, Tag, TagClass, implement, make, method };
+}
+type RuntimeContext<ROut> = DurableObjectState | DurableObjectAlarm | WorkerEnvironment | ROut;
+type HandlerContext<ROut> = RuntimeContext<ROut> | Scope.Scope;
+type FetchContext<ROut> = HandlerContext<ROut> | NativeRequest;
+/** Metadata available before an event effect or its event layer starts. */
+interface RunOptions {
+  readonly eventLayer?: boolean;
+  readonly event?: "fetch" | "rpc" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError";
+  readonly rpc?: RpcInvocationInfo;
+}
+/** Override to instrument the whole event, then call super[RunSymbol]. */
+declare const RunSymbol: unique symbol;
+/**
+ * Effect type for Durable Object lifecycle and RPC handlers.
+ */
+type DurableObjectHandler<ROut, A = unknown> = Effect.Effect<A, unknown, HandlerContext<ROut>>;
+/**
+ * Shape of Durable Object RPC handlers passed to {@link make}.
+ */
+type DurableObjectRpc<ROut> = Record<string, (...args: Array<any>) => DurableObjectHandler<ROut>>;
+type DurableObjectRpcApi<Rpc extends DurableObjectRpc<ROut>, ROut> = { readonly [Key in keyof Rpc]: Rpc[Key] extends ((...args: infer Args) => Effect.Effect<infer A, unknown, HandlerContext<ROut>>) ? (...args: Args) => Promise<A> : never; };
+type RpcHandlers<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof DurableObject<WorkerEnv> ? never : Key extends string ? [Api[Key]] extends [never] ? never : Api[Key] extends ((...args: Array<any>) => Promise<any>) ? Key : never : never]: Api[Key] extends ((...args: infer Args) => Promise<infer A>) ? (...args: Args) => DurableObjectHandler<ROut, A> : never; };
+interface DurableObjectOptionsBase<RRuntime, REvent = never, EventLayerError = never, Rpc extends DurableObjectRpc<RRuntime | REvent | RAlarm> = Record<never, never>, RAlarm = never> {
+  /**
+   * Layer provided around each Cloudflare event handled by this Durable Object.
+   *
+   * The layer is built inside the event's Effect scope and finalized when the
+   * event effect completes. It is not applied to `initialize`, which is an
+   * instance-load lifecycle hook rather than a platform event.
+   */
+  readonly eventLayer?: Layer$1.Layer<REvent, EventLayerError, RuntimeContext<NoInfer<RRuntime | RAlarm>>>;
+  /**
+   * Effect run when Cloudflare loads this Durable Object instance into memory.
+   *
+   * Use `DurableObjectState.blockConcurrencyWhile` inside this hook when
+   * incoming events should wait for setup to finish. Cloudflare may construct
+   * the same Durable Object id again after eviction or restart; use Durable
+   * Object storage if work must happen only once per id.
+   */
+  readonly initialize?: Effect.Effect<void, unknown, HandlerContext<NoInfer<RRuntime | RAlarm>>>;
+  /**
+   * Optional RPC methods exposed as Durable Object instance methods.
+   *
+   * After every invocation, the configured OTLP flusher is scheduled through
+   * `DurableObjectState.waitUntil`, including when the handler fails. The
+   * scheduled flush silently settles within two seconds even if the exporter
+   * does not.
+   */
+  readonly rpc?: Rpc;
+  /** Accept live native trace metadata. The client must also enable rpcTracing. */
+  readonly rpcTracing?: ReceiverOptions;
+  readonly fetch?: Effect.Effect<Response, unknown, FetchContext<NoInfer<RRuntime | REvent | RAlarm>>>;
+  /** Register handlers to provide their typed scheduler to application layers and all DO events. */
+  readonly alarms?: Effect.Effect<unknown, unknown, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>> | AlarmRegistration<RAlarm, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>, unknown>;
+  /**
+   * Optional raw alarm handler.
+   *
+   * After every invocation, the configured OTLP flusher is scheduled through
+   * `DurableObjectState.waitUntil`, including when the handler fails. The
+   * scheduled flush silently settles within two seconds even if the exporter
+   * does not.
+   */
+  readonly alarm?: (alarmInfo?: globalThis.AlarmInvocationInfo) => Effect.Effect<void, unknown, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>>;
+  readonly webSocketMessage?: (socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, unknown, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>>;
+  readonly webSocketClose?: (socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, unknown, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>>;
+  readonly webSocketError?: (socket: DurableWebSocket, cause: unknown) => Effect.Effect<void, unknown, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>>;
+}
+type CheckAlarmRegistration<RProvided, RAlarm> = [Exclude<Extract<NoInfer<RProvided>, AlarmService>, NoInfer<RAlarm>>] extends [never] ? unknown : never;
+/** A declared event or alarm service must have its corresponding provider. */
+type DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never, Rpc extends DurableObjectRpc<RRuntime | REvent | RAlarm> = Record<never, never>, RAlarm = never> = DurableObjectOptionsBase<RRuntime, REvent, EventLayerError, Rpc, RAlarm> & CheckAlarmRegistration<RRuntime | REvent, RAlarm> & ([Exclude<REvent, RuntimeContext<RRuntime | RAlarm> | Scope.Scope>] extends [never] ? unknown : {
+  readonly eventLayer: Layer$1.Layer<REvent, EventLayerError, RuntimeContext<NoInfer<RRuntime | RAlarm>>>;
+}) & ([RAlarm] extends [never] ? unknown : {
+  readonly alarms: AlarmRegistration<RAlarm, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>, unknown>;
+});
+/**
+ * Cloudflare `DurableObject` constructor produced by {@link make}.
+ */
+type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (state: globalThis.DurableObjectState, env: WorkerEnv) => DurableObject<WorkerEnv> & DurableObjectRpcApi<Rpc, ROut> & {
+  [RunSymbol]<A, E>(effect: Effect.Effect<A, E, HandlerContext<ROut>>, options?: RunOptions): Promise<A>;
+};
+/**
+ * Builds a Durable Object whose base `layer` lives for the in-memory instance.
+ * Cloudflare does not expose an eviction or shutdown hook, so finalizers in
+ * that layer are not guaranteed to run. Put resources that require timely
+ * release in `eventLayer`, whose scope closes after each handled event.
+ */
+declare function make<ROut, LayerError>(layer: Layer$1.Layer<ROut, LayerError, RuntimeContext<never>> & CheckAlarmRegistration<ROut, never>): DurableObjectClass<Record<never, never>, ROut>;
+declare function make<ROut, LayerError, REvent = never, EventLayerError = never, const Rpc extends DurableObjectRpc<NoInfer<ROut> | REvent | NoInfer<RAlarm>> = Record<never, never>, RAlarm = never>(layer: Layer$1.Layer<ROut, LayerError, RuntimeContext<NoInfer<RAlarm>>>, options: DurableObjectOptions<ROut, REvent, EventLayerError, Rpc, RAlarm>): DurableObjectClass<Rpc, ROut | REvent | RAlarm>;
+//#endregion
+export { type Api, type Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcApi, type DurableObjectRpcApi as DurableObjectRpcShape, DurableObject_d_exports, type HandlerEffect, type Handlers, type LayerOptions, type Method, type Methods, type NoReservedMethods, type Options, type ReservedMethodName, RpcHandlers, RunOptions, RunSymbol, RuntimeContext, type ServerApi, type ServiceFreeSchema, Tag, type TagClass, implement, make, method };

package/dist/DurableObject.mjs

@@ -0,0 +1,77 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { fromWebSocket } from "./DurableObjectWebSocket.mjs";
+import { DurableObjectState, fromDurableObjectState } from "./DurableObjectState.mjs";
+import { reservedMethodNames as reservedMethodNames$1 } from "./RpcDefinition.mjs";
+import { assumeEntrypointClass, defineEntrypointRpcMethods } from "./internal/Entrypoint.mjs";
+import { makeEntrypointRuntime, runEventPromise } from "./internal/Runtime.mjs";
+import { scheduleTelemetryFlush as scheduleTelemetryFlush$1 } from "./internal/Telemetry.mjs";
+import { NativeRequest } from "./Worker.mjs";
+import { DurableObjectAlarm } from "./DurableObjectAlarm.mjs";
+import { Tag, implement, method } from "./DurableObjectDefinition.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { DurableObject } from "cloudflare:workers";
+import * as Tracer from "effect/Tracer";
+//#region src/DurableObject.ts
+var DurableObject_exports = /* @__PURE__ */ __exportAll({
+	RunSymbol: () => RunSymbol,
+	Tag: () => Tag,
+	implement: () => implement,
+	make: () => make,
+	method: () => method
+});
+const reservedMethodNames = reservedMethodNames$1;
+/** Override to instrument the whole event, then call super[RunSymbol]. */
+const RunSymbol = Symbol.for("effect-cf/DurableObject/run");
+const scheduleTelemetryFlush = scheduleTelemetryFlush$1((flush) => Effect.flatMap(DurableObjectState, (state) => state.waitUntil(flush)));
+function make(layer, options = {}) {
+	const registration = options.alarms !== void 0 && !Effect.isEffect(options.alarms) ? options.alarms : void 0;
+	const logicalAlarms = (registration?.run ?? (Effect.isEffect(options.alarms) ? options.alarms : void 0))?.pipe(Effect.asVoid);
+	class EffectDurableObject extends DurableObject {
+		runtime;
+		constructor(state, env) {
+			super(state, env);
+			const baseServices = DurableObjectAlarm.layer.pipe(Layer.provideMerge(Layer.succeed(DurableObjectState, fromDurableObjectState(state))));
+			const services = (registration?.layer ?? Layer.empty).pipe(Layer.provideMerge(baseServices));
+			this.runtime = makeEntrypointRuntime(layer, env, services);
+			const initialize = options.initialize;
+			if (initialize !== void 0) state.waitUntil(this[RunSymbol](initialize, { eventLayer: false }));
+		}
+		[RunSymbol](effect, runOptions = {}) {
+			const eventLayer = runOptions.eventLayer === false ? void 0 : options.eventLayer;
+			const parent = runOptions.rpc?.parent;
+			const parentSpan = parent === void 0 ? void 0 : Tracer.externalSpan(parent);
+			if (eventLayer === void 0) return runEventPromise(this.runtime, effect, void 0, parentSpan);
+			return runEventPromise(this.runtime, effect, eventLayer, parentSpan);
+		}
+		fetch(request) {
+			const fetchHandler = options.fetch;
+			if (fetchHandler === void 0) return Promise.resolve(new Response("Not Found", { status: 404 }));
+			return this[RunSymbol](Effect.provideService(fetchHandler, NativeRequest, request), { event: "fetch" });
+		}
+		alarm(alarmInfo) {
+			const rawAlarm = options.alarm?.(alarmInfo);
+			const alarmEffect = logicalAlarms !== void 0 && rawAlarm !== void 0 ? Effect.gen(function* () {
+				yield* logicalAlarms;
+				yield* rawAlarm;
+			}) : logicalAlarms ?? rawAlarm;
+			if (alarmEffect !== void 0) return this[RunSymbol](alarmEffect.pipe(Effect.onExit(() => scheduleTelemetryFlush)), { event: "alarm" });
+		}
+		webSocketMessage(socket, message) {
+			if (options.webSocketMessage !== void 0) return this[RunSymbol](options.webSocketMessage(fromWebSocket(socket), message), { event: "webSocketMessage" });
+		}
+		webSocketClose(socket, code, reason, wasClean) {
+			if (options.webSocketClose !== void 0) return this[RunSymbol](options.webSocketClose(fromWebSocket(socket), code, reason, wasClean), { event: "webSocketClose" });
+		}
+		webSocketError(socket, cause) {
+			if (options.webSocketError !== void 0) return this[RunSymbol](options.webSocketError(fromWebSocket(socket), cause), { event: "webSocketError" });
+		}
+	}
+	defineEntrypointRpcMethods("Durable Object", EffectDurableObject.prototype, options.rpc, reservedMethodNames, (self, effect, rpc) => self[RunSymbol](effect, {
+		event: "rpc",
+		rpc
+	}), () => scheduleTelemetryFlush, options.rpcTracing);
+	return assumeEntrypointClass(EffectDurableObject);
+}
+//#endregion
+export { DurableObject_exports, RunSymbol, Tag, implement, make, method };

package/dist/DurableObjectAlarm.d.mts

@@ -0,0 +1,187 @@
+import { StorageOperationError } from "./DurableObjectStorage.mjs";
+import { DurableObjectState } from "./DurableObjectState.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import * as Layer from "effect/Layer";
+import * as Duration from "effect/Duration";
+import * as DateTime from "effect/DateTime";
+declare namespace DurableObjectAlarm_d_exports {
+  export { AlarmDefinitionConfig, AlarmDefinitionEntry, AlarmDefinitionPayload, AlarmDefinitions, AlarmFailurePolicy, AlarmPayload, AlarmPayloadSchema, AlarmRef, AlarmRegistration, AlarmRetryPolicy, AlarmScheduler, AlarmService, AlarmTagClass, AlarmTransaction, DefinedAlarmEvent, DefinedAlarmHandlers, DefinedAlarmScheduler, DefinedAlarmTransaction, DefinedScheduleAlarmInput, DurableObjectAlarm, DurableObjectAlarmError, DurableObjectAlarmEvent, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, ProcessDueAlarmsFailure, ProcessDueAlarmsFailureAction, ProcessDueAlarmsHandler, ProcessDueAlarmsMode, ProcessDueAlarmsOptions, ProcessDueAlarmsResult, ScheduleAlarmInput, StoredAlarmDecodeError, Tag, define, processDue };
+}
+type AlarmPayload = S.Json;
+declare const InvalidAlarmRefError_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: "InvalidAlarmRefError";
+} & Readonly<A>;
+declare class InvalidAlarmRefError extends InvalidAlarmRefError_base<{
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const InvalidAlarmPayloadError_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: "InvalidAlarmPayloadError";
+} & Readonly<A>;
+declare class InvalidAlarmPayloadError extends InvalidAlarmPayloadError_base<{
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const InvalidRepeatEveryError_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: "InvalidRepeatEveryError";
+} & Readonly<A>;
+declare class InvalidRepeatEveryError extends InvalidRepeatEveryError_base<{
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const InvalidProcessDueAlarmsOptionsError_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: "InvalidProcessDueAlarmsOptionsError";
+} & Readonly<A>;
+declare class InvalidProcessDueAlarmsOptionsError extends InvalidProcessDueAlarmsOptionsError_base<{
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const StoredAlarmDecodeError_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: "StoredAlarmDecodeError";
+} & Readonly<A>;
+declare class StoredAlarmDecodeError extends StoredAlarmDecodeError_base<{
+  readonly cause: unknown;
+  readonly storageId: string;
+}> {
+  get message(): string;
+}
+type DurableObjectAlarmError = InvalidAlarmPayloadError | InvalidAlarmRefError | InvalidProcessDueAlarmsOptionsError | InvalidRepeatEveryError | StorageOperationError | StoredAlarmDecodeError;
+declare const DurableObjectAlarmEvent: S.TaggedUnion<{
+  readonly AlarmDue: S.TaggedStruct<"AlarmDue", {
+    readonly id: S.NonEmptyString;
+    readonly payload: S.Codec<S.Json, S.Json, never, never>;
+    /** Persisted due time, which can differ from the invocation time during retries. */
+    readonly scheduledAt: S.DateTimeUtc;
+    readonly tag: S.NonEmptyString;
+  }>;
+}>;
+type DurableObjectAlarmEvent = typeof DurableObjectAlarmEvent.Type;
+type AlarmRef<Tag extends string = string> = {
+  readonly id: string;
+  readonly tag: Tag;
+};
+/** Reusing `{tag, id}` replaces an alarm. Repeats run after success, never as fixed-cadence catch-up. */
+type ScheduleAlarmInput<Tag extends string = string> = AlarmRef<Tag> & {
+  readonly payload: AlarmPayload;
+  readonly repeatEvery?: Duration.Input;
+  readonly runAt: DateTime.Utc;
+};
+type ProcessDueAlarmsMode = "isolated" | "ordered";
+interface ProcessDueAlarmsFailure {
+  readonly cause: unknown;
+  readonly event?: DurableObjectAlarmEvent;
+  readonly id: string;
+  readonly storageId: string;
+  readonly tag: string;
+}
+interface ProcessDueAlarmsResult {
+  readonly failed: readonly ProcessDueAlarmsFailure[];
+  readonly handled: readonly DurableObjectAlarmEvent[];
+}
+type ProcessDueAlarmsFailureAction = "ordered" | "retry" | "skip-and-advance-repeat" | {
+  readonly mode: "ordered";
+} | {
+  readonly mode: "retry";
+  readonly retryFailedAfter?: Duration.Input;
+} | {
+  readonly mode: "skip-and-advance-repeat";
+};
+interface ProcessDueAlarmsOptions<OnFailureR = never, OnFailureE = never> {
+  readonly limit?: number;
+  /** `isolated` retries only the failed row; `ordered` stops before later rows. */
+  readonly mode?: ProcessDueAlarmsMode;
+  readonly onFailure?: (failure: ProcessDueAlarmsFailure) => Effect.Effect<ProcessDueAlarmsFailureAction | void, OnFailureE, OnFailureR>;
+  readonly retryFailedAfter?: Duration.Input;
+}
+type ProcessDueAlarmsHandler<R = never, E = never> = (event: DurableObjectAlarmEvent) => Effect.Effect<void, E, R>;
+/**
+ * Alarm mutations owned by one transaction callback. Run them in the callback's
+ * fiber; forked work and use after the callback ends fail with StorageOperationError.
+ */
+type AlarmTransaction = Pick<AlarmScheduler, "scheduleAlarm" | "cancelAlarm">;
+/** Own `storage.setAlarm()` exclusively: a Durable Object has one platform alarm timestamp. */
+type AlarmScheduler = {
+  /**
+   * Commits local application storage and logical alarms in one native SQLite
+   * Durable Object transaction, reconciling the native alarm before commit.
+   * Use the supplied mutations, not standalone alarm methods or nested transactions.
+   * SqlClient queries must use this same Durable Object's storage.
+   *
+   * Failure, defects and interruption before commit roll back. A lost reply or
+   * interruption after commit does not undo committed state. Keep RPC and other
+   * external effects outside; atomically pre-arm a later wake before fallible work.
+   * Cloudflare's native retries are bounded; composition does not remove the
+   * pre-arm requirement or promise infinite retry liveness.
+   */
+  readonly transaction: <A, E, R>(closure: (alarms: AlarmTransaction) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | StorageOperationError, R>;
+  readonly cancelAlarm: (input: AlarmRef) => Effect.Effect<void, InvalidAlarmRefError | StorageOperationError>;
+  /** Acknowledge after handling. Conditional writes preserve handler replacements; alarms are at-least-once. */
+  readonly processDueAlarms: <R = never, E = never, OnFailureR = never, OnFailureE = never>(handle: ProcessDueAlarmsHandler<R, E>, options?: ProcessDueAlarmsOptions<OnFailureR, OnFailureE>) => Effect.Effect<ProcessDueAlarmsResult, E | OnFailureE | DurableObjectAlarmError, R | OnFailureR>;
+  /** A failed platform setAlarm rolls back the logical schedule in the same transaction. */
+  readonly scheduleAlarm: (input: ScheduleAlarmInput) => Effect.Effect<void, InvalidAlarmPayloadError | InvalidAlarmRefError | InvalidRepeatEveryError | StorageOperationError>;
+};
+declare const processDue: <R = never, E = never, OnFailureR = never, OnFailureE = never>(handle: ProcessDueAlarmsHandler<R, E>, options?: ProcessDueAlarmsOptions<OnFailureR, OnFailureE>) => Effect.Effect<ProcessDueAlarmsResult, E | OnFailureE | DurableObjectAlarmError, OnFailureR | R | DurableObjectAlarm>;
+type AlarmPayloadSchema = S.Codec<any, any, never, never>;
+type AlarmFailurePolicy = "ordered" | "retry" | "skip-and-advance-repeat";
+interface AlarmRetryPolicy {
+  readonly initialDelay?: Duration.Input;
+}
+interface AlarmDefinitionConfig<Payload extends AlarmPayloadSchema = AlarmPayloadSchema> {
+  readonly failure?: AlarmFailurePolicy;
+  readonly payload: Payload;
+  readonly retry?: AlarmRetryPolicy;
+}
+type AlarmDefinitionEntry = AlarmDefinitionConfig | AlarmPayloadSchema;
+type AlarmDefinitions = Readonly<Record<string, AlarmDefinitionEntry>>;
+type AlarmDefinitionSchema<Definition> = Definition extends AlarmDefinitionConfig<infer Payload> ? Payload : Definition;
+type AlarmDefinitionPayload<Definition> = AlarmDefinitionSchema<Definition> extends S.Codec<infer A, any, never, never> ? A : never;
+type DefinedAlarmEvent<Tag extends string, Payload> = Omit<DurableObjectAlarmEvent, "payload" | "tag"> & {
+  readonly payload: Payload;
+  readonly tag: Tag;
+};
+type DefinedAlarmHandlers<Definitions extends AlarmDefinitions, R = never, E = never> = { readonly [Tag in keyof Definitions & string]: (event: DefinedAlarmEvent<Tag, AlarmDefinitionPayload<Definitions[Tag]>>) => Effect.Effect<void, E, R>; };
+/** A discriminated union keeps each tag paired with its decoded payload type. */
+type DefinedScheduleAlarmInput<Definitions extends AlarmDefinitions> = { readonly [Tag in keyof Definitions & string]: Omit<ScheduleAlarmInput<Tag>, "payload"> & {
+  readonly payload: AlarmDefinitionPayload<Definitions[Tag]>;
+}; }[keyof Definitions & string];
+interface DefinedAlarmTransaction<Definitions extends AlarmDefinitions> {
+  readonly scheduleAlarm: (input: DefinedScheduleAlarmInput<Definitions>) => ReturnType<AlarmScheduler["scheduleAlarm"]>;
+  readonly cancelAlarm: (input: AlarmRef<keyof Definitions & string>) => ReturnType<AlarmScheduler["cancelAlarm"]>;
+}
+declare const TypedAlarmSchedulerTypeId: unique symbol;
+/** Identifies service requirements whose scheduler needs a registered dispatcher. */
+interface AlarmService {
+  readonly Service: {
+    readonly [TypedAlarmSchedulerTypeId]: typeof TypedAlarmSchedulerTypeId;
+  };
+}
+interface DefinedAlarmScheduler<Definitions extends AlarmDefinitions> extends DefinedAlarmTransaction<Definitions> {
+  readonly [TypedAlarmSchedulerTypeId]: typeof TypedAlarmSchedulerTypeId;
+  readonly transaction: <A, E, R>(closure: (alarms: DefinedAlarmTransaction<Definitions>) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | StorageOperationError, R>;
+}
+/** Registers a dispatcher and the service authorized to schedule its alarms. */
+interface AlarmRegistration<Self, R = never, E = never> {
+  readonly layer: Layer.Layer<Self, never, DurableObjectAlarm>;
+  readonly run: Effect.Effect<ProcessDueAlarmsResult, E | DurableObjectAlarmError, R | DurableObjectAlarm>;
+}
+interface AlarmTagClass<Self, Id extends string, Definitions extends AlarmDefinitions> extends Context.ServiceClass<Self, Id, DefinedAlarmScheduler<Definitions>> {
+  readonly handlers: <R = never, E = never>(handlers: DefinedAlarmHandlers<Definitions, R, E>, options?: ProcessDueAlarmsOptions<R, E>) => AlarmRegistration<Self, R, E>;
+}
+/** Handler-only definitions for applications using the raw scheduler. Prefer Tag for typed scheduling. */
+declare const define: <const Definitions extends AlarmDefinitions>(definitions: Definitions) => {
+  handlers: <R = never, E = never>(handlers: DefinedAlarmHandlers<Definitions, R, E>, options?: ProcessDueAlarmsOptions<R, E> | undefined) => Effect.Effect<ProcessDueAlarmsResult, E | DurableObjectAlarmError, R | DurableObjectAlarm>;
+};
+/** The typed scheduler becomes available when its handlers are registered on a Durable Object. */
+declare const Tag: <Self>() => <const Id extends string, const Definitions extends AlarmDefinitions>(id: Id, definitions: Definitions) => AlarmTagClass<Self, Id, Definitions>;
+declare const DurableObjectAlarm_base: Context.ServiceClass<DurableObjectAlarm, "effect-cf/DurableObjectAlarm", AlarmScheduler>;
+declare class DurableObjectAlarm extends DurableObjectAlarm_base {
+  static readonly layer: Layer.Layer<DurableObjectAlarm, never, DurableObjectState>;
+}
+//#endregion
+export { AlarmDefinitionConfig, AlarmDefinitionEntry, AlarmDefinitionPayload, AlarmDefinitions, AlarmFailurePolicy, AlarmPayload, AlarmPayloadSchema, AlarmRef, AlarmRegistration, AlarmRetryPolicy, AlarmScheduler, AlarmService, AlarmTagClass, AlarmTransaction, DefinedAlarmEvent, DefinedAlarmHandlers, DefinedAlarmScheduler, DefinedAlarmTransaction, DefinedScheduleAlarmInput, DurableObjectAlarm, DurableObjectAlarmError, DurableObjectAlarmEvent, DurableObjectAlarm_d_exports, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, ProcessDueAlarmsFailure, ProcessDueAlarmsFailureAction, ProcessDueAlarmsHandler, ProcessDueAlarmsMode, ProcessDueAlarmsOptions, ProcessDueAlarmsResult, ScheduleAlarmInput, StoredAlarmDecodeError, Tag, define, processDue };