@effect-agent/platform-cloudflare 0.1.0-beta.9 → 0.1.0-beta.91

package/dist/CloudflareMemory.mjs

@@ -0,0 +1,202 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Clock, Context, Effect, Layer, Schema } from "effect";
+import { Principal } from "effect-agent/submission-ledger";
+import { DurableObject, DurableObjectState, RpcTargets } from "effect-cf";
+import { defaultDoMemoryStorageLimits, doMemoryStoreLayerWithFailpoints } from "@effect-agent/storage-cloudflare/do-memory-store";
+import { MemoryOwnerIdentity, MemoryOwnerRequest, MemoryOwnerResponse, MemoryRpcError, MemoryRpcLimits, decodeMemoryWire, defaultMemoryRpcLimits, encodeMemoryWire, handleMemoryOwnerRequest } from "@effect-agent/storage-cloudflare/memory-protocol";
+import * as Memory from "effect-agent/memory";
+import * as MemoryNamespace from "effect-agent/memory-namespace";
+import { MemoryNamespaceAddress } from "effect-agent/memory-namespace";
+import { MemoryRecallLimits } from "effect-agent/memory-reference";
+import { MemoryAccess } from "effect-agent/memory-revalidation";
+import { MemoryDocument, MemoryKey, MemoryMutationFailpoint, MemoryStorageError, MemoryWriter } from "effect-agent/memory-store";
+import "effect-agent/semantic-memory-index";
+import "effect-agent/semantic-memory-revalidation";
+//#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.decodeEffect(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.decodeEffect(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.decodeEffect(MemoryOwnerRequest)(request).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
+		const encoded = yield* encodeMemoryWire(MemoryOwnerRequest, decoded, validated.maxRequestBytes);
+		const unavailable = (cause) => {
+			const error = MemoryRpcError.make({ reason: "unavailable" });
+			error.cause = cause;
+			return error;
+		};
+		const address = memoryObjectName(bound.namespace);
+		const target = yield* RpcTargets.get(namespace, address, () => namespace.get(namespace.idFromName(address))).pipe(Effect.mapError(unavailable));
+		const raw = yield* Effect.tryPromise({
+			try: () => target.memory(encoded),
+			catch: unavailable
+		}).pipe(Effect.tapCause(() => RpcTargets.invalidate(target)));
+		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.decodeEffect(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));
+	});
+	/**
+	* Read one exact current document in one owner RPC. Null means absent; withdrawals return
+	* tombstones. Denial, unavailable storage and deadlines fail typed, never become absence.
+	* Reads begun after an acknowledged write observe it or a later revision. The owner checks
+	* exact-key authority and active document scopes; source-dependent provenance policy remains
+	* application-owned. No extraction, job draining, embedding, discovery or rendering occurs.
+	*/
+	const get = Effect.fn("CloudflareMemoryClient.get")(function* (key) {
+		const decodedKey = yield* Schema.decodeUnknownEffect(MemoryKey.Wire)(key).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
+		if (!MemoryNamespace.equals(decodedKey.namespace, bound.namespace)) return yield* MemoryRpcError.make({ reason: "denied" });
+		return yield* Effect.gen(function* () {
+			const response = yield* call({
+				_tag: "Get",
+				version: 1,
+				access: bound,
+				principal,
+				key: decodedKey,
+				deadlineMillis: (yield* Clock.currentTimeMillis) + validated.timeoutMillis
+			});
+			if (response._tag !== "Document" || !MemoryNamespace.equals(response.key.namespace, bound.namespace) || response.key.id !== decodedKey.id) return yield* MemoryRpcError.make({ reason: "protocol" });
+			if (response.document === null) return null;
+			if (response.document.key.id !== decodedKey.id || response.document.source.id !== decodedKey.id || response.document._tag === "ActiveMemoryDocument" && !response.document.scopes.includes(bound.scope)) return yield* MemoryRpcError.make({ reason: "protocol" });
+			yield* encodeMemoryWire(MemoryDocument.Wire, response.document, validated.maxSourceBytes);
+			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 {
+		get,
+		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.decodeEffect(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 {\n  type DoMemoryStorageLimits,\n  defaultDoMemoryStorageLimits,\n  doMemoryStoreLayerWithFailpoints,\n} from \"@effect-agent/storage-cloudflare/do-memory-store\";\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/memory-protocol\";\nimport { Clock, Context, Effect, Layer, Schema } from \"effect\";\nimport * as Memory from \"effect-agent/memory\";\nimport * as MemoryNamespace from \"effect-agent/memory-namespace\";\nimport { MemoryNamespaceAddress } from \"effect-agent/memory-namespace\";\nimport { type MemoryLookup, MemoryRecallLimits } from \"effect-agent/memory-reference\";\nimport { MemoryAccess } from \"effect-agent/memory-revalidation\";\nimport {\n  type MemoryReader,\n  type MemoryWrite,\n  MemoryKey,\n  MemoryDocument,\n  MemoryMutationFailpoint,\n  MemoryStorageError,\n  MemoryWriter,\n} from \"effect-agent/memory-store\";\nimport {\n  type MemoryIndexSearch,\n  type SemanticMemoryProfile,\n} from \"effect-agent/semantic-memory-index\";\nimport { type SemanticCandidateLimits } from \"effect-agent/semantic-memory-revalidation\";\nimport { Principal } from \"effect-agent/submission-ledger\";\nimport {\n  DurableObject as EffectCfDurableObject,\n  DurableObjectState,\n  RpcTargets,\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.decodeEffect(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.decodeEffect(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.decodeEffect(MemoryOwnerRequest)(request).pipe(\n      Effect.mapError(() => MemoryRpcError.make({ reason: \"protocol\" })),\n    );\n\n    const encoded = yield* encodeMemoryWire(MemoryOwnerRequest, decoded, validated.maxRequestBytes);\n\n    const unavailable = (cause: unknown) => {\n      const error = MemoryRpcError.make({ reason: \"unavailable\" });\n\n      error.cause = cause;\n\n      return error;\n    };\n\n    const address = memoryObjectName(bound.namespace);\n\n    const target = yield* RpcTargets.get(namespace, address, () =>\n      namespace.get(namespace.idFromName(address)),\n    ).pipe(Effect.mapError(unavailable));\n\n    const raw = yield* Effect.tryPromise({\n      try: () => target.memory(encoded),\n      catch: unavailable,\n    }).pipe(Effect.tapCause(() => RpcTargets.invalidate(target)));\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.decodeEffect(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  /**\n   * Read one exact current document in one owner RPC. Null means absent; withdrawals return\n   * tombstones. Denial, unavailable storage and deadlines fail typed, never become absence.\n   * Reads begun after an acknowledged write observe it or a later revision. The owner checks\n   * exact-key authority and active document scopes; source-dependent provenance policy remains\n   * application-owned. No extraction, job draining, embedding, discovery or rendering occurs.\n   */\n  const get = Effect.fn(\"CloudflareMemoryClient.get\")(function* (key: MemoryKey<Namespace>) {\n    const decodedKey = yield* Schema.decodeUnknownEffect(MemoryKey.Wire)(key).pipe(\n      Effect.mapError(() => MemoryRpcError.make({ reason: \"protocol\" })),\n    );\n\n    if (!MemoryNamespace.equals(decodedKey.namespace, bound.namespace))\n      return yield* MemoryRpcError.make({ reason: \"denied\" });\n\n    return yield* Effect.gen(function* () {\n      const response = yield* call({\n        _tag: \"Get\",\n        version: 1,\n        access: bound,\n        principal,\n        key: decodedKey,\n        deadlineMillis: (yield* Clock.currentTimeMillis) + validated.timeoutMillis,\n      });\n\n      if (\n        response._tag !== \"Document\" ||\n        !MemoryNamespace.equals(response.key.namespace, bound.namespace) ||\n        response.key.id !== decodedKey.id\n      )\n        return yield* MemoryRpcError.make({ reason: \"protocol\" });\n      if (response.document === null) return null;\n      if (\n        response.document.key.id !== decodedKey.id ||\n        response.document.source.id !== decodedKey.id ||\n        (response.document._tag === \"ActiveMemoryDocument\" &&\n          !response.document.scopes.includes(bound.scope))\n      )\n        return yield* MemoryRpcError.make({ reason: \"protocol\" });\n\n      yield* encodeMemoryWire(MemoryDocument.Wire, response.document, validated.maxSourceBytes);\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 { get, 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.decodeEffect(MemoryRpcLimits)(options.rpcLimits ?? defaultMemoryRpcLimits).pipe(\n        Effect.mapError(() => MemoryRpcError.make({ reason: \"protocol\" })),\n      );\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/do-schedule-store";
+import { ScheduleAuthorizer, ScheduleFailpointError, ScheduleOwner, ScheduleStorageError, SchedulingLimits } from "effect-agent/schedule";
+import { ScheduleDriver, Scheduling } from "effect-agent/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