effect-cf 0.39.0 → 0.40.0

package/dist/index.mjs

@@ -18,7 +18,7 @@ import { SqliteClient } from "@effect/sql-sqlite-do";
 import { NonRetryableError } from "cloudflare:workflows";
 //#region src/WorkersAi.ts
 var WorkersAi_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$13,
+	Tag: () => Tag$14,
 	WorkersAiOperationError: () => WorkersAiOperationError,
 	embeddingResponse: () => embeddingResponse,
 	isWorkersAiBinding: () => isWorkersAiBinding,
@@ -80,8 +80,8 @@ const makeClient$13 = (definition) => (ai) => {
 	};
 };
 const layer$17 = (tag, definition) => layer$18(tag, definition.binding, (value) => isWorkersAiBinding(value), makeClient$13(definition), { expected: expectedWorkersAiBinding });
-const make$14 = (id) => Tag$13()(id);
-const Tag$13 = () => (id) => {
+const make$14 = (id) => Tag$14()(id);
+const Tag$14 = () => (id) => {
 	const tag = Context.Service()(id);
 	const makeLayer = (definition) => layer$17(tag, definition);
 	return Object.assign(tag, {
@@ -93,7 +93,7 @@ const Tag$13 = () => (id) => {
 //#region src/AiGateway.ts
 var AiGateway_exports = /* @__PURE__ */ __exportAll({
 	AiGatewayOperationError: () => AiGatewayOperationError,
-	Tag: () => Tag$12,
+	Tag: () => Tag$13,
 	isAiGatewayBinding: () => isAiGatewayBinding,
 	layer: () => layer$16,
 	make: () => make$13,
@@ -249,8 +249,8 @@ const makeHttpClient = (definition, request = fetch) => {
 	};
 };
 const layer$16 = (tag, definition) => layer$18(tag, definition.binding, isAiGatewayBinding, (ai) => makeClientFromAi(definition, ai), { expected: expectedAiGatewayBinding });
-const make$13 = (id) => Tag$12()(id);
-const Tag$12 = () => (id) => {
+const make$13 = (id) => Tag$13()(id);
+const Tag$13 = () => (id) => {
 	const tag = Context.Service()(id);
 	const makeLayer = (definition) => layer$16(tag, definition);
 	return Object.assign(tag, {
@@ -267,7 +267,7 @@ var AnalyticsEngine_exports = /* @__PURE__ */ __exportAll({
 	AnalyticsEngineQueryError: () => AnalyticsEngineQueryError,
 	AnalyticsEngineWriteValidationError: () => AnalyticsEngineWriteValidationError,
 	QueryTag: () => QueryTag,
-	Tag: () => Tag$11,
+	Tag: () => Tag$12,
 	isAnalyticsEngineDataset: () => isAnalyticsEngineDataset,
 	layer: () => layer$15,
 	layerFetch: () => layerFetch,
@@ -288,7 +288,7 @@ const writeLimits = {
 	maxBlobs: 20,
 	maxDoubles: 20,
 	maxIndexes: 1,
-	maxBlobBytes: 16 * 1024,
+	maxBlobBytes: 16384,
 	maxIndexBytes: 96,
 	maxDataPointsPerInvocation: 250
 };
@@ -493,9 +493,9 @@ const queryLayerConfig = (tag, config = queryConfig()) => Layer.effect(tag, Effe
 }));
 const layerFetchConfig = (tag, config = queryConfig()) => queryLayerConfig(tag, config).pipe(Layer.provide(FetchHttpClient.layer));
 const layer$15 = (tag, definition) => layer$18(tag, definition.binding, isAnalyticsEngineDataset, makeClient$11(definition, definition.write), { expected: expectedAnalyticsEngineDataset });
-const make$12 = (id) => Tag$11()(id);
+const make$12 = (id) => Tag$12()(id);
 const makeQuery = (id) => QueryTag()(id);
-const Tag$11 = () => (id) => {
+const Tag$12 = () => (id) => {
 	const tag = Context.Service()(id);
 	const makeLayer = (definition) => layer$15(tag, definition);
 	return Object.assign(tag, {
@@ -521,7 +521,7 @@ const QueryTag = () => (id) => {
 //#region src/BrowserRendering.ts
 var BrowserRendering_exports = /* @__PURE__ */ __exportAll({
 	BrowserRenderingOperationError: () => BrowserRenderingOperationError,
-	Tag: () => Tag$10,
+	Tag: () => Tag$11,
 	isBrowserRenderingBinding: () => isBrowserRenderingBinding,
 	layer: () => layer$14,
 	make: () => make$11,
@@ -581,8 +581,8 @@ const makeClient$10 = (definition) => (binding) => ({
 	rawUnsafe: Effect.succeed(binding)
 });
 const layer$14 = (tag, definition) => layer$18(tag, definition.binding, isBrowserRenderingBinding, makeClient$10(definition), { expected: expectedBrowserRenderingBinding });
-const make$11 = (id) => Tag$10()(id);
-const Tag$10 = () => (id) => {
+const make$11 = (id) => Tag$11()(id);
+const Tag$11 = () => (id) => {
 	const tag = Context.Service()(id);
 	const makeLayer = (definition) => layer$14(tag, definition);
 	return Object.assign(tag, {
@@ -807,7 +807,7 @@ var ContainerNamespace_exports = /* @__PURE__ */ __exportAll({
 	ContainerNamespace: () => ContainerNamespace,
 	ContainerOperationError: () => ContainerOperationError,
 	ContainerState: () => ContainerState,
-	Tag: () => Tag$9,
+	Tag: () => Tag$10,
 	isContainerNamespaceResource: () => isContainerNamespaceResource,
 	layer: () => layer$10,
 	make: () => make$10,
@@ -924,8 +924,8 @@ const makeClient$8 = (definition) => (namespace) => {
 	};
 };
 const layer$10 = (tag, definition) => layer$18(tag, definition.binding, (value) => isContainerNamespaceResource(value), makeClient$8(definition), { expected: expectedContainerNamespace });
-const make$10 = (id) => Tag$9()(id);
-const Tag$9 = () => (id) => {
+const make$10 = (id) => Tag$10()(id);
+const Tag$10 = () => (id) => {
 	const tag = Context.Service()(`effect-cf/Container/${id}`);
 	const makeLayer = (definition) => layer$10(tag, definition);
 	const getByName = Effect.fnUntraced(function* (name, options) {
@@ -956,7 +956,7 @@ const Tag$9 = () => (id) => {
 		rawUnsafe
 	});
 };
-const ContainerNamespace = Tag$9;
+const ContainerNamespace = Tag$10;
 //#endregion
 //#region src/D1.ts
 var D1_exports = /* @__PURE__ */ __exportAll({
@@ -983,412 +983,100 @@ const Service = () => (id, definition) => {
 	});
 };
 //#endregion
-//#region src/DurableObjectNamespace.ts
-var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
-	DurableObjectFetchError: () => DurableObjectFetchError,
-	DurableObjectRpcError: () => DurableObjectRpcError,
-	isDurableObjectNamespaceClient: () => isDurableObjectNamespaceClient,
-	layer: () => layer$9,
-	makeClient: () => makeClient$7,
-	makeDirectMethods: () => makeDirectMethods
+//#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$9,
+	define: () => define,
+	processDue: () => processDue
 });
-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") {
+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 `Durable Object RPC method "${this.method}" failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+		return `Invalid Durable Object alarm ref: ${causeMessage(this.cause)}`;
 	}
 };
-/**
-* Failure raised when forwarding a request to a Durable Object stub.
-*/
-var DurableObjectFetchError = class extends Data.TaggedError("DurableObjectFetchError") {
+var InvalidAlarmPayloadError = class extends Data.TaggedError("InvalidAlarmPayloadError") {
 	get message() {
-		return `Durable Object fetch failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+		return `Invalid Durable Object alarm payload: ${causeMessage(this.cause)}`;
 	}
 };
-const hasFunction$1 = (value, key) => Predicate.hasProperty(value, key) && Predicate.isFunction(value[key]);
-const isDurableObjectNamespaceClient = (value) => hasFunction$1(value, "getByName") && hasFunction$1(value, "get") && hasFunction$1(value, "idFromName") && hasFunction$1(value, "idFromString") && hasFunction$1(value, "newUniqueId") && hasFunction$1(value, "jurisdiction");
-const makeClient$7 = (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
-			})));
-			return yield* invokeRpcMethod(stub, method, definition.rpcTracing ? yield* withRpcTraceContext(encodedArgs) : encodedArgs, (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 value = yield* scoped(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 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)
-		});
-	};
+var InvalidRepeatEveryError = class extends Data.TaggedError("InvalidRepeatEveryError") {
+	get message() {
+		return `Invalid Durable Object alarm repeatEvery: ${causeMessage(this.cause)}`;
+	}
 };
-const layer$9 = (tag, definition) => layer$18(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$7(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));
+var InvalidProcessDueAlarmsOptionsError = class extends Data.TaggedError("InvalidProcessDueAlarmsOptionsError") {
+	get message() {
+		return `Invalid processDueAlarms options: ${causeMessage(this.cause)}`;
 	}
-	return methods;
 };
-//#endregion
-//#region src/DurableObjectDefinition.ts
-var DurableObjectDefinition_exports = /* @__PURE__ */ __exportAll({
-	DurableObject: () => DurableObject$1,
-	Tag: () => Tag$8,
-	implement: () => implement$2,
-	make: () => make$8,
-	method: () => method
-});
-const reservedMethodNames$1 = /* @__PURE__ */ new Set([
-	"constructor",
-	"dup",
-	"fetch",
-	"alarm",
-	"webSocketMessage",
-	"webSocketClose",
-	"webSocketError"
-]);
-function method(definition) {
-	return method$1(definition);
-}
-const makeDefinition$2 = (id, methods) => {
-	assertNoReservedMethods("Durable Object", methods, reservedMethodNames$1);
-	const definition = make$15(id, methods);
-	return Object.assign(definition, { make: (layer, options) => make$7(layer, {
-		...options,
-		rpc: wrapHandlers(definition, options.rpc)
-	}) });
+var StoredAlarmDecodeError = class extends Data.TaggedError("StoredAlarmDecodeError") {
+	get message() {
+		return `Failed to decode stored alarm "${this.storageId}": ${causeMessage(this.cause)}`;
+	}
 };
-const make$8 = (id, methods) => Tag$8()(id, methods);
-const Tag$8 = () => (id, methods) => {
-	const definition = makeDefinition$2(id, methods);
-	const serviceKey = `effect-cf/DurableObject/${id}`;
-	const tag = Context.Service()(serviceKey);
-	const bindingDefinition = (binding) => ({
-		...binding,
-		definition
+const DurableObjectAlarmEvent = Schema.TaggedUnion({ AlarmDue: {
+	id: Schema.NonEmptyString,
+	payload: Schema.Json,
+	/** Persisted due time, which can differ from the invocation time during retries. */
+	scheduledAt: Schema.DateTimeUtc,
+	tag: Schema.NonEmptyString
+} });
+const AlarmRefSchema = Schema.Struct({
+	id: Schema.NonEmptyString,
+	tag: Schema.NonEmptyString
+});
+const decodeAlarmRef = (input) => Schema.decodeUnknownEffect(AlarmRefSchema)(input).pipe(Effect.mapError((cause) => new InvalidAlarmRefError({ cause })));
+const StoredPayloadString = Schema.fromJsonString(Schema.Json);
+const decodeStoredPayload = (row) => Schema.decodeUnknownEffect(StoredPayloadString)(row.payload).pipe(Effect.mapError((cause) => new StoredAlarmDecodeError({
+	cause,
+	storageId: row.storage_id
+})));
+const encodeStoredPayload = (payload) => Schema.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 layer = (binding) => layer$9(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,
-		newUniqueId,
-		idFromName,
-		idFromString,
-		get,
-		getByName,
-		jurisdiction,
-		fetch,
-		rpc,
-		call,
-		scopedCall,
-		rawUnsafe
-	});
-};
-const DurableObject$1 = Tag$8;
-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$2 = (_definition, handlers) => handlers;
-//#endregion
-//#region src/DurableObject.ts
-var DurableObject_exports = /* @__PURE__ */ __exportAll({
-	RunSymbol: () => RunSymbol,
-	Tag: () => Tag$8,
-	implement: () => implement$2,
-	make: () => make$7,
-	method: () => method
-});
-const reservedMethodNames = reservedMethodNames$2;
-/** 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)));
-/**
-* 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.
-*/
-const make$7 = (layer, options = {}) => {
-	class EffectDurableObject extends DurableObject {
-		runtime;
-		constructor(state, env) {
-			super(state, env);
-			this.runtime = makeEntrypointRuntime(layer, env, Layer.succeed(DurableObjectState, fromDurableObjectState(state)));
-			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 logicalAlarms = options.alarms?.pipe(Effect.asVoid);
-			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
-//#region src/DurableObjectAlarm.ts
-var DurableObjectAlarm_exports = /* @__PURE__ */ __exportAll({
-	DurableObjectAlarm: () => DurableObjectAlarm,
-	DurableObjectAlarmEvent: () => DurableObjectAlarmEvent,
-	InvalidAlarmPayloadError: () => InvalidAlarmPayloadError,
-	InvalidAlarmRefError: () => InvalidAlarmRefError,
-	InvalidProcessDueAlarmsOptionsError: () => InvalidProcessDueAlarmsOptionsError,
-	InvalidRepeatEveryError: () => InvalidRepeatEveryError,
-	StoredAlarmDecodeError: () => StoredAlarmDecodeError,
-	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 = Schema.TaggedUnion({ AlarmDue: {
-	id: Schema.NonEmptyString,
-	payload: Schema.Json,
-	/** Persisted due time, which can differ from the invocation time during retries. */
-	scheduledAt: Schema.DateTimeUtc,
-	tag: Schema.NonEmptyString
-} });
-const AlarmRefSchema = Schema.Struct({
-	id: Schema.NonEmptyString,
-	tag: Schema.NonEmptyString
-});
-const decodeAlarmRef = (input) => Schema.decodeUnknownEffect(AlarmRefSchema)(input).pipe(Effect.mapError((cause) => new InvalidAlarmRefError({ cause })));
-const StoredPayloadString = Schema.fromJsonString(Schema.Json);
-const decodeStoredPayload = (row) => Schema.decodeUnknownEffect(StoredPayloadString)(row.payload).pipe(Effect.mapError((cause) => new StoredAlarmDecodeError({
-	cause,
-	storageId: row.storage_id
-})));
-const encodeStoredPayload = (payload) => Schema.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 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) => {
@@ -1410,6 +1098,7 @@ const getFailureActionRetryDelay = (action) => Predicate.isString(action) || act
 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) => {
@@ -1420,27 +1109,66 @@ const getAlarmDefinitionFailureAction = (definition) => {
 		retryFailedAfter: definition.retry?.initialDelay
 	} : { mode: definition.failure };
 };
-const define = (definitions) => ({ handlers: (handlers, options) => processDue((event) => Effect.gen(function* () {
-	const definition = definitions[event.tag];
-	if (definition === void 0) return;
-	const schema = getAlarmDefinitionSchema(definition);
-	const payload = yield* Schema.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(definitions[failure.tag]);
-		const optionAction = options?.onFailure === void 0 ? void 0 : yield* options.onFailure(failure);
-		return action ?? optionAction;
-	})
-}) });
+const makeDefinition$3 = (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* Schema.encodeEffect(getAlarmDefinitionSchema(definition))(input.payload).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.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* Schema.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$3(definitions).handlers });
+/** The typed scheduler becomes available when its handlers are registered on a Durable Object. */
+const Tag$9 = () => (id, definitions) => {
+	const tag = Context.Service()(id);
+	const definition = makeDefinition$3(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;
@@ -1581,9 +1309,321 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 			scheduleAlarm: (input) => transaction((alarms) => alarms.scheduleAlarm(input)),
 			transaction
 		});
-	}).pipe(Effect.withSpan("DurableObjectAlarm.layer")));
+	}));
 };
 //#endregion
+//#region src/DurableObjectNamespace.ts
+var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
+	DurableObjectFetchError: () => DurableObjectFetchError,
+	DurableObjectRpcError: () => DurableObjectRpcError,
+	isDurableObjectNamespaceClient: () => isDurableObjectNamespaceClient,
+	layer: () => layer$9,
+	makeClient: () => makeClient$7,
+	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$1 = (value, key) => Predicate.hasProperty(value, key) && Predicate.isFunction(value[key]);
+const isDurableObjectNamespaceClient = (value) => hasFunction$1(value, "getByName") && hasFunction$1(value, "get") && hasFunction$1(value, "idFromName") && hasFunction$1(value, "idFromString") && hasFunction$1(value, "newUniqueId") && hasFunction$1(value, "jurisdiction");
+const makeClient$7 = (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$9 = (tag, definition) => layer$18(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$7(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
+//#region src/DurableObjectDefinition.ts
+var DurableObjectDefinition_exports = /* @__PURE__ */ __exportAll({
+	DurableObject: () => DurableObject$1,
+	Tag: () => Tag$8,
+	implement: () => implement$2,
+	make: () => make$8,
+	method: () => method
+});
+const reservedMethodNames$1 = /* @__PURE__ */ new Set([
+	"constructor",
+	"dup",
+	"fetch",
+	"alarm",
+	"webSocketMessage",
+	"webSocketClose",
+	"webSocketError"
+]);
+function method(definition) {
+	return method$1(definition);
+}
+const makeDefinition$2 = (id, methods) => {
+	assertNoReservedMethods("Durable Object", methods, reservedMethodNames$1);
+	const definition = make$15(id, methods);
+	return Object.assign(definition, { make: (layer, options) => make$7(layer, {
+		...options,
+		rpc: wrapHandlers(definition, options.rpc)
+	}) });
+};
+const make$8 = (id, methods) => Tag$8()(id, methods);
+const Tag$8 = () => (id, methods) => {
+	const definition = makeDefinition$2(id, methods);
+	const serviceKey = `effect-cf/DurableObject/${id}`;
+	const tag = Context.Service()(serviceKey);
+	const bindingDefinition = (binding) => ({
+		...binding,
+		definition
+	});
+	const layer = (binding) => layer$9(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,
+		newUniqueId,
+		idFromName,
+		idFromString,
+		get,
+		getByName,
+		jurisdiction,
+		fetch,
+		rpc,
+		call,
+		scopedCall,
+		rawUnsafe
+	});
+};
+const DurableObject$1 = Tag$8;
+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$2 = (_definition, handlers) => handlers;
+//#endregion
+//#region src/DurableObject.ts
+var DurableObject_exports = /* @__PURE__ */ __exportAll({
+	RunSymbol: () => RunSymbol,
+	Tag: () => Tag$8,
+	implement: () => implement$2,
+	make: () => make$7,
+	method: () => method
+});
+const reservedMethodNames = reservedMethodNames$2;
+/** 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$7(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
 //#region src/DurableObjectRpcWebSocket.ts
 var DurableObjectRpcWebSocket_exports = /* @__PURE__ */ __exportAll({
 	DurableObjectRpcWebSocket: () => DurableObjectRpcWebSocket,
@@ -2145,10 +2185,10 @@ const textEncoder = new TextEncoder();
 const sendLimits = {
 	maxRecipients: 50,
 	maxAttachments: 32,
-	maxMessageBytes: 5 * 1024 * 1024,
+	maxMessageBytes: 5242880,
 	maxHeaderNameBytes: 100,
 	maxHeaderValueBytes: 2048,
-	maxHeadersBytes: 16 * 1024,
+	maxHeadersBytes: 16384,
 	maxAllowlistHeaders: 20
 };
 /**