@effect-agent/platform-cloudflare 0.1.0-beta.6 → 0.1.0-beta.60

package/dist/CloudflareMemory.mjs

@@ -0,0 +1,168 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Principal } from "@effect-agent/thread/SubmissionLedger";
+import { Clock, Context, Effect, Layer, Schema } from "effect";
+import * as Memory from "@effect-agent/core/Memory";
+import * as MemoryNamespace from "@effect-agent/core/MemoryNamespace";
+import { MemoryNamespaceAddress } from "@effect-agent/core/MemoryNamespace";
+import { MemoryRecallLimits } from "@effect-agent/core/MemoryReference";
+import { MemoryAccess } from "@effect-agent/core/MemoryRevalidation";
+import { MemoryDocument, MemoryMutationFailpoint, MemoryStorageError, MemoryWriter } from "@effect-agent/core/MemoryStore";
+import "@effect-agent/core/SemanticMemoryIndex";
+import "@effect-agent/core/SemanticMemoryRevalidation";
+import { defaultDoMemoryStorageLimits, doMemoryStoreLayerWithFailpoints } from "@effect-agent/storage-cloudflare/DoMemoryStore";
+import { MemoryOwnerIdentity, MemoryOwnerRequest, MemoryOwnerResponse, MemoryRpcError, MemoryRpcLimits, decodeMemoryWire, defaultMemoryRpcLimits, encodeMemoryWire, handleMemoryOwnerRequest } from "@effect-agent/storage-cloudflare/MemoryProtocol";
+import { DurableObject, DurableObjectState } from "effect-cf";
+//#region src/CloudflareMemory.ts
+var CloudflareMemory_exports = /* @__PURE__ */ __exportAll({
+	CloudflareMemoryClient: () => CloudflareMemoryClient,
+	MemoryObject: () => MemoryObject,
+	MemoryObjectNamespace: () => MemoryObjectNamespace,
+	cloudflareMemoryWriterLayer: () => cloudflareMemoryWriterLayer,
+	memoryObjectName: () => memoryObjectName
+});
+var MemoryObjectNamespace = class extends Context.Service()("@effect-agent/platform-cloudflare/MemoryObjectNamespace") {};
+/** Namespace version and identity are already canonicalized by MemoryNamespace. */
+const memoryObjectName = (namespace) => namespace.address;
+/**
+* Effect-native, host-bound memory client. Recall revalidates the entire admitted lookup
+* in one RPC and renders it locally. No retries or per-source splitting occur here.
+* Interrupted callers stop waiting; the owner has its own deadline. A timed-out write
+* may have committed: reconcile by sending the identical operation ID and command.
+*/
+const makeMemoryClient = Effect.fn("CloudflareMemoryClient.make")(function* (access, principal, rpcLimits = defaultMemoryRpcLimits) {
+	const validated = yield* Schema.decodeUnknownEffect(MemoryRpcLimits)(rpcLimits).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
+	const bound = yield* Schema.decodeUnknownEffect(MemoryAccess.Wire)(access).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
+	principal = yield* Schema.decodeUnknownEffect(Principal)(principal).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
+	const { namespace } = yield* MemoryObjectNamespace;
+	const call = Effect.fn("CloudflareMemoryClient.call")(function* (request) {
+		const decoded = yield* Schema.decodeUnknownEffect(MemoryOwnerRequest)(request).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
+		const encoded = yield* encodeMemoryWire(MemoryOwnerRequest, decoded, validated.maxRequestBytes);
+		const raw = yield* Effect.tryPromise({
+			try: () => namespace.get(namespace.idFromName(memoryObjectName(bound.namespace))).memory(encoded),
+			catch: () => MemoryRpcError.make({ reason: "unavailable" })
+		});
+		const response = yield* decodeMemoryWire(MemoryOwnerResponse, raw, validated.maxResponseBytes);
+		if (response._tag === "Failed") return yield* response.failure;
+		if (!MemoryNamespace.equals(response.access.namespace, bound.namespace) || response.access.scope !== bound.scope) return yield* MemoryRpcError.make({ reason: "protocol" });
+		return response;
+	});
+	const withinDeadline = (effect, timeoutMillis) => effect.pipe(Effect.timeoutOrElse({
+		duration: timeoutMillis,
+		orElse: () => Effect.fail(MemoryRpcError.make({ reason: "timeout" }))
+	}));
+	const revalidate = Effect.fn("CloudflareMemoryClient.revalidate")(function* (lookup, limits) {
+		limits = yield* Schema.decodeUnknownEffect(MemoryRecallLimits)(limits).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
+		const timeoutMillis = Math.min(validated.timeoutMillis, limits.timeoutMillis);
+		return yield* Effect.gen(function* () {
+			const response = yield* call({
+				_tag: "Revalidate",
+				version: 1,
+				access: bound,
+				principal,
+				lookup,
+				limits,
+				deadlineMillis: (yield* Clock.currentTimeMillis) + timeoutMillis
+			});
+			if (response._tag !== "Lookup") return yield* MemoryRpcError.make({ reason: "protocol" });
+			return response.lookup;
+		}).pipe((effect) => withinDeadline(effect, timeoutMillis));
+	});
+	const change = Effect.fn("CloudflareMemoryClient.change")(function* (write) {
+		if (!MemoryNamespace.equals(write.key.namespace, bound.namespace)) return yield* MemoryRpcError.make({ reason: "denied" });
+		return yield* Effect.gen(function* () {
+			const response = yield* call({
+				_tag: "Change",
+				version: 1,
+				access: bound,
+				principal,
+				write,
+				deadlineMillis: (yield* Clock.currentTimeMillis) + validated.timeoutMillis
+			});
+			if (response._tag !== "Changed" || response.document.key.id !== write.key.id) return yield* MemoryRpcError.make({ reason: "protocol" });
+			return yield* MemoryDocument.restore(access.namespace, response.document);
+		}).pipe((effect) => withinDeadline(effect, validated.timeoutMillis));
+	});
+	const revalidateSemantic = Effect.fn("CloudflareMemoryClient.revalidateSemantic")(function* (found, profile, limits) {
+		return yield* Effect.gen(function* () {
+			const response = yield* call({
+				_tag: "RevalidateSemantic",
+				version: 1,
+				access: bound,
+				principal,
+				found,
+				profile,
+				limits,
+				deadlineMillis: (yield* Clock.currentTimeMillis) + validated.timeoutMillis
+			});
+			if (response._tag !== "Semantic") return yield* MemoryRpcError.make({ reason: "protocol" });
+			return response.result;
+		}).pipe((effect) => withinDeadline(effect, validated.timeoutMillis));
+	});
+	return {
+		recall: Effect.fn("CloudflareMemoryClient.recall")(function* (lookup, limits, estimateTokens) {
+			return yield* Memory.recall([{
+				id: "memory",
+				essential: true,
+				read: revalidate(lookup, limits)
+			}], limits, estimateTokens);
+		}),
+		revalidate,
+		revalidateSemantic,
+		change
+	};
+});
+const CloudflareMemoryClient = {
+	/** Bind access and principal using the MemoryObjectNamespace supplied by the application. */
+	make: makeMemoryClient,
+	/** Use a resolved Worker or Durable Object binding without manual service provisioning. */
+	fromBinding: Effect.fn("CloudflareMemoryClient.fromBinding")(function* (binding, options) {
+		return yield* makeMemoryClient(options.access, options.principal, options.rpcLimits).pipe(Effect.provideService(MemoryObjectNamespace, { namespace: binding }));
+	})
+};
+/**
+* Optional activity-processor destination. Keeps domain write errors intact; transport,
+* authorization and deadline failures become the existing MemoryStorageError contract.
+* Receipts remain authoritative, including after caller interruption or lost replies.
+*/
+const cloudflareMemoryWriterLayer = (access, principal, limits = defaultMemoryRpcLimits) => Layer.effect(MemoryWriter, Effect.gen(function* () {
+	const client = yield* CloudflareMemoryClient.make(access, principal, limits);
+	return MemoryWriter.fromAdapter({ change: (write) => client.change(write).pipe(Effect.catchTag("MemoryRpcError", (error) => Effect.fail(MemoryStorageError.make({
+		operation: `memory RPC ${error.reason}`,
+		reason: error.reason === "unavailable" || error.reason === "timeout" ? "unavailable" : "invalid-input"
+	}))), Effect.catchTag([
+		"MemoryRecallError",
+		"MemoryIndexError",
+		"SemanticMemoryError"
+	], () => Effect.fail(MemoryStorageError.make({
+		operation: "memory RPC response",
+		reason: "corrupt"
+	})))) });
+}));
+/**
+* Dedicated SQLite owner, independent of Thread lifetimes. The host binds authorization
+* after restoring its namespace definition from MemoryOwnerIdentity. Do not retain
+* cleanup-scoped resources in the host Layer; it lives for the DO incarnation.
+*/
+const makeMemoryObject = (host, options = {}) => {
+	const identity = Layer.effect(MemoryOwnerIdentity, Effect.gen(function* () {
+		const state = yield* DurableObjectState.DurableObjectState;
+		const address = yield* Schema.decodeUnknownEffect(MemoryNamespaceAddress)(state.raw.id.name).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "denied" })));
+		return { namespace: MemoryNamespace.Any.make({ address }) };
+	}));
+	const store = Layer.unwrap(Effect.map(DurableObjectState.DurableObjectState, (state) => doMemoryStoreLayerWithFailpoints(state.raw.storage, options.storageLimits ?? defaultDoMemoryStorageLimits))).pipe(Layer.provide(options.failpoints ?? MemoryMutationFailpoint.layer));
+	const application = Layer.merge(store, host).pipe(Layer.provideMerge(identity));
+	const runtime = Layer.effectContext(Effect.gen(function* () {
+		const state = yield* DurableObjectState.DurableObjectState;
+		const scope = yield* Effect.scope;
+		yield* Schema.decodeUnknownEffect(MemoryRpcLimits)(options.rpcLimits ?? defaultMemoryRpcLimits).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
+		return yield* state.blockConcurrencyWhile(Layer.buildWithScope(application, scope));
+	}));
+	return DurableObject.make(runtime, { rpc: { memory: (encoded) => handleMemoryOwnerRequest(encoded, options.rpcLimits) } });
+};
+const MemoryObject = { 
+/** Build the SQLite Durable Object class with the application's owner authorization Layer. */
+make: makeMemoryObject };
+//#endregion
+export { CloudflareMemoryClient, MemoryObject, MemoryObjectNamespace, cloudflareMemoryWriterLayer, memoryObjectName, CloudflareMemory_exports as t };
+
+//# sourceMappingURL=CloudflareMemory.mjs.map

package/dist/CloudflareMemory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudflareMemory.mjs","names":["EffectCfDurableObject"],"sources":["../src/CloudflareMemory.ts"],"sourcesContent":["import * as Memory from \"@effect-agent/core/Memory\";\nimport * as MemoryNamespace from \"@effect-agent/core/MemoryNamespace\";\nimport { MemoryNamespaceAddress } from \"@effect-agent/core/MemoryNamespace\";\nimport { type MemoryLookup, MemoryRecallLimits } from \"@effect-agent/core/MemoryReference\";\nimport { MemoryAccess } from \"@effect-agent/core/MemoryRevalidation\";\nimport {\n  type MemoryReader,\n  type MemoryWrite,\n  MemoryDocument,\n  MemoryMutationFailpoint,\n  MemoryStorageError,\n  MemoryWriter,\n} from \"@effect-agent/core/MemoryStore\";\nimport {\n  type MemoryIndexSearch,\n  type SemanticMemoryProfile,\n} from \"@effect-agent/core/SemanticMemoryIndex\";\nimport { type SemanticCandidateLimits } from \"@effect-agent/core/SemanticMemoryRevalidation\";\nimport {\n  type DoMemoryStorageLimits,\n  defaultDoMemoryStorageLimits,\n  doMemoryStoreLayerWithFailpoints,\n} from \"@effect-agent/storage-cloudflare/DoMemoryStore\";\nimport {\n  type MemoryOwnerAuthorizer,\n  decodeMemoryWire,\n  defaultMemoryRpcLimits,\n  encodeMemoryWire,\n  handleMemoryOwnerRequest,\n  MemoryOwnerIdentity,\n  MemoryOwnerRequest,\n  MemoryOwnerResponse,\n  MemoryRpcError,\n  MemoryRpcLimits,\n  type MemoryOwnerFailure,\n} from \"@effect-agent/storage-cloudflare/MemoryProtocol\";\nimport { Principal } from \"@effect-agent/thread/SubmissionLedger\";\nimport { Clock, Context, Effect, Layer, Schema } from \"effect\";\nimport {\n  DurableObject as EffectCfDurableObject,\n  DurableObjectState,\n  type WorkerEnvironment,\n} from \"effect-cf\";\n\nexport interface MemoryObjectRpc extends Rpc.DurableObjectBranded {\n  memory(encoded: string): Promise<string>;\n}\n\nexport class MemoryObjectNamespace extends Context.Service<\n  MemoryObjectNamespace,\n  {\n    readonly namespace: DurableObjectNamespace<MemoryObjectRpc>;\n  }\n>()(\"@effect-agent/platform-cloudflare/MemoryObjectNamespace\") {}\n\n/** Namespace version and identity are already canonicalized by MemoryNamespace. */\nexport const memoryObjectName = (namespace: MemoryNamespace.Any): string => namespace.address;\n\n/**\n * Effect-native, host-bound memory client. Recall revalidates the entire admitted lookup\n * in one RPC and renders it locally. No retries or per-source splitting occur here.\n * Interrupted callers stop waiting; the owner has its own deadline. A timed-out write\n * may have committed: reconcile by sending the identical operation ID and command.\n */\nconst makeMemoryClient = Effect.fn(\"CloudflareMemoryClient.make\")(function* <\n  Namespace extends MemoryNamespace.Any,\n>(\n  access: MemoryAccess<Namespace>,\n  principal: Principal,\n  rpcLimits: MemoryRpcLimits = defaultMemoryRpcLimits,\n) {\n  const validated = yield* Schema.decodeUnknownEffect(MemoryRpcLimits)(rpcLimits).pipe(\n    Effect.mapError(() => MemoryRpcError.make({ reason: \"protocol\" })),\n  );\n\n  const bound = yield* Schema.decodeUnknownEffect(MemoryAccess.Wire)(access).pipe(\n    Effect.mapError(() => MemoryRpcError.make({ reason: \"protocol\" })),\n  );\n\n  principal = yield* Schema.decodeUnknownEffect(Principal)(principal).pipe(\n    Effect.mapError(() => MemoryRpcError.make({ reason: \"protocol\" })),\n  );\n  const { namespace } = yield* MemoryObjectNamespace;\n\n  const call = Effect.fn(\"CloudflareMemoryClient.call\")(function* (request: MemoryOwnerRequest) {\n    const decoded = yield* Schema.decodeUnknownEffect(MemoryOwnerRequest)(request).pipe(\n      Effect.mapError(() => MemoryRpcError.make({ reason: \"protocol\" })),\n    );\n\n    const encoded = yield* encodeMemoryWire(MemoryOwnerRequest, decoded, validated.maxRequestBytes);\n\n    const raw = yield* Effect.tryPromise({\n      try: () =>\n        namespace.get(namespace.idFromName(memoryObjectName(bound.namespace))).memory(encoded),\n      catch: () => MemoryRpcError.make({ reason: \"unavailable\" }),\n    });\n\n    const response = yield* decodeMemoryWire(MemoryOwnerResponse, raw, validated.maxResponseBytes);\n\n    if (response._tag === \"Failed\") return yield* response.failure;\n    if (\n      !MemoryNamespace.equals(response.access.namespace, bound.namespace) ||\n      response.access.scope !== bound.scope\n    )\n      return yield* MemoryRpcError.make({ reason: \"protocol\" });\n\n    return response;\n  });\n\n  const withinDeadline = <A, E, R>(effect: Effect.Effect<A, E, R>, timeoutMillis: number) =>\n    effect.pipe(\n      Effect.timeoutOrElse({\n        duration: timeoutMillis,\n        orElse: () => Effect.fail(MemoryRpcError.make({ reason: \"timeout\" })),\n      }),\n    );\n\n  const revalidate = Effect.fn(\"CloudflareMemoryClient.revalidate\")(function* (\n    lookup: MemoryLookup,\n    limits: MemoryRecallLimits,\n  ) {\n    limits = yield* Schema.decodeUnknownEffect(MemoryRecallLimits)(limits).pipe(\n      Effect.mapError(() => MemoryRpcError.make({ reason: \"protocol\" })),\n    );\n    const timeoutMillis = Math.min(validated.timeoutMillis, limits.timeoutMillis);\n\n    return yield* Effect.gen(function* () {\n      const response = yield* call({\n        _tag: \"Revalidate\",\n        version: 1,\n        access: bound,\n        principal,\n        lookup,\n        limits,\n        deadlineMillis: (yield* Clock.currentTimeMillis) + timeoutMillis,\n      });\n\n      if (response._tag !== \"Lookup\") return yield* MemoryRpcError.make({ reason: \"protocol\" });\n\n      return response.lookup;\n    }).pipe((effect) => withinDeadline(effect, timeoutMillis));\n  });\n\n  const change = Effect.fn(\"CloudflareMemoryClient.change\")(function* (\n    write: MemoryWrite<Namespace>,\n  ) {\n    if (!MemoryNamespace.equals(write.key.namespace, bound.namespace))\n      return yield* MemoryRpcError.make({ reason: \"denied\" });\n\n    return yield* Effect.gen(function* () {\n      const response = yield* call({\n        _tag: \"Change\",\n        version: 1,\n        access: bound,\n        principal,\n        write,\n        deadlineMillis: (yield* Clock.currentTimeMillis) + validated.timeoutMillis,\n      });\n\n      if (response._tag !== \"Changed\" || response.document.key.id !== write.key.id)\n        return yield* MemoryRpcError.make({ reason: \"protocol\" });\n\n      return yield* MemoryDocument.restore(access.namespace, response.document);\n    }).pipe((effect) => withinDeadline(effect, validated.timeoutMillis));\n  });\n\n  const revalidateSemantic = Effect.fn(\"CloudflareMemoryClient.revalidateSemantic\")(function* (\n    found: MemoryIndexSearch<Namespace>,\n    profile: SemanticMemoryProfile,\n    limits: SemanticCandidateLimits,\n  ) {\n    return yield* Effect.gen(function* () {\n      const response = yield* call({\n        _tag: \"RevalidateSemantic\",\n        version: 1,\n        access: bound,\n        principal,\n        found,\n        profile,\n        limits,\n        deadlineMillis: (yield* Clock.currentTimeMillis) + validated.timeoutMillis,\n      });\n\n      if (response._tag !== \"Semantic\") return yield* MemoryRpcError.make({ reason: \"protocol\" });\n\n      return response.result;\n    }).pipe((effect) => withinDeadline(effect, validated.timeoutMillis));\n  });\n\n  /**\n   * Revalidate in one owner RPC, then render whole passages within the caller's budget.\n   * The bound source is essential: unavailable/stale results and matches that cannot fit\n   * fail instead of silently producing empty context. No-match remains successful.\n   * The single outcome has sourceId \"memory\". No embedding or candidate search is performed.\n   * Use revalidate with Memory.recall for multiple readers sharing one output budget.\n   */\n  const recall = Effect.fn(\"CloudflareMemoryClient.recall\")(function* (\n    lookup: MemoryLookup,\n    limits: MemoryRecallLimits,\n    estimateTokens?: (text: string) => number,\n  ) {\n    return yield* Memory.recall(\n      [{ id: \"memory\", essential: true, read: revalidate(lookup, limits) }],\n      limits,\n      estimateTokens,\n    );\n  });\n\n  return { recall, revalidate, revalidateSemantic, change };\n});\n\nexport const CloudflareMemoryClient = {\n  /** Bind access and principal using the MemoryObjectNamespace supplied by the application. */\n  make: makeMemoryClient,\n  /** Use a resolved Worker or Durable Object binding without manual service provisioning. */\n  fromBinding: Effect.fn(\"CloudflareMemoryClient.fromBinding\")(function* <\n    Namespace extends MemoryNamespace.Any,\n  >(\n    binding: DurableObjectNamespace<MemoryObjectRpc>,\n    options: {\n      readonly access: MemoryAccess<Namespace>;\n      readonly principal: Principal;\n      readonly rpcLimits?: MemoryRpcLimits;\n    },\n  ) {\n    return yield* makeMemoryClient(options.access, options.principal, options.rpcLimits).pipe(\n      Effect.provideService(MemoryObjectNamespace, { namespace: binding }),\n    );\n  }),\n};\n\n/**\n * Optional activity-processor destination. Keeps domain write errors intact; transport,\n * authorization and deadline failures become the existing MemoryStorageError contract.\n * Receipts remain authoritative, including after caller interruption or lost replies.\n */\nexport const cloudflareMemoryWriterLayer = (\n  access: MemoryAccess,\n  principal: Principal,\n  limits: MemoryRpcLimits = defaultMemoryRpcLimits,\n) =>\n  Layer.effect(\n    MemoryWriter,\n    Effect.gen(function* () {\n      const client = yield* CloudflareMemoryClient.make(access, principal, limits);\n\n      return MemoryWriter.fromAdapter({\n        change: (write) =>\n          client.change(write).pipe(\n            Effect.catchTag(\"MemoryRpcError\", (error) =>\n              Effect.fail(\n                MemoryStorageError.make({\n                  operation: `memory RPC ${error.reason}`,\n                  reason:\n                    error.reason === \"unavailable\" || error.reason === \"timeout\"\n                      ? \"unavailable\"\n                      : \"invalid-input\",\n                }),\n              ),\n            ),\n            Effect.catchTag([\"MemoryRecallError\", \"MemoryIndexError\", \"SemanticMemoryError\"], () =>\n              Effect.fail(\n                MemoryStorageError.make({ operation: \"memory RPC response\", reason: \"corrupt\" }),\n              ),\n            ),\n          ),\n      });\n    }),\n  );\n\ntype OwnerServices = MemoryReader | MemoryWriter | MemoryOwnerAuthorizer | MemoryOwnerIdentity;\n\nexport interface MemoryObjectInstance extends InstanceType<\n  EffectCfDurableObject.DurableObjectClass<Record<never, never>, OwnerServices>\n> {\n  memory(encoded: string): Promise<string>;\n}\n\nexport interface MemoryObjectClass {\n  new (ctx: globalThis.DurableObjectState, env: Cloudflare.Env): MemoryObjectInstance;\n}\n\n/**\n * Dedicated SQLite owner, independent of Thread lifetimes. The host binds authorization\n * after restoring its namespace definition from MemoryOwnerIdentity. Do not retain\n * cleanup-scoped resources in the host Layer; it lives for the DO incarnation.\n */\nconst makeMemoryObject = <E>(\n  host: Layer.Layer<\n    MemoryOwnerAuthorizer,\n    E,\n    MemoryOwnerIdentity | DurableObjectState.DurableObjectState | WorkerEnvironment\n  >,\n  options: {\n    readonly storageLimits?: DoMemoryStorageLimits;\n    readonly rpcLimits?: MemoryRpcLimits;\n    readonly failpoints?: Layer.Layer<\n      MemoryMutationFailpoint,\n      never,\n      DurableObjectState.DurableObjectState\n    >;\n  } = {},\n): MemoryObjectClass => {\n  const identity = Layer.effect(\n    MemoryOwnerIdentity,\n    Effect.gen(function* () {\n      const state = yield* DurableObjectState.DurableObjectState;\n\n      const address = yield* Schema.decodeUnknownEffect(MemoryNamespaceAddress)(\n        state.raw.id.name,\n      ).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: \"denied\" })));\n\n      return { namespace: MemoryNamespace.Any.make({ address }) };\n    }),\n  );\n\n  const store = Layer.unwrap(\n    Effect.map(DurableObjectState.DurableObjectState, (state) =>\n      doMemoryStoreLayerWithFailpoints(\n        state.raw.storage,\n        options.storageLimits ?? defaultDoMemoryStorageLimits,\n      ),\n    ),\n  ).pipe(Layer.provide(options.failpoints ?? MemoryMutationFailpoint.layer));\n\n  const application = Layer.merge(store, host).pipe(Layer.provideMerge(identity));\n\n  const runtime: Layer.Layer<\n    OwnerServices,\n    E | MemoryOwnerFailure,\n    DurableObjectState.DurableObjectState | WorkerEnvironment\n  > = Layer.effectContext(\n    Effect.gen(function* () {\n      const state = yield* DurableObjectState.DurableObjectState;\n      const scope = yield* Effect.scope;\n\n      yield* Schema.decodeUnknownEffect(MemoryRpcLimits)(\n        options.rpcLimits ?? defaultMemoryRpcLimits,\n      ).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: \"protocol\" })));\n\n      return yield* state.blockConcurrencyWhile(Layer.buildWithScope(application, scope));\n    }),\n  );\n\n  const rpc = { memory: (encoded: string) => handleMemoryOwnerRequest(encoded, options.rpcLimits) };\n\n  return EffectCfDurableObject.make<\n    OwnerServices,\n    E | MemoryOwnerFailure,\n    never,\n    never,\n    typeof rpc\n  >(runtime, { rpc });\n};\n\nexport const MemoryObject = {\n  /** Build the SQLite Durable Object class with the application's owner authorization Layer. */\n  make: makeMemoryObject,\n};\n"],"mappings":"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"}

package/dist/CloudflareScheduling.d.mts

@@ -0,0 +1,52 @@
+import { ThreadObjectNamespace } from "./CloudflareBindings.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+import { DurableObject, DurableObjectAlarm, DurableObjectState as DurableObjectState$1, WorkerEnvironment } from "effect-cf";
+import { DoScheduleAlarmControl } from "@effect-agent/storage-cloudflare/DoScheduleStore";
+import { ScheduleAuthorizer, ScheduleFailpointError, ScheduleOwner, ScheduleStorageError, SchedulingLimits } from "@effect-agent/thread/Schedule";
+import { ScheduleDriver, Scheduling } from "@effect-agent/thread/Scheduling";
+declare namespace CloudflareScheduling_d_exports {
+  export { CloudflareSchedulingClient, ScheduleAlarmProtocolError, ScheduleOwnerIdentity, ScheduleOwnerNamespace, ScheduleOwnerObjectClass, ScheduleOwnerObjectInstance, ScheduleOwnerObjectRpc, ScheduleOwnerProtocolError, makeScheduleOwnerObjectClass, scheduleAlarmHandler };
+}
+declare const ScheduleAlarmProtocolError_base: Schema.Class<ScheduleAlarmProtocolError, Schema.TaggedStruct<"ScheduleAlarmProtocolError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ScheduleAlarmProtocolError extends ScheduleAlarmProtocolError_base {}
+declare const ScheduleOwnerProtocolError_base: Schema.Class<ScheduleOwnerProtocolError, Schema.TaggedStruct<"ScheduleOwnerProtocolError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ScheduleOwnerProtocolError extends ScheduleOwnerProtocolError_base {}
+interface ScheduleOwnerObjectRpc extends Rpc.DurableObjectBranded {
+  schedule(encoded: unknown): Promise<unknown>;
+}
+declare const ScheduleOwnerNamespace_base: Context.ServiceClass<ScheduleOwnerNamespace, "@effect-agent/platform-cloudflare/ScheduleOwnerNamespace", {
+  readonly namespace: DurableObjectNamespace<ScheduleOwnerObjectRpc>;
+}>;
+declare class ScheduleOwnerNamespace extends ScheduleOwnerNamespace_base {}
+/** Provides the same authorized management service as NodeScheduling.layer. */
+declare class CloudflareSchedulingClient {
+  static readonly layer: Layer.Layer<Scheduling, never, ScheduleOwnerNamespace>;
+}
+declare const ScheduleOwnerIdentity_base: Context.ServiceClass<ScheduleOwnerIdentity, "@effect-agent/platform-cloudflare/ScheduleOwnerIdentity", {
+  readonly owner: ScheduleOwner;
+}>;
+declare class ScheduleOwnerIdentity extends ScheduleOwnerIdentity_base {}
+type ScheduleRuntimeServices = Scheduling | ScheduleDriver | DoScheduleAlarmControl | ScheduleOwnerIdentity | DurableObjectAlarm.DurableObjectAlarm;
+/** @internal The complete native alarm operation, including its event deadline. */
+declare const scheduleAlarmHandler: (limits: SchedulingLimits) => Effect.Effect<void, ScheduleAlarmProtocolError | ScheduleFailpointError | ScheduleStorageError | import("effect/Cause").TimeoutError | DurableObjectAlarm.DurableObjectAlarmError, DoScheduleAlarmControl | DurableObjectAlarm.DurableObjectAlarm | ScheduleDriver | ScheduleOwnerIdentity>;
+interface ScheduleOwnerObjectInstance extends InstanceType<DurableObject.DurableObjectClass<Record<never, never>, ScheduleRuntimeServices>> {
+  schedule(encoded: unknown): Promise<unknown>;
+  alarm(alarmInfo?: AlarmInvocationInfo): Promise<void> | void;
+}
+interface ScheduleOwnerObjectClass {
+  new (ctx: DurableObjectState, env: Cloudflare.Env): ScheduleOwnerObjectInstance;
+}
+/**
+ * The host Layer supplies authorization and routing and is cached for the object incarnation.
+ * Cloudflare eviction does not guarantee its finalizers run. Do not acquire resources requiring
+ * cleanup in this Layer; acquire them inside scoped `manage` / `prepare` operations instead.
+ * Native services belong to effect-cf; the database and alarm runtime remain instance-owned.
+ */
+declare const makeScheduleOwnerObjectClass: <E>(host: Layer.Layer<ScheduleAuthorizer | ThreadObjectNamespace, E, DurableObjectState$1.DurableObjectState | WorkerEnvironment | ScheduleOwnerIdentity>, limits?: SchedulingLimits) => ScheduleOwnerObjectClass;
+//#endregion
+export { CloudflareSchedulingClient, ScheduleAlarmProtocolError, ScheduleOwnerIdentity, ScheduleOwnerNamespace, ScheduleOwnerObjectClass, ScheduleOwnerObjectInstance, ScheduleOwnerObjectRpc, ScheduleOwnerProtocolError, makeScheduleOwnerObjectClass, scheduleAlarmHandler, CloudflareScheduling_d_exports as t };
+//# sourceMappingURL=CloudflareScheduling.d.mts.map

package/dist/CloudflareScheduling.mjs

@@ -0,0 +1,389 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { CloudflareThreadClient } from "./CloudflareThreadClient.mjs";
+import { n as cloudflareScheduledInputAdmissionLayer, t as cloudflarePreparedInputAdmissionLayer } from "./prepared-admission-G7N4DDqS.mjs";
+import "@effect-agent/thread/DurableAgentRuntime";
+import { AdmissionFence } from "@effect-agent/thread/SubmissionLedger";
+import { Clock, Context, DateTime, Effect, Layer, Schema } from "effect";
+import { AgentId } from "@effect-agent/core/Identifiers";
+import { DefinitionDigests, PersistedJson } from "@effect-agent/thread/Records";
+import { DurableObject, DurableObjectAlarm, DurableObjectState } from "effect-cf";
+import { DoScheduleAlarmControl, DoScheduleTransaction, scheduleStoreLayer } from "@effect-agent/storage-cloudflare/DoScheduleStore";
+import { ScheduleAuthorizationError, ScheduleCapacityError, ScheduleConflict, ScheduleDestination, ScheduleFailpointError, ScheduleId, ScheduleNotFound, ScheduleOwner, ScheduleScope, ScheduleSnapshot, ScheduleSnapshotPage, ScheduleStorageError, ScheduleTimingRequest, ScheduleValidationError, defaultSchedulingLimits } from "@effect-agent/thread/Schedule";
+import { scheduleOwnerKey } from "@effect-agent/thread/ScheduleTransition";
+import { ScheduleDriver, ScheduleWakeNoop, Scheduling } from "@effect-agent/thread/Scheduling";
+import { BrowserCrypto } from "@effect/platform-browser";
+import { SqliteClient } from "@effect/sql-sqlite-do";
+//#region src/CloudflareScheduling.ts
+var CloudflareScheduling_exports = /* @__PURE__ */ __exportAll({
+	CloudflareSchedulingClient: () => CloudflareSchedulingClient,
+	ScheduleAlarmProtocolError: () => ScheduleAlarmProtocolError,
+	ScheduleOwnerIdentity: () => ScheduleOwnerIdentity,
+	ScheduleOwnerNamespace: () => ScheduleOwnerNamespace,
+	ScheduleOwnerProtocolError: () => ScheduleOwnerProtocolError,
+	makeScheduleOwnerObjectClass: () => makeScheduleOwnerObjectClass,
+	scheduleAlarmHandler: () => scheduleAlarmHandler
+});
+const SCHEDULE_ALARM_TAG = "effect-agent/ScheduleOwnerWake";
+const SCHEDULE_ALARM_ID = "driver";
+const ScheduleAlarmPayload = Schema.Struct({
+	schemaVersion: Schema.Literal(1),
+	generation: Schema.Int.check(Schema.isGreaterThan(0))
+});
+var ScheduleAlarmProtocolError = class extends Schema.TaggedError()("ScheduleAlarmProtocolError", { message: Schema.String }) {};
+const boundedProtocolMessage = (message) => message.length <= 4096 ? message : `${message.slice(0, 4093)}...`;
+var ScheduleOwnerProtocolError = class extends Schema.TaggedError()("ScheduleOwnerProtocolError", { message: Schema.String.check(Schema.isMaxLength(4096)) }) {};
+const ScheduleMutationRequestFields = {
+	schemaVersion: Schema.Literal(1),
+	agentId: AgentId,
+	input: PersistedJson,
+	scope: ScheduleScope,
+	scheduleId: ScheduleId,
+	timing: ScheduleTimingRequest,
+	destination: ScheduleDestination,
+	deliveryPrincipal: ScheduleScope.fields.principal,
+	definitions: DefinitionDigests,
+	admissionGroup: Schema.optionalKey(Schema.NonEmptyString.check(Schema.isMaxLength(256))),
+	admissionFence: Schema.optionalKey(AdmissionFence)
+};
+const ScheduleCreateRequest = Schema.TaggedStruct("Create", ScheduleMutationRequestFields);
+const ScheduleUpdateRequest = Schema.TaggedStruct("Update", {
+	...ScheduleMutationRequestFields,
+	expectedRevision: Schema.Int.check(Schema.isGreaterThan(0))
+});
+const ScheduleGetRequest = Schema.TaggedStruct("Get", {
+	schemaVersion: Schema.Literal(1),
+	scope: ScheduleScope,
+	scheduleId: ScheduleId
+});
+const ScheduleListRequest = Schema.TaggedStruct("List", {
+	schemaVersion: Schema.Literal(1),
+	scope: ScheduleScope,
+	after: Schema.optionalKey(ScheduleId),
+	limit: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(100)))
+});
+const ScheduleControlRequest = Schema.TaggedStruct("Control", {
+	schemaVersion: Schema.Literal(1),
+	operation: Schema.Literals([
+		"pause",
+		"resume",
+		"cancel"
+	]),
+	scope: ScheduleScope,
+	scheduleId: ScheduleId,
+	expectedRevision: Schema.Int.check(Schema.isGreaterThan(0))
+});
+const ScheduleRecoverRequest = Schema.TaggedStruct("Recover", {
+	schemaVersion: Schema.Literal(1),
+	scope: ScheduleScope,
+	scheduleId: ScheduleId,
+	expectedRevision: Schema.Int.check(Schema.isGreaterThan(0)),
+	expectedGeneration: Schema.Natural
+});
+const ScheduleOwnerRequest = Schema.Union([
+	ScheduleRecoverRequest,
+	ScheduleCreateRequest,
+	ScheduleUpdateRequest,
+	ScheduleGetRequest,
+	ScheduleListRequest,
+	ScheduleControlRequest
+]);
+const ScheduleOwnerFailure = Schema.Union([
+	ScheduleValidationError,
+	ScheduleAuthorizationError,
+	ScheduleConflict,
+	ScheduleNotFound,
+	ScheduleCapacityError,
+	ScheduleStorageError,
+	ScheduleFailpointError,
+	ScheduleOwnerProtocolError
+]);
+const ScheduleOwnerResponse = Schema.Union([
+	Schema.TaggedStruct("Snapshot", { value: ScheduleSnapshot }),
+	Schema.TaggedStruct("Page", { value: ScheduleSnapshotPage }),
+	Schema.TaggedStruct("Failed", { failure: ScheduleOwnerFailure })
+]);
+const decodeScheduleOwnerRequest = Schema.decodeUnknownEffect(ScheduleOwnerRequest);
+const encodeScheduleOwnerRequest = Schema.encodeEffect(ScheduleOwnerRequest);
+const decodeScheduleOwnerResponse = Schema.decodeUnknownEffect(ScheduleOwnerResponse);
+const encodeScheduleOwnerResponse = Schema.encodeEffect(ScheduleOwnerResponse);
+const scheduleProtocolFailure = (message) => ({
+	_tag: "Failed",
+	failure: ScheduleOwnerProtocolError.make({ message: boundedProtocolMessage(message) })
+});
+var ScheduleOwnerNamespace = class extends Context.Service()("@effect-agent/platform-cloudflare/ScheduleOwnerNamespace") {};
+const passthroughAgent = (agentId) => ({ definition: {
+	id: agentId,
+	input: PersistedJson
+} });
+const requestOwner = (request) => request.scope.owner;
+/** Provides the same authorized management service as NodeScheduling.layer. */
+var CloudflareSchedulingClient = class {
+	static layer = Layer.effect(Scheduling, Effect.gen(function* () {
+		const { namespace } = yield* ScheduleOwnerNamespace;
+		const call = Effect.fn("CloudflareSchedulingClient.call")(function* (owner, request) {
+			const encoded = yield* encodeScheduleOwnerRequest(request).pipe(Effect.mapError(() => ScheduleStorageError.make({
+				operation: "Schedule Owner protocol",
+				reason: "corrupt"
+			})));
+			const raw = yield* Effect.tryPromise({
+				try: () => namespace.get(namespace.idFromName(scheduleOwnerKey(owner))).schedule(encoded),
+				catch: () => ScheduleStorageError.make({
+					operation: "call Schedule Owner",
+					reason: "unavailable"
+				})
+			});
+			const response = yield* decodeScheduleOwnerResponse(raw).pipe(Effect.mapError(() => ScheduleStorageError.make({
+				operation: "Schedule Owner protocol",
+				reason: "corrupt"
+			})));
+			if (response._tag !== "Failed") return response;
+			return yield* response.failure._tag === "ScheduleOwnerProtocolError" ? ScheduleStorageError.make({
+				operation: "Schedule Owner protocol",
+				reason: "corrupt"
+			}) : response.failure;
+		});
+		const encodeInput = Effect.fn("CloudflareSchedulingClient.encodeInput")(function* (agent, input) {
+			const encoded = yield* Schema.encodeEffect(agent.definition.input)(input).pipe(Effect.mapError(() => ScheduleValidationError.make({ message: "Unable to encode Agent input" })));
+			return yield* Schema.decodeUnknownEffect(PersistedJson)(encoded).pipe(Effect.mapError(() => ScheduleValidationError.make({ message: "Agent input does not satisfy the canonical persistence bounds" })));
+		});
+		const create = (agent, input, options) => Effect.gen(function* () {
+			const payload = yield* encodeInput(agent, input);
+			const response = yield* call(options.scope.owner, {
+				_tag: "Create",
+				schemaVersion: 1,
+				agentId: agent.definition.id,
+				input: payload,
+				...options
+			});
+			return response._tag === "Snapshot" ? response.value : yield* ScheduleStorageError.make({
+				operation: "Schedule Owner protocol",
+				reason: "corrupt"
+			});
+		});
+		const update = (agent, input, options) => Effect.gen(function* () {
+			const payload = yield* encodeInput(agent, input);
+			const response = yield* call(options.scope.owner, {
+				_tag: "Update",
+				schemaVersion: 1,
+				agentId: agent.definition.id,
+				input: payload,
+				...options
+			});
+			return response._tag === "Snapshot" ? response.value : yield* ScheduleStorageError.make({
+				operation: "Schedule Owner protocol",
+				reason: "corrupt"
+			});
+		});
+		const get = (scope, scheduleId) => Effect.gen(function* () {
+			const response = yield* call(scope.owner, {
+				_tag: "Get",
+				schemaVersion: 1,
+				scope,
+				scheduleId
+			});
+			return response._tag === "Snapshot" ? response.value : yield* ScheduleStorageError.make({
+				operation: "Schedule Owner protocol",
+				reason: "corrupt"
+			});
+		});
+		const list = (scope, options = {}) => Effect.gen(function* () {
+			const response = yield* call(scope.owner, {
+				_tag: "List",
+				schemaVersion: 1,
+				scope,
+				...options.after === void 0 ? {} : { after: options.after },
+				...options.limit === void 0 ? {} : { limit: options.limit }
+			});
+			return response._tag === "Page" ? response.value : yield* ScheduleStorageError.make({
+				operation: "Schedule Owner protocol",
+				reason: "corrupt"
+			});
+		});
+		const control = (operation, scope, scheduleId, expectedRevision) => Effect.gen(function* () {
+			const response = yield* call(scope.owner, {
+				_tag: "Control",
+				schemaVersion: 1,
+				operation,
+				scope,
+				scheduleId,
+				expectedRevision
+			});
+			return response._tag === "Snapshot" ? response.value : yield* ScheduleStorageError.make({
+				operation: "Schedule Owner protocol",
+				reason: "corrupt"
+			});
+		});
+		return Scheduling.of({
+			create,
+			update,
+			get,
+			list,
+			pause: (scope, id, revision) => control("pause", scope, id, revision),
+			resume: (scope, id, revision) => control("resume", scope, id, revision),
+			recover: (scope, scheduleId, expectedRevision, expectedGeneration) => Effect.gen(function* () {
+				const response = yield* call(scope.owner, {
+					_tag: "Recover",
+					schemaVersion: 1,
+					scope,
+					scheduleId,
+					expectedRevision,
+					expectedGeneration
+				});
+				return response._tag === "Snapshot" ? response.value : yield* ScheduleStorageError.make({
+					operation: "Schedule Owner protocol",
+					reason: "corrupt"
+				});
+			}),
+			cancel: (scope, id, revision) => control("cancel", scope, id, revision)
+		});
+	}));
+};
+var ScheduleOwnerIdentity = class extends Context.Service()("@effect-agent/platform-cloudflare/ScheduleOwnerIdentity") {};
+const decodeOwnerName = Effect.fn("decodeScheduleOwnerName")(function* (name) {
+	if (name === null || name === void 0) return yield* ScheduleOwnerProtocolError.make({ message: "Schedule Owner objects require an idFromName identity" });
+	const tuple = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Tuple([Schema.String, Schema.String])))(name).pipe(Effect.mapError(() => ScheduleOwnerProtocolError.make({ message: "Schedule Owner object name is malformed" })));
+	return yield* Schema.decodeUnknownEffect(ScheduleOwner)({
+		tenantId: tuple[0],
+		ownerId: tuple[1]
+	}).pipe(Effect.mapError(() => ScheduleOwnerProtocolError.make({ message: "Schedule Owner object identity is invalid" })));
+});
+const alarmStorageError = (operation) => (error) => ScheduleStorageError.make({
+	operation,
+	reason: error._tag === "StorageOperationError" ? "unavailable" : "corrupt"
+});
+const transactionLayer = Layer.effect(DoScheduleTransaction, Effect.gen(function* () {
+	const alarms = yield* DurableObjectAlarm.DurableObjectAlarm;
+	return DoScheduleTransaction.of({ run: (body) => Effect.gen(function* () {
+		const nowMillis = yield* Clock.currentTimeMillis;
+		return yield* alarms.transaction((transaction) => body((replacement) => replacement.deadlineAtMillis === null ? transaction.cancelAlarm({
+			id: SCHEDULE_ALARM_ID,
+			tag: SCHEDULE_ALARM_TAG
+		}).pipe(Effect.mapError(alarmStorageError("cancel Schedule Owner alarm"))) : Effect.fromOption(DateTime.make(Math.max(replacement.deadlineAtMillis, nowMillis + 1))).pipe(Effect.mapError(() => ScheduleStorageError.make({
+			operation: "validate Schedule Owner alarm deadline",
+			reason: "corrupt"
+		})), Effect.flatMap((runAt) => transaction.scheduleAlarm({
+			id: SCHEDULE_ALARM_ID,
+			tag: SCHEDULE_ALARM_TAG,
+			runAt,
+			payload: {
+				schemaVersion: 1,
+				generation: replacement.generation
+			}
+		}).pipe(Effect.mapError(alarmStorageError("schedule Schedule Owner alarm"))))))).pipe(Effect.catchTag("StorageOperationError", () => ScheduleStorageError.make({
+			operation: "commit Schedule Owner transaction",
+			reason: "unavailable"
+		})));
+	}) });
+}));
+const ensureOwner = (expected, request) => {
+	const observed = requestOwner(request);
+	return observed.tenantId === expected.tenantId && observed.ownerId === expected.ownerId ? Effect.void : Effect.fail(ScheduleOwnerProtocolError.make({ message: "The request owner does not match the addressed Schedule Owner object" }));
+};
+const handleScheduleRequest = Effect.fn("ScheduleOwner.handleRequest")(function* (encoded) {
+	const decoded = yield* decodeScheduleOwnerRequest(encoded).pipe(Effect.result);
+	if (decoded._tag === "Failure") return yield* encodeScheduleOwnerResponse(scheduleProtocolFailure("The Schedule request could not be decoded")).pipe(Effect.orDie);
+	const request = decoded.success;
+	const { owner } = yield* ScheduleOwnerIdentity;
+	const scheduling = yield* Scheduling;
+	const response = yield* Effect.gen(function* () {
+		yield* ensureOwner(owner, request);
+		switch (request._tag) {
+			case "Create": return {
+				_tag: "Snapshot",
+				value: yield* scheduling.create(passthroughAgent(request.agentId), request.input, {
+					scope: request.scope,
+					scheduleId: request.scheduleId,
+					timing: request.timing,
+					destination: request.destination,
+					deliveryPrincipal: request.deliveryPrincipal,
+					definitions: request.definitions,
+					...request.admissionGroup === void 0 ? {} : { admissionGroup: request.admissionGroup },
+					...request.admissionFence === void 0 ? {} : { admissionFence: request.admissionFence }
+				})
+			};
+			case "Update": return {
+				_tag: "Snapshot",
+				value: yield* scheduling.update(passthroughAgent(request.agentId), request.input, {
+					scope: request.scope,
+					scheduleId: request.scheduleId,
+					timing: request.timing,
+					destination: request.destination,
+					deliveryPrincipal: request.deliveryPrincipal,
+					definitions: request.definitions,
+					...request.admissionGroup === void 0 ? {} : { admissionGroup: request.admissionGroup },
+					...request.admissionFence === void 0 ? {} : { admissionFence: request.admissionFence },
+					expectedRevision: request.expectedRevision
+				})
+			};
+			case "Get": return {
+				_tag: "Snapshot",
+				value: yield* scheduling.get(request.scope, request.scheduleId)
+			};
+			case "List": return {
+				_tag: "Page",
+				value: yield* scheduling.list(request.scope, {
+					...request.after === void 0 ? {} : { after: request.after },
+					...request.limit === void 0 ? {} : { limit: request.limit }
+				})
+			};
+			case "Recover": return {
+				_tag: "Snapshot",
+				value: yield* scheduling.recover(request.scope, request.scheduleId, request.expectedRevision, request.expectedGeneration)
+			};
+			case "Control": return {
+				_tag: "Snapshot",
+				value: request.operation === "pause" ? yield* scheduling.pause(request.scope, request.scheduleId, request.expectedRevision) : request.operation === "resume" ? yield* scheduling.resume(request.scope, request.scheduleId, request.expectedRevision) : yield* scheduling.cancel(request.scope, request.scheduleId, request.expectedRevision)
+			};
+		}
+	}).pipe(Effect.map((value) => value), Effect.catch((failure) => Schema.is(ScheduleOwnerFailure)(failure) ? Effect.succeed({
+		_tag: "Failed",
+		failure
+	}) : Effect.succeed(scheduleProtocolFailure("The Schedule operation failed outside its public contract"))));
+	return yield* encodeScheduleOwnerResponse(response).pipe(Effect.orDie);
+});
+/** @internal The complete native alarm operation, including its event deadline. */
+const scheduleAlarmHandler = (limits) => DurableObjectAlarm.processDue((event) => Effect.gen(function* () {
+	if (event.tag !== SCHEDULE_ALARM_TAG || event.id !== SCHEDULE_ALARM_ID) return yield* ScheduleAlarmProtocolError.make({ message: `Unsupported Schedule Owner alarm ${event.tag}/${event.id}` });
+	yield* Schema.decodeUnknownEffect(ScheduleAlarmPayload)(event.payload).pipe(Effect.mapError(() => ScheduleAlarmProtocolError.make({ message: "Unsupported Schedule Owner alarm payload version" })));
+	const scheduling = yield* ScheduleDriver;
+	const alarmControl = yield* DoScheduleAlarmControl;
+	const { owner } = yield* ScheduleOwnerIdentity;
+	const nowMillis = yield* Clock.currentTimeMillis;
+	yield* alarmControl.prearm(nowMillis + limits.recoveryPollMillis);
+	if ((yield* scheduling.runDue(owner)).failed > 0) yield* alarmControl.prearm((yield* Clock.currentTimeMillis) + limits.recoveryPollMillis);
+	else yield* alarmControl.reconcile;
+}), { mode: "ordered" }).pipe(Effect.timeout("14 minutes"), Effect.asVoid);
+/**
+* The host Layer supplies authorization and routing and is cached for the object incarnation.
+* Cloudflare eviction does not guarantee its finalizers run. Do not acquire resources requiring
+* cleanup in this Layer; acquire them inside scoped `manage` / `prepare` operations instead.
+* Native services belong to effect-cf; the database and alarm runtime remain instance-owned.
+*/
+const makeScheduleOwnerObjectClass = (host, limits = defaultSchedulingLimits) => {
+	const ownerLayer = Layer.effect(ScheduleOwnerIdentity, Effect.gen(function* () {
+		const state = yield* DurableObjectState.DurableObjectState;
+		return ScheduleOwnerIdentity.of({ owner: yield* decodeOwnerName(state.raw.id.name) });
+	}));
+	const sqlLayer = Layer.unwrap(Effect.map(DurableObjectState.DurableObjectState, (state) => SqliteClient.layer({ storage: state.raw.storage })));
+	const application = Layer.merge(Scheduling.layer(limits), ScheduleDriver.layer(limits)).pipe(Layer.provideMerge(scheduleStoreLayer.pipe(Layer.provide(transactionLayer), Layer.provide(sqlLayer))), Layer.provide(cloudflareScheduledInputAdmissionLayer.pipe(Layer.provide(cloudflarePreparedInputAdmissionLayer), Layer.provide(CloudflareThreadClient.layer))), Layer.provide(ScheduleWakeNoop), Layer.provide(BrowserCrypto.layer), Layer.provideMerge(DurableObjectAlarm.DurableObjectAlarm.layer), Layer.provide(host), Layer.provideMerge(ownerLayer));
+	const runtime = Layer.effectContext(Effect.gen(function* () {
+		const state = yield* DurableObjectState.DurableObjectState;
+		const scope = yield* Effect.scope;
+		return yield* state.blockConcurrencyWhile(Layer.buildWithScope(application, scope));
+	}));
+	const Base = DurableObject.make(runtime, {
+		initialize: Effect.void,
+		rpc: { schedule: (encoded) => handleScheduleRequest(encoded) },
+		alarms: scheduleAlarmHandler(limits)
+	});
+	class ScheduleOwnerObject extends Base {
+		alarm(alarmInfo) {
+			return super.alarm?.(alarmInfo);
+		}
+	}
+	return ScheduleOwnerObject;
+};
+//#endregion
+export { CloudflareSchedulingClient, ScheduleAlarmProtocolError, ScheduleOwnerIdentity, ScheduleOwnerNamespace, ScheduleOwnerProtocolError, makeScheduleOwnerObjectClass, scheduleAlarmHandler, CloudflareScheduling_exports as t };
+
+//# sourceMappingURL=CloudflareScheduling.mjs.map