effect-cf 0.39.1 → 0.40.1

package/dist/DurableObjectAlarm.mjs

@@ -0,0 +1,344 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { causeMessage } from "./internal/ErrorMessage.mjs";
+import { StorageOperationError } from "./DurableObjectStorage.mjs";
+import { DurableObjectState } from "./DurableObjectState.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 Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
+import * as Exit from "effect/Exit";
+import * as Clock from "effect/Clock";
+import * as Duration from "effect/Duration";
+import * as DateTime from "effect/DateTime";
+//#region src/DurableObjectAlarm.ts
+var DurableObjectAlarm_exports = /* @__PURE__ */ __exportAll({
+	DurableObjectAlarm: () => DurableObjectAlarm,
+	DurableObjectAlarmEvent: () => DurableObjectAlarmEvent,
+	InvalidAlarmPayloadError: () => InvalidAlarmPayloadError,
+	InvalidAlarmRefError: () => InvalidAlarmRefError,
+	InvalidProcessDueAlarmsOptionsError: () => InvalidProcessDueAlarmsOptionsError,
+	InvalidRepeatEveryError: () => InvalidRepeatEveryError,
+	StoredAlarmDecodeError: () => StoredAlarmDecodeError,
+	Tag: () => Tag,
+	define: () => define,
+	processDue: () => processDue
+});
+const INIT_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS effect_cf_scheduled_alarms (
+  storage_id TEXT PRIMARY KEY,
+  alarm_id TEXT NOT NULL,
+  tag TEXT NOT NULL,
+  run_at INTEGER NOT NULL,
+  repeat_every_ms INTEGER,
+  payload TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_effect_cf_scheduled_alarms_run_at_storage_id
+  ON effect_cf_scheduled_alarms (run_at, storage_id);
+`;
+const DEFAULT_PROCESS_DUE_ALARMS_LIMIT = 100;
+const DEFAULT_PROCESS_DUE_ALARMS_FAILURE_RESCHEDULE_AFTER = "30 seconds";
+const getScheduledEventId = (input) => `effect-cf-alarm:${encodeURIComponent(input.tag)}:${encodeURIComponent(input.id)}`;
+var InvalidAlarmRefError = class extends Data.TaggedError("InvalidAlarmRefError") {
+	get message() {
+		return `Invalid Durable Object alarm ref: ${causeMessage(this.cause)}`;
+	}
+};
+var InvalidAlarmPayloadError = class extends Data.TaggedError("InvalidAlarmPayloadError") {
+	get message() {
+		return `Invalid Durable Object alarm payload: ${causeMessage(this.cause)}`;
+	}
+};
+var InvalidRepeatEveryError = class extends Data.TaggedError("InvalidRepeatEveryError") {
+	get message() {
+		return `Invalid Durable Object alarm repeatEvery: ${causeMessage(this.cause)}`;
+	}
+};
+var InvalidProcessDueAlarmsOptionsError = class extends Data.TaggedError("InvalidProcessDueAlarmsOptionsError") {
+	get message() {
+		return `Invalid processDueAlarms options: ${causeMessage(this.cause)}`;
+	}
+};
+var StoredAlarmDecodeError = class extends Data.TaggedError("StoredAlarmDecodeError") {
+	get message() {
+		return `Failed to decode stored alarm "${this.storageId}": ${causeMessage(this.cause)}`;
+	}
+};
+const DurableObjectAlarmEvent = S.TaggedUnion({ AlarmDue: {
+	id: S.NonEmptyString,
+	payload: S.Json,
+	/** Persisted due time, which can differ from the invocation time during retries. */
+	scheduledAt: S.DateTimeUtc,
+	tag: S.NonEmptyString
+} });
+const AlarmRefSchema = S.Struct({
+	id: S.NonEmptyString,
+	tag: S.NonEmptyString
+});
+const decodeAlarmRef = (input) => S.decodeUnknownEffect(AlarmRefSchema)(input).pipe(Effect.mapError((cause) => new InvalidAlarmRefError({ cause })));
+const StoredPayloadString = S.fromJsonString(S.Json);
+const decodeStoredPayload = (row) => S.decodeUnknownEffect(StoredPayloadString)(row.payload).pipe(Effect.mapError((cause) => new StoredAlarmDecodeError({
+	cause,
+	storageId: row.storage_id
+})));
+const encodeStoredPayload = (payload) => S.encodeEffect(StoredPayloadString)(payload).pipe(Effect.mapError((cause) => new InvalidAlarmPayloadError({ cause })));
+const ensureTable = (state) => state.storage.sql.exec(INIT_TABLE_SQL).pipe(Effect.asVoid);
+const toRepeatEveryMillis = (input) => {
+	if (input === void 0) return Effect.succeed(null);
+	return Effect.try({
+		try: () => {
+			const millis = Duration.toMillis(input);
+			if (!Number.isFinite(millis) || millis <= 0) throw new Error("Alarm repeatEvery must be a positive finite duration");
+			return Math.ceil(millis);
+		},
+		catch: (cause) => new InvalidRepeatEveryError({ cause })
+	});
+};
+const toAlarmDue = (row) => Effect.gen(function* () {
+	if (!Number.isFinite(row.run_at)) return yield* Effect.fail(new StoredAlarmDecodeError({
+		cause: /* @__PURE__ */ new Error("Stored alarm run_at must be a finite number"),
+		storageId: row.storage_id
+	}));
+	return DurableObjectAlarmEvent.make({
+		_tag: "AlarmDue",
+		id: row.alarm_id,
+		payload: yield* decodeStoredPayload(row),
+		scheduledAt: DateTime.makeUnsafe(row.run_at),
+		tag: row.tag
+	});
+});
+const getProcessLimit = (options) => {
+	const limit = options?.limit ?? DEFAULT_PROCESS_DUE_ALARMS_LIMIT;
+	if (!Number.isSafeInteger(limit) || limit <= 0) return Effect.fail(new InvalidProcessDueAlarmsOptionsError({ cause: /* @__PURE__ */ new Error("processDueAlarms limit must be a positive safe integer") }));
+	return Effect.succeed(limit);
+};
+const toFailureRescheduleMillis = (input) => Effect.try({
+	try: () => {
+		const millis = Duration.toMillis(input);
+		if (!Number.isFinite(millis) || millis <= 0) throw new Error("Alarm failure rescheduleAfter must be a positive finite duration");
+		return Math.ceil(millis);
+	},
+	catch: (cause) => new InvalidProcessDueAlarmsOptionsError({ cause })
+});
+const getFailureRetryDelay = (options) => toFailureRescheduleMillis(options?.retryFailedAfter ?? DEFAULT_PROCESS_DUE_ALARMS_FAILURE_RESCHEDULE_AFTER);
+const getFailureActionMode = (action) => Predicate.isString(action) ? action : action.mode;
+const getFailureActionRetryDelay = (action) => Predicate.isString(action) || action.mode !== "retry" ? void 0 : action.retryFailedAfter;
+const processDue = (handle, options = {}) => Effect.gen(function* () {
+	return yield* (yield* DurableObjectAlarm).processDueAlarms(handle, options);
+});
+const TypedAlarmSchedulerTypeId = Symbol.for("effect-cf/DurableObjectAlarm/TypedScheduler");
+const isAlarmDefinitionConfig = (definition) => Predicate.isObject(definition) && "payload" in definition;
+const getAlarmDefinitionSchema = (definition) => isAlarmDefinitionConfig(definition) ? definition.payload : definition;
+const getAlarmDefinitionFailureAction = (definition) => {
+	if (definition === void 0 || !isAlarmDefinitionConfig(definition)) return;
+	if (definition.failure === void 0) return;
+	return definition.failure === "retry" ? {
+		mode: "retry",
+		retryFailedAfter: definition.retry?.initialDelay
+	} : { mode: definition.failure };
+};
+const makeDefinition = (definitions) => {
+	const definitionFor = (tag) => Object.hasOwn(definitions, tag) ? definitions[tag] : void 0;
+	const bind = (mutations) => ({
+		scheduleAlarm: Effect.fn("DefinedAlarms.scheduleAlarm")(function* (input) {
+			const definition = definitionFor(input.tag);
+			if (definition === void 0) return yield* Effect.fail(new InvalidAlarmRefError({ cause: /* @__PURE__ */ new Error(`Unknown alarm tag "${input.tag}"`) }));
+			const payload = yield* S.encodeEffect(getAlarmDefinitionSchema(definition))(input.payload).pipe(Effect.flatMap(S.decodeUnknownEffect(S.Json)), Effect.mapError((cause) => new InvalidAlarmPayloadError({ cause })));
+			yield* mutations.scheduleAlarm({
+				...input,
+				payload
+			});
+		}),
+		cancelAlarm: Effect.fn("DefinedAlarms.cancelAlarm")(function* (input) {
+			if (definitionFor(input.tag) === void 0) return yield* Effect.fail(new InvalidAlarmRefError({ cause: /* @__PURE__ */ new Error(`Unknown alarm tag "${input.tag}"`) }));
+			yield* mutations.cancelAlarm(input);
+		})
+	});
+	return {
+		make: (alarms) => ({
+			[TypedAlarmSchedulerTypeId]: TypedAlarmSchedulerTypeId,
+			...bind(alarms),
+			transaction: (closure) => alarms.transaction((tx) => closure(bind(tx)))
+		}),
+		handlers: (handlers, options) => processDue((event) => Effect.gen(function* () {
+			const definition = definitionFor(event.tag);
+			if (definition === void 0) return yield* Effect.fail(new StoredAlarmDecodeError({
+				cause: /* @__PURE__ */ new Error(`Unknown alarm tag "${event.tag}"`),
+				storageId: getScheduledEventId(event)
+			}));
+			const schema = getAlarmDefinitionSchema(definition);
+			const payload = yield* S.decodeUnknownEffect(schema)(event.payload).pipe(Effect.mapError((cause) => new StoredAlarmDecodeError({
+				cause,
+				storageId: getScheduledEventId(event)
+			})));
+			const handler = handlers[event.tag];
+			yield* handler({
+				...event,
+				payload
+			});
+		}), {
+			...options,
+			onFailure: (failure) => Effect.gen(function* () {
+				const action = getAlarmDefinitionFailureAction(definitionFor(failure.tag));
+				const optionAction = options?.onFailure === void 0 ? void 0 : yield* options.onFailure(failure);
+				return action ?? optionAction;
+			})
+		})
+	};
+};
+/** Handler-only definitions for applications using the raw scheduler. Prefer Tag for typed scheduling. */
+const define = (definitions) => ({ handlers: makeDefinition(definitions).handlers });
+/** The typed scheduler becomes available when its handlers are registered on a Durable Object. */
+const Tag = () => (id, definitions) => {
+	const tag = Context.Service()(id);
+	const definition = makeDefinition(definitions);
+	return Object.assign(tag, { handlers: (handlers, options) => ({
+		layer: Layer.effect(tag, Effect.map(DurableObjectAlarm, definition.make)),
+		run: definition.handlers(handlers, options)
+	}) });
+};
+var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("effect-cf/DurableObjectAlarm") {
+	static layer = Layer.effect(DurableObjectAlarm, Effect.gen(function* () {
+		const state = yield* DurableObjectState;
+		const reconcileAlarm = Effect.fn("DurableObjectAlarm.reconcileAlarm")(function* () {
+			const next = (yield* (yield* state.storage.sql.exec(`SELECT run_at FROM effect_cf_scheduled_alarms ORDER BY run_at ASC, storage_id ASC LIMIT 1`)).toArray())[0];
+			if (next === void 0) {
+				yield* state.storage.deleteAlarm();
+				return;
+			}
+			yield* state.storage.setAlarm(next.run_at);
+		});
+		const rescheduleFailedAlarm = Effect.fn("DurableObjectAlarm.rescheduleFailedAlarm")(function* (row, retryDelayMillis) {
+			const retryAt = (yield* Clock.currentTimeMillis) + retryDelayMillis;
+			if (row.repeat_every_ms === null) {
+				yield* (yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms
+                  SET run_at = ?
+                WHERE storage_id = ?
+                  AND run_at = ?
+                  AND repeat_every_ms IS NULL
+                  AND payload = ?`, retryAt, row.storage_id, row.run_at, row.payload)).rowsWritten;
+				return;
+			}
+			yield* (yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms
+                SET run_at = ?
+              WHERE storage_id = ?
+                AND run_at = ?
+                AND repeat_every_ms = ?
+                AND payload = ?`, retryAt, row.storage_id, row.run_at, row.repeat_every_ms, row.payload)).rowsWritten;
+		});
+		const acknowledgeAlarm = Effect.fn("DurableObjectAlarm.acknowledgeAlarm")(function* (row) {
+			if (row.repeat_every_ms === null) {
+				yield* (yield* state.storage.sql.exec(`DELETE FROM effect_cf_scheduled_alarms
+              WHERE storage_id = ?
+                AND run_at = ?
+                AND repeat_every_ms IS NULL
+                AND payload = ?`, row.storage_id, row.run_at, row.payload)).rowsWritten;
+				return;
+			}
+			const acknowledgedAt = yield* Clock.currentTimeMillis;
+			yield* (yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms
+              SET run_at = ?
+            WHERE storage_id = ?
+              AND run_at = ?
+              AND repeat_every_ms = ?
+              AND payload = ?`, acknowledgedAt + row.repeat_every_ms, row.storage_id, row.run_at, row.repeat_every_ms, row.payload)).rowsWritten;
+		});
+		const cancelAlarm = Effect.fn("DurableObjectAlarm.cancelAlarm")(function* (input) {
+			const ref = yield* decodeAlarmRef(input);
+			yield* state.storage.sql.exec(`DELETE FROM effect_cf_scheduled_alarms WHERE storage_id = ?`, getScheduledEventId(ref));
+		});
+		const scheduleAlarm = Effect.fn("DurableObjectAlarm.scheduleAlarm")(function* (input) {
+			const ref = yield* decodeAlarmRef(input);
+			const repeatEveryMillis = yield* toRepeatEveryMillis(input.repeatEvery);
+			const payload = yield* encodeStoredPayload(input.payload);
+			const runAt = DateTime.toEpochMillis(input.runAt);
+			yield* state.storage.sql.exec(`INSERT OR REPLACE INTO effect_cf_scheduled_alarms
+                   (storage_id, alarm_id, tag, run_at, repeat_every_ms, payload)
+                 VALUES (?, ?, ?, ?, ?, ?)`, getScheduledEventId(ref), ref.id, ref.tag, runAt, repeatEveryMillis, payload);
+		});
+		const transaction = (closure) => state.storage.transaction(() => Effect.withFiber((owner) => {
+			let active = true;
+			const requireActive = (effect) => Effect.withFiber((fiber) => active && fiber === owner ? effect : Effect.fail(new StorageOperationError({
+				operation: "alarm.transaction",
+				cause: /* @__PURE__ */ new Error("Alarm mutations require their active transaction callback")
+			})));
+			return Effect.gen(function* () {
+				yield* ensureTable(state);
+				const result = yield* Effect.suspend(() => closure({
+					cancelAlarm: (input) => requireActive(cancelAlarm(input)),
+					scheduleAlarm: (input) => requireActive(scheduleAlarm(input))
+				})).pipe(Effect.ensuring(Effect.sync(() => {
+					active = false;
+				})));
+				yield* reconcileAlarm();
+				return result;
+			});
+		}));
+		const processDueAlarms = Effect.fn("DurableObjectAlarm.processDueAlarms")(function* (handle, options) {
+			yield* ensureTable(state);
+			const mode = options?.mode ?? "isolated";
+			const limit = yield* getProcessLimit(options);
+			const now = yield* Clock.currentTimeMillis;
+			const dueRows = yield* (yield* state.storage.sql.exec(`SELECT storage_id, alarm_id, tag, run_at, repeat_every_ms, payload
+             FROM effect_cf_scheduled_alarms
+            WHERE run_at <= ?
+            ORDER BY run_at ASC, storage_id ASC
+            LIMIT ?`, now, limit)).toArray();
+			const handled = [];
+			const failed = [];
+			const handleFailure = function* (row, event, cause) {
+				const failure = {
+					cause,
+					event,
+					id: row.alarm_id,
+					storageId: row.storage_id,
+					tag: row.tag
+				};
+				failed.push(failure);
+				const failureAction = options?.onFailure === void 0 ? void 0 : yield* options.onFailure(failure);
+				const actionMode = failureAction === void 0 ? mode : getFailureActionMode(failureAction);
+				if (actionMode === "retry" || actionMode === "isolated") {
+					const actionRetryDelay = failureAction === void 0 ? void 0 : getFailureActionRetryDelay(failureAction);
+					const retryDelay = actionRetryDelay === void 0 ? yield* getFailureRetryDelay(options) : yield* toFailureRescheduleMillis(actionRetryDelay);
+					yield* rescheduleFailedAlarm(row, retryDelay);
+					return "continue";
+				}
+				if (actionMode === "skip-and-advance-repeat") {
+					yield* acknowledgeAlarm(row);
+					return "continue";
+				}
+				yield* reconcileAlarm();
+				return "stop";
+			};
+			for (const row of dueRows) {
+				const eventExit = yield* Effect.exit(toAlarmDue(row));
+				if (Exit.isFailure(eventExit)) {
+					if ((yield* handleFailure(row, void 0, eventExit.cause)) === "stop") return yield* Effect.failCause(eventExit.cause);
+					continue;
+				}
+				const event = eventExit.value;
+				const handleExit = yield* Effect.exit(handle(event));
+				if (Exit.isFailure(handleExit)) {
+					if ((yield* handleFailure(row, event, handleExit.cause)) === "stop") return yield* Effect.failCause(handleExit.cause);
+					continue;
+				}
+				yield* acknowledgeAlarm(row);
+				handled.push(event);
+			}
+			yield* reconcileAlarm();
+			return {
+				failed,
+				handled
+			};
+		});
+		return DurableObjectAlarm.of({
+			cancelAlarm: (input) => transaction((alarms) => alarms.cancelAlarm(input)),
+			processDueAlarms,
+			scheduleAlarm: (input) => transaction((alarms) => alarms.scheduleAlarm(input)),
+			transaction
+		});
+	}));
+};
+//#endregion
+export { DurableObjectAlarm, DurableObjectAlarmEvent, DurableObjectAlarm_exports, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, StoredAlarmDecodeError, Tag, define, processDue };

package/dist/DurableObjectDefinition.d.mts

@@ -0,0 +1,87 @@
+import { WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
+import { Provider } from "./Rpc.mjs";
+import { ReservedMethodName as ReservedMethodName$1 } from "./RpcDefinition.mjs";
+import { DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient } from "./DurableObjectNamespace.mjs";
+import { DurableObjectClass, DurableObjectHandler, DurableObjectOptions, RuntimeContext } from "./DurableObject.mjs";
+import * as Context$1 from "effect/Context";
+import { Layer, Schema } from "effect";
+declare namespace DurableObjectDefinition_d_exports {
+  export { Api, Definition, DurableObject, HandlerEffect, Handlers, LayerOptions, Method, Methods, NoReservedMethods, Options, ReservedMethodName, ServerApi, ServiceFreeSchema, Tag, TagClass, implement, make, method };
+}
+type ServiceFreeSchema = Schema.Codec<any, any, never, never>;
+interface Method<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema = ServiceFreeSchema> {
+  readonly args: Args;
+  readonly success: Success;
+}
+declare namespace Method {
+  export type Any = Method<ReadonlyArray<ServiceFreeSchema>, ServiceFreeSchema>;
+  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends ReadonlyArray<ServiceFreeSchema>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
+  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = { [Index in keyof Args]: Schema.Json; };
+  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
+  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
+  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
+  export type EncodedSuccess<_Self extends Any> = Schema.Json;
+  export {};
+}
+type Methods = Record<string, Method.Any>;
+/**
+ * RPC contract for a Durable Object class.
+ */
+interface Definition<Id extends string = string, MethodDefinitions extends Methods = Methods> {
+  readonly id: Id;
+  readonly methods: MethodDefinitions;
+}
+declare namespace Definition {
+  type Any = Definition<string, Methods>;
+}
+type ReservedMethodName = ReservedMethodName$1 | "fetch" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError";
+type NoReservedMethods<MethodDefinitions extends Methods> = Extract<keyof MethodDefinitions, ReservedMethodName> extends never ? MethodDefinitions : never;
+/**
+ * Promise-based client API derived from a Durable Object definition.
+ */
+type ServerApi<Self extends Definition.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method.Args<Self["methods"][Key]>) => Promise<Method.Success<Self["methods"][Key]>>; };
+type Api<Self extends Definition.Any> = Provider<ServerApi<Self>, ReservedMethodName>;
+/**
+ * Effect handlers for each RPC method in a Durable Object definition.
+ */
+type Handlers<ROut, Self extends Definition.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method.Args<Self["methods"][Key]>) => DurableObjectHandler<ROut, Method.Success<Self["methods"][Key]>>; };
+/**
+ * Durable Object constructor options for a specific RPC definition.
+ */
+type Options<ROut, Self extends Definition.Any, REvent = never, EventLayerError = never, RAlarm = never> = DurableObjectOptions<ROut, REvent, EventLayerError, Handlers<NoInfer<ROut> | REvent | NoInfer<RAlarm>, Self>, RAlarm> & {
+  readonly rpc: Handlers<NoInfer<ROut> | REvent | NoInfer<RAlarm>, Self>;
+};
+type LayerOptions = {
+  readonly binding: string;
+  readonly rpcTracing?: boolean;
+};
+type TagClass<Self, Id extends string, MethodDefinitions extends Methods> = Context$1.ServiceClass<Self, `effect-cf/DurableObject/${Id}`, DurableObjectNamespaceEffectClient<Api<Definition<Id, MethodDefinitions>>, Definition<Id, MethodDefinitions>>> & DurableObjectNamespaceStaticClient<Self, Api<Definition<Id, MethodDefinitions>>, Definition<Id, MethodDefinitions>> & {
+  readonly id: Id;
+  readonly methods: MethodDefinitions;
+  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never, RAlarm = never>(layer: Layer.Layer<ROut, LayerError, RuntimeContext<NoInfer<RAlarm>>>, options: Options<ROut, Definition<Id, MethodDefinitions>, REvent, EventLayerError, RAlarm>) => DurableObjectClass<Handlers<ROut | REvent | RAlarm, Definition<Id, MethodDefinitions>>, ROut | REvent | RAlarm>;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+};
+/**
+ * Defines a single RPC method schema in a Durable Object definition.
+ */
+declare function method<Success extends ServiceFreeSchema>(definition: {
+  readonly success: Success;
+}): Method<readonly [], Success>;
+declare function method<const Args extends ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema>(definition: {
+  readonly args: Args;
+  readonly success: Success;
+}): Method<Args, Success>;
+declare const make: <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass<Definition<Id, MethodDefinitions>, Id, MethodDefinitions>;
+declare const Tag: <Self>() => <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass<Self, Id, MethodDefinitions>;
+declare const DurableObject: typeof Tag;
+/**
+ * Helper for implementing handlers with the exact method shape of a definition.
+ */
+declare const implement: <ROut, const Self extends Definition.Any>(_definition: Self, handlers: Handlers<ROut, Self>) => Handlers<ROut, Self>;
+/**
+ * Convenience alias for a single Durable Object RPC handler Effect.
+ */
+type HandlerEffect<ROut, Self extends Definition.Any, Key extends keyof Self["methods"]> = DurableObjectHandler<ROut, Method.Success<Self["methods"][Key]>>;
+//#endregion
+export { Api, Definition, DurableObject, DurableObjectDefinition_d_exports, HandlerEffect, Handlers, LayerOptions, Method, Methods, NoReservedMethods, Options, ReservedMethodName, ServerApi, ServiceFreeSchema, Tag, TagClass, implement, make, method };

package/dist/DurableObjectDefinition.mjs

@@ -0,0 +1,125 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { assertNoReservedMethods, decodeArgs, encodeSuccess, make as make$1, method as method$1 } from "./RpcDefinition.mjs";
+import { recordDecodedArgs } from "./internal/RpcInvocation.mjs";
+import { layer, makeDirectMethods } from "./DurableObjectNamespace.mjs";
+import { make as make$2 } from "./DurableObject.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+//#region src/DurableObjectDefinition.ts
+var DurableObjectDefinition_exports = /* @__PURE__ */ __exportAll({
+	DurableObject: () => DurableObject,
+	Tag: () => Tag,
+	implement: () => implement,
+	make: () => make,
+	method: () => method
+});
+const reservedMethodNames = /* @__PURE__ */ new Set([
+	"constructor",
+	"dup",
+	"fetch",
+	"alarm",
+	"webSocketMessage",
+	"webSocketClose",
+	"webSocketError"
+]);
+function method(definition) {
+	return method$1(definition);
+}
+const makeDefinition = (id, methods) => {
+	assertNoReservedMethods("Durable Object", methods, reservedMethodNames);
+	const definition = make$1(id, methods);
+	return Object.assign(definition, { make: (layer, options) => make$2(layer, {
+		...options,
+		rpc: wrapHandlers(definition, options.rpc)
+	}) });
+};
+const make = (id, methods) => Tag()(id, methods);
+const Tag = () => (id, methods) => {
+	const definition = makeDefinition(id, methods);
+	const serviceKey = `effect-cf/DurableObject/${id}`;
+	const tag = Context.Service()(serviceKey);
+	const bindingDefinition = (binding) => ({
+		...binding,
+		definition
+	});
+	const layer$1 = (binding) => layer(tag, bindingDefinition(binding));
+	const newUniqueId = Effect.fn("DurableObject.newUniqueId")(function* (options) {
+		return yield* (yield* tag).newUniqueId(options);
+	});
+	const idFromName = Effect.fn("DurableObject.idFromName")(function* (name) {
+		return yield* (yield* tag).idFromName(name);
+	});
+	const idFromString = Effect.fn("DurableObject.idFromString")(function* (value) {
+		return yield* (yield* tag).idFromString(value);
+	});
+	const get = Effect.fn("DurableObject.get")(function* (objectId, options) {
+		return yield* (yield* tag).get(objectId, options);
+	});
+	const getByName = Effect.fn("DurableObject.getByName")(function* (name, options) {
+		return yield* (yield* tag).getByName(name, options);
+	});
+	const jurisdiction = Effect.fn("DurableObject.jurisdiction")(function* (value) {
+		return yield* (yield* tag).jurisdiction(value);
+	});
+	const fetch = Effect.fn("DurableObject.fetch")(function* (stub, input, init) {
+		return yield* (yield* tag).fetch(stub, input, init);
+	});
+	const rpc = Effect.fnUntraced(function* (stub, methodName, ...args) {
+		const invokeRpc = (yield* tag).rpc;
+		return yield* invokeRpc(stub, methodName, ...args);
+	});
+	const call = Effect.fnUntraced(function* (stub, methodName, ...args) {
+		const invokeCall = (yield* tag).call;
+		return yield* invokeCall(stub, methodName, ...args);
+	});
+	const scopedCall = Effect.fnUntraced(function* (stub, methodName, ...args) {
+		const invokeScopedCall = (yield* tag).scopedCall;
+		return yield* invokeScopedCall(stub, methodName, ...args);
+	});
+	const rawUnsafe = Effect.fnUntraced(function* () {
+		return yield* (yield* tag).rawUnsafe;
+	});
+	const directMethods = makeDirectMethods(definition, {
+		call,
+		fetch,
+		get,
+		getByName
+	});
+	return Object.assign(tag, directMethods, {
+		id: definition.id,
+		methods: definition.methods,
+		make: definition.make,
+		layer: layer$1,
+		newUniqueId,
+		idFromName,
+		idFromString,
+		get,
+		getByName,
+		jurisdiction,
+		fetch,
+		rpc,
+		call,
+		scopedCall,
+		rawUnsafe
+	});
+};
+const DurableObject = Tag;
+const wrapHandlers = (definition, handlers) => {
+	const wrapped = Object.create(Object.prototype);
+	for (const key of Object.keys(definition.methods)) {
+		const handler = handlers[key];
+		wrapped[key] = (...args) => Effect.gen(function* () {
+			const decodedArgs = yield* decodeArgs(definition, key, args);
+			yield* recordDecodedArgs(decodedArgs);
+			const value = yield* handler(...decodedArgs);
+			return yield* encodeSuccess(definition, key, value);
+		});
+	}
+	return wrapped;
+};
+/**
+* Helper for implementing handlers with the exact method shape of a definition.
+*/
+const implement = (_definition, handlers) => handlers;
+//#endregion
+export { DurableObject, DurableObjectDefinition_exports, Tag, implement, make, method };