effect-agent 0.1.0-beta.85 → 0.1.0-beta.87

package/dist/core/MemoryRevalidation.mjs

@@ -0,0 +1,126 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { n as utf8ByteLength } from "../utf8-DchGZRBd.mjs";
+import { MemoryLookup, MemoryPassage, MemoryRecallError, MemoryRecallLimits } from "./MemoryReference.mjs";
+import { MemoryDocument, MemoryKey, MemoryReader, MemoryScope, MemoryStorageError } from "./MemoryStore.mjs";
+import { Effect, Schema } from "effect";
+//#region src/core/MemoryRevalidation.ts
+var MemoryRevalidation_exports = /* @__PURE__ */ __exportAll({
+	MemoryAccess: () => MemoryAccess,
+	revalidateMemoryLookup: () => revalidateMemoryLookup
+});
+const RevalidationLimits = Schema.Struct({
+	maxInputBytes: MemoryRecallLimits.fields.maxInputBytes,
+	maxSourceBytes: MemoryRecallLimits.fields.maxInputBytes
+});
+/** Bind these values in host code. Neither is a model-selectable retrieval parameter. */
+var MemoryAccessWire = class extends Schema.Class("@effect-agent/capabilities/MemoryAccess")({
+	namespace: MemoryKey.Wire.fields.namespace,
+	scope: MemoryScope
+}) {};
+const MemoryAccess = {
+	Wire: MemoryAccessWire,
+	make: (fields) => Object.assign(Schema.decodeUnknownSync(MemoryAccessWire)(fields), { namespace: fields.namespace })
+};
+/**
+* Resolve derivative candidates against the current authoritative source and host-bound access.
+* The reader needs no write capability. A same-revision excerpt is kept only if its exact text
+* occurs in the current source; all attribution and metadata come from that source. Otherwise
+* the whole current document replaces it. Aggregate output JSON is bounded before retention,
+* including duplicates, by maxInputBytes, defaulting to 16 MiB with a 64 MiB maximum.
+* maxSourceBytes optionally bounds aggregate encoded authoritative documents, once per source.
+* One authoritative document is decoded at a time; reader-side allocations precede these bounds.
+*
+* There is no cache. One invocation reads each distinct source once. Checks begun after a
+* successful withdrawal or access revocation exclude that source; an in-flight snapshot can
+* finish, including its same-Turn overflow retry. Original history and prior outputs remain.
+*/
+const revalidateMemoryLookup = Effect.fn("revalidateMemoryLookup")(function* (lookup, access, limits = {}) {
+	const decodedLimits = yield* Schema.decodeEffect(RevalidationLimits)(limits).pipe(Effect.mapError(() => MemoryRecallError.make({
+		reason: "invalid-input",
+		message: "Invalid revalidation limits"
+	})));
+	const decodedAccess = yield* Schema.decodeEffect(MemoryAccess.Wire)(access).pipe(Effect.mapError(() => MemoryRecallError.make({
+		reason: "invalid-input",
+		message: "Invalid host memory access"
+	})));
+	const decoded = yield* Schema.decodeEffect(MemoryLookup)(lookup).pipe(Effect.mapError(() => MemoryRecallError.make({
+		reason: "invalid-input",
+		message: "Malformed memory candidates"
+	})));
+	if (decoded._tag !== "Found") return decoded;
+	const reader = yield* MemoryReader;
+	const groups = /* @__PURE__ */ new Map();
+	for (const [index, candidate] of decoded.passages.entries()) {
+		const group = groups.get(candidate.source.id);
+		if (group === void 0) groups.set(candidate.source.id, [{
+			candidate,
+			index
+		}]);
+		else group.push({
+			candidate,
+			index
+		});
+	}
+	const passages = [];
+	const maxInputBytes = decodedLimits.maxInputBytes ?? 16777216;
+	let inputBytes = 0;
+	let sourceBytes = 0;
+	for (const [sourceId, group] of groups) {
+		yield* Effect.yieldNow;
+		const key = MemoryKey.make({
+			namespace: decodedAccess.namespace,
+			id: sourceId
+		});
+		const document = yield* reader.get(key).pipe(Effect.flatMap((value) => Schema.decodeEffect(Schema.NullOr(MemoryDocument.Wire))(value).pipe(Effect.mapError(() => MemoryStorageError.make({
+			operation: "validate source view",
+			reason: "corrupt"
+		})))));
+		if (document !== null && (document.key.namespace.address !== key.namespace.address || document.key.id !== key.id || document.source.id !== key.id)) return yield* MemoryStorageError.make({
+			operation: "validate source identity",
+			reason: "corrupt"
+		});
+		if (document === null || document._tag === "WithdrawnMemoryDocument" || !document.scopes.includes(decodedAccess.scope)) continue;
+		if (decodedLimits.maxSourceBytes !== void 0) {
+			sourceBytes += utf8ByteLength(JSON.stringify(document));
+			if (sourceBytes > decodedLimits.maxSourceBytes) return yield* MemoryRecallError.make({
+				reason: "budget",
+				sourceId,
+				message: "Authoritative memory source byte budget exceeded"
+			});
+		}
+		for (const { candidate, index } of group) {
+			const sameExcerpt = document.source.revision === candidate.source.revision && document.content.text.includes(candidate.content.text);
+			const passage = MemoryPassage.make({
+				version: 1,
+				authority: decodedAccess.namespace.address,
+				source: document.source,
+				passageId: sameExcerpt ? candidate.passageId : "document",
+				content: {
+					...document.content,
+					text: sameExcerpt ? candidate.content.text : document.content.text
+				}
+			});
+			const encoded = JSON.stringify(passage);
+			const remaining = maxInputBytes - inputBytes;
+			const encodedBytes = encoded.length <= remaining ? utf8ByteLength(encoded) : void 0;
+			if (encodedBytes === void 0 || encodedBytes > remaining) return yield* MemoryRecallError.make({
+				reason: "budget",
+				sourceId,
+				message: "Revalidated memory input encoding budget exceeded"
+			});
+			inputBytes += encodedBytes;
+			passages.push({
+				passage,
+				index
+			});
+		}
+	}
+	return passages.length === 0 ? { _tag: "NoMatch" } : {
+		_tag: "Found",
+		passages: passages.sort((left, right) => left.index - right.index).map(({ passage }) => passage)
+	};
+});
+//#endregion
+export { MemoryAccess, revalidateMemoryLookup, MemoryRevalidation_exports as t };
+
+//# sourceMappingURL=MemoryRevalidation.mjs.map

package/dist/core/MemoryRevalidation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryRevalidation.mjs","names":[],"sources":["../../src/core/MemoryRevalidation.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\";\n\nimport { utf8ByteLength } from \"./internal/utf8.ts\";\nimport type * as MemoryNamespace from \"./MemoryNamespace.ts\";\nimport {\n  MemoryLookup,\n  MemoryPassage,\n  MemoryRecallError,\n  MemoryRecallLimits,\n} from \"./MemoryReference.ts\";\nimport {\n  MemoryDocument,\n  MemoryKey,\n  MemoryReader,\n  MemoryScope,\n  MemoryStorageError,\n} from \"./MemoryStore.ts\";\n\nconst RevalidationLimits = Schema.Struct({\n  maxInputBytes: MemoryRecallLimits.fields.maxInputBytes,\n  maxSourceBytes: MemoryRecallLimits.fields.maxInputBytes,\n});\n\n/** Bind these values in host code. Neither is a model-selectable retrieval parameter. */\nclass MemoryAccessWire extends Schema.Class<MemoryAccessWire>(\n  \"@effect-agent/capabilities/MemoryAccess\",\n)({\n  namespace: MemoryKey.Wire.fields.namespace,\n  scope: MemoryScope,\n}) {}\n\nexport type MemoryAccess<Namespace extends MemoryNamespace.Any = MemoryNamespace.Any> = Omit<\n  MemoryAccessWire,\n  \"namespace\"\n> & { readonly namespace: Namespace };\n\nexport const MemoryAccess = {\n  Wire: MemoryAccessWire,\n  make: <Namespace extends MemoryNamespace.Any>(\n    fields: MemoryAccess<Namespace>,\n  ): MemoryAccess<Namespace> =>\n    Object.assign(Schema.decodeUnknownSync(MemoryAccessWire)(fields), {\n      namespace: fields.namespace,\n    }),\n};\n\n/**\n * Resolve derivative candidates against the current authoritative source and host-bound access.\n * The reader needs no write capability. A same-revision excerpt is kept only if its exact text\n * occurs in the current source; all attribution and metadata come from that source. Otherwise\n * the whole current document replaces it. Aggregate output JSON is bounded before retention,\n * including duplicates, by maxInputBytes, defaulting to 16 MiB with a 64 MiB maximum.\n * maxSourceBytes optionally bounds aggregate encoded authoritative documents, once per source.\n * One authoritative document is decoded at a time; reader-side allocations precede these bounds.\n *\n * There is no cache. One invocation reads each distinct source once. Checks begun after a\n * successful withdrawal or access revocation exclude that source; an in-flight snapshot can\n * finish, including its same-Turn overflow retry. Original history and prior outputs remain.\n */\nexport const revalidateMemoryLookup = Effect.fn(\"revalidateMemoryLookup\")(function* (\n  lookup: MemoryLookup,\n  access: MemoryAccess,\n  limits: Pick<MemoryRecallLimits, \"maxInputBytes\"> & { readonly maxSourceBytes?: number } = {},\n) {\n  const decodedLimits = yield* Schema.decodeEffect(RevalidationLimits)(limits).pipe(\n    Effect.mapError(() =>\n      MemoryRecallError.make({ reason: \"invalid-input\", message: \"Invalid revalidation limits\" }),\n    ),\n  );\n\n  const decodedAccess = yield* Schema.decodeEffect(MemoryAccess.Wire)(access).pipe(\n    Effect.mapError(() =>\n      MemoryRecallError.make({ reason: \"invalid-input\", message: \"Invalid host memory access\" }),\n    ),\n  );\n\n  const decoded = yield* Schema.decodeEffect(MemoryLookup)(lookup).pipe(\n    Effect.mapError(() =>\n      MemoryRecallError.make({ reason: \"invalid-input\", message: \"Malformed memory candidates\" }),\n    ),\n  );\n\n  if (decoded._tag !== \"Found\") return decoded;\n  const reader = yield* MemoryReader;\n\n  const groups = new Map<\n    string,\n    Array<{ readonly candidate: MemoryPassage; readonly index: number }>\n  >();\n\n  for (const [index, candidate] of decoded.passages.entries()) {\n    const group = groups.get(candidate.source.id);\n\n    if (group === undefined) groups.set(candidate.source.id, [{ candidate, index }]);\n    else group.push({ candidate, index });\n  }\n  const passages: Array<{ readonly passage: MemoryPassage; readonly index: number }> = [];\n  const maxInputBytes = decodedLimits.maxInputBytes ?? 16_777_216;\n  let inputBytes = 0;\n  let sourceBytes = 0;\n\n  for (const [sourceId, group] of groups) {\n    yield* Effect.yieldNow;\n    const key = MemoryKey.make({ namespace: decodedAccess.namespace, id: sourceId });\n\n    const document = yield* reader\n      .get(key)\n      .pipe(\n        Effect.flatMap((value) =>\n          Schema.decodeEffect(Schema.NullOr(MemoryDocument.Wire))(value).pipe(\n            Effect.mapError(() =>\n              MemoryStorageError.make({ operation: \"validate source view\", reason: \"corrupt\" }),\n            ),\n          ),\n        ),\n      );\n\n    if (\n      document !== null &&\n      (document.key.namespace.address !== key.namespace.address ||\n        document.key.id !== key.id ||\n        document.source.id !== key.id)\n    ) {\n      return yield* MemoryStorageError.make({\n        operation: \"validate source identity\",\n        reason: \"corrupt\",\n      });\n    }\n    if (\n      document === null ||\n      document._tag === \"WithdrawnMemoryDocument\" ||\n      !document.scopes.includes(decodedAccess.scope)\n    )\n      continue;\n    if (decodedLimits.maxSourceBytes !== undefined) {\n      sourceBytes += utf8ByteLength(JSON.stringify(document));\n      if (sourceBytes > decodedLimits.maxSourceBytes)\n        return yield* MemoryRecallError.make({\n          reason: \"budget\",\n          sourceId,\n          message: \"Authoritative memory source byte budget exceeded\",\n        });\n    }\n    for (const { candidate, index } of group) {\n      const sameExcerpt =\n        document.source.revision === candidate.source.revision &&\n        document.content.text.includes(candidate.content.text);\n\n      const passage = MemoryPassage.make({\n        version: 1,\n        authority: decodedAccess.namespace.address,\n        source: document.source,\n        passageId: sameExcerpt ? candidate.passageId : \"document\",\n        content: {\n          ...document.content,\n          text: sameExcerpt ? candidate.content.text : document.content.text,\n        },\n      });\n\n      const encoded = JSON.stringify(passage);\n      const remaining = maxInputBytes - inputBytes;\n\n      const encodedBytes = encoded.length <= remaining ? utf8ByteLength(encoded) : undefined;\n\n      if (encodedBytes === undefined || encodedBytes > remaining) {\n        return yield* MemoryRecallError.make({\n          reason: \"budget\",\n          sourceId,\n          message: \"Revalidated memory input encoding budget exceeded\",\n        });\n      }\n      inputBytes += encodedBytes;\n      passages.push({ passage, index });\n    }\n  }\n\n  return passages.length === 0\n    ? { _tag: \"NoMatch\" as const }\n    : {\n        _tag: \"Found\" as const,\n        passages: passages\n          .sort((left, right) => left.index - right.index)\n          .map(({ passage }) => passage),\n      };\n});\n"],"mappings":"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"}

package/dist/core/MemoryStore.d.mts

@@ -0,0 +1,186 @@
+import { l as MemorySourceReference, n as MemoryContent } from "../MemoryReference-B8Q3UJoJ.mjs";
+import { t as Any } from "../MemoryNamespace-BbRW5p71.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+declare namespace MemoryStore_d_exports {
+  export { ActiveMemoryDocument, MemoryConflict, MemoryDocument, MemoryKey, MemoryMutationFailpoint, MemoryMutationFailure, MemoryMutationPoint, MemoryOperationConflict, MemoryReader, MemoryScope, MemoryStorageError, MemoryWithdrawn, MemoryWrite, MemoryWriteError, MemoryWriter, WithdrawnMemoryDocument, applyMemoryWrite };
+}
+/** Host-defined recall visibility label. A scope identifies access policy; it does not grant it. */
+declare const MemoryScope: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/MemoryScope">;
+type MemoryScope = typeof MemoryScope.Type;
+declare const MemoryKeyWire_base: Schema.Class<MemoryKeyWire, Schema.Struct<{
+  readonly namespace: Schema.Struct<{
+    readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+  }>;
+  readonly id: Schema.NonEmptyString;
+}>, {}>;
+/** A host-selected namespace prevents accidental cross-tenant document lookup. */
+declare class MemoryKeyWire extends MemoryKeyWire_base {}
+type MemoryKey<Namespace extends Any = Any> = Omit<MemoryKeyWire, "namespace"> & {
+  readonly namespace: Namespace;
+};
+declare const MemoryKey: {
+  Wire: typeof MemoryKeyWire;
+  make: <Namespace extends Any>(fields: MemoryKey<Namespace>) => MemoryKey<Namespace>;
+};
+declare const ActiveMemoryDocumentWire_base: Schema.Class<ActiveMemoryDocumentWire, Schema.TaggedStruct<"ActiveMemoryDocument", {
+  readonly version: Schema.Literal<1>;
+  readonly key: typeof MemoryKeyWire;
+  readonly source: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly locator: Schema.NonEmptyString;
+    readonly revision: Schema.NonEmptyString;
+  }>;
+  readonly generation: Schema.Int;
+  readonly predecessor: Schema.NullOr<typeof MemorySourceReference>;
+  readonly modifiedAt: Schema.Finite;
+  readonly content: typeof MemoryContent;
+  /** Explicit application-defined scope names. Empty grants no recall access. */
+  readonly scopes: Schema.$Array<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/MemoryScope">>;
+}>, {}>;
+declare class ActiveMemoryDocumentWire extends ActiveMemoryDocumentWire_base {}
+declare const WithdrawnMemoryDocumentWire_base: Schema.Class<WithdrawnMemoryDocumentWire, Schema.TaggedStruct<"WithdrawnMemoryDocument", {
+  readonly version: Schema.Literal<1>;
+  readonly key: typeof MemoryKeyWire;
+  readonly source: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly locator: Schema.NonEmptyString;
+    readonly revision: Schema.NonEmptyString;
+  }>;
+  readonly generation: Schema.Int;
+  readonly predecessor: Schema.NullOr<typeof MemorySourceReference>;
+  readonly modifiedAt: Schema.Finite;
+  readonly reason: Schema.String;
+}>, {}>;
+/** Terminal tombstone. Reusing its ID cannot restore the source through delayed work. */
+declare class WithdrawnMemoryDocumentWire extends WithdrawnMemoryDocumentWire_base {}
+type ActiveMemoryDocument<Namespace extends Any = Any> = Omit<ActiveMemoryDocumentWire, "key"> & {
+  readonly key: MemoryKey<Namespace>;
+};
+declare const ActiveMemoryDocument: {
+  Wire: typeof ActiveMemoryDocumentWire;
+  make: <Namespace extends Any>(fields: Omit<ActiveMemoryDocument<Namespace>, "_tag"> & {
+    readonly _tag?: "ActiveMemoryDocument";
+  }) => ActiveMemoryDocument<Namespace>;
+};
+type WithdrawnMemoryDocument<Namespace extends Any = Any> = Omit<WithdrawnMemoryDocumentWire, "key"> & {
+  readonly key: MemoryKey<Namespace>;
+};
+declare const WithdrawnMemoryDocument: {
+  Wire: typeof WithdrawnMemoryDocumentWire;
+  make: <Namespace extends Any>(fields: Omit<WithdrawnMemoryDocument<Namespace>, "_tag"> & {
+    readonly _tag?: "WithdrawnMemoryDocument";
+  }) => WithdrawnMemoryDocument<Namespace>;
+};
+type MemoryDocument<Namespace extends Any = Any> = ActiveMemoryDocument<Namespace> | WithdrawnMemoryDocument<Namespace>;
+declare const MemoryDocument: {
+  Wire: Schema.Union<readonly [typeof ActiveMemoryDocumentWire, typeof WithdrawnMemoryDocumentWire]>;
+  restore: <Namespace extends Any>(namespace: Namespace, input: unknown) => Effect.Effect<MemoryDocument<Namespace>, MemoryStorageError, never>;
+};
+declare const MemoryWriteWire: Schema.Union<readonly [Schema.TaggedStruct<"Put", {
+  readonly key: typeof MemoryKeyWire;
+  readonly operationId: Schema.NonEmptyString;
+  readonly expectedRevision: Schema.NullOr<Schema.NonEmptyString>;
+  readonly locator: Schema.NonEmptyString;
+  readonly content: typeof MemoryContent;
+  readonly scopes: Schema.$Array<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/MemoryScope">>;
+}>, Schema.TaggedStruct<"Withdraw", {
+  readonly key: typeof MemoryKeyWire;
+  readonly operationId: Schema.NonEmptyString;
+  readonly expectedRevision: Schema.NonEmptyString;
+  readonly reason: Schema.String;
+}>]>;
+type MemoryWrite<Namespace extends Any = Any> = (Omit<(typeof MemoryWriteWire.members)[0]["Type"], "key"> | Omit<(typeof MemoryWriteWire.members)[1]["Type"], "key">) & {
+  readonly key: MemoryKey<Namespace>;
+};
+declare const MemoryWrite: {
+  Wire: Schema.Union<readonly [Schema.TaggedStruct<"Put", {
+    readonly key: typeof MemoryKeyWire;
+    readonly operationId: Schema.NonEmptyString;
+    readonly expectedRevision: Schema.NullOr<Schema.NonEmptyString>;
+    readonly locator: Schema.NonEmptyString;
+    readonly content: typeof MemoryContent;
+    readonly scopes: Schema.$Array<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/MemoryScope">>;
+  }>, Schema.TaggedStruct<"Withdraw", {
+    readonly key: typeof MemoryKeyWire;
+    readonly operationId: Schema.NonEmptyString;
+    readonly expectedRevision: Schema.NonEmptyString;
+    readonly reason: Schema.String;
+  }>]>;
+  make: <Namespace extends Any>(fields: MemoryWrite<Namespace>) => MemoryWrite<Namespace>;
+};
+declare const MemoryConflict_base: Schema.Class<MemoryConflict, Schema.TaggedStruct<"MemoryConflict", {
+  readonly key: typeof MemoryKeyWire;
+  readonly expectedRevision: Schema.NullOr<Schema.NonEmptyString>;
+  readonly actualRevision: Schema.NullOr<Schema.NonEmptyString>;
+}>, import("effect/Cause").YieldableError>;
+declare class MemoryConflict extends MemoryConflict_base {}
+declare const MemoryWithdrawn_base: Schema.Class<MemoryWithdrawn, Schema.TaggedStruct<"MemoryWithdrawn", {
+  readonly key: typeof MemoryKeyWire;
+  readonly revision: Schema.NonEmptyString;
+}>, import("effect/Cause").YieldableError>;
+declare class MemoryWithdrawn extends MemoryWithdrawn_base {}
+declare const MemoryOperationConflict_base: Schema.Class<MemoryOperationConflict, Schema.TaggedStruct<"MemoryOperationConflict", {
+  readonly key: typeof MemoryKeyWire;
+  readonly operationId: Schema.NonEmptyString;
+}>, import("effect/Cause").YieldableError>;
+declare class MemoryOperationConflict extends MemoryOperationConflict_base {}
+declare const MemoryStorageError_base: Schema.Class<MemoryStorageError, Schema.TaggedStruct<"MemoryStorageError", {
+  readonly operation: Schema.NonEmptyString;
+  readonly reason: Schema.Literals<readonly ["invalid-input", "unavailable", "corrupt", "incompatible"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class MemoryStorageError extends MemoryStorageError_base {}
+declare const MemoryMutationPoint: Schema.Literals<readonly ["memory:initialize:before", "memory:initialize:before-accounting", "memory:initialize:after-accounting", "memory:initialize:after", "memory:change:before", "memory:change:after-state", "memory:change:after-receipt", "memory:change:after"]>;
+type MemoryMutationPoint = typeof MemoryMutationPoint.Type;
+declare const MemoryMutationFailure_base: Schema.Class<MemoryMutationFailure, Schema.TaggedStruct<"MemoryMutationFailure", {
+  readonly point: Schema.Literals<readonly ["memory:initialize:before", "memory:initialize:before-accounting", "memory:initialize:after-accounting", "memory:initialize:after", "memory:change:before", "memory:change:after-state", "memory:change:after-receipt", "memory:change:after"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class MemoryMutationFailure extends MemoryMutationFailure_base {}
+declare const MemoryMutationFailpoint_base: Context.ServiceClass<MemoryMutationFailpoint, "@effect-agent/core/MemoryMutationFailpoint", {
+  readonly hit: (point: MemoryMutationPoint) => Effect.Effect<void, MemoryMutationFailure>;
+}>;
+/** Explicit fault-injection seam; production adapters install the no-op Layer. */
+declare class MemoryMutationFailpoint extends MemoryMutationFailpoint_base {
+  static readonly layer: Layer.Layer<MemoryMutationFailpoint, never, never>;
+}
+type MemoryWriteError = MemoryStorageError | MemoryConflict | MemoryWithdrawn | MemoryOperationConflict | MemoryMutationFailure;
+declare const MemoryReader_base: Context.ServiceClass<MemoryReader, "@effect-agent/core/MemoryReader", {
+  readonly get: <Namespace extends Any>(key: MemoryKey<Namespace>) => Effect.Effect<MemoryDocument<Namespace> | null, MemoryStorageError>;
+}>;
+/**
+ * Read capability independent of editing. A get begun after a committed write must observe
+ * that write or a later revision. An adapter unable to provide that view must fail typed.
+ * Host code binds namespace and access scope; cached candidates do not implement this port.
+ */
+declare class MemoryReader extends MemoryReader_base {
+  static fromAdapter(adapter: {
+    readonly get: (key: MemoryKey) => Effect.Effect<MemoryDocument | null, MemoryStorageError>;
+  }): MemoryReader["Service"];
+}
+declare const MemoryWriter_base: Context.ServiceClass<MemoryWriter, "@effect-agent/core/MemoryWriter", {
+  readonly change: <Namespace extends Any>(write: MemoryWrite<Namespace>) => Effect.Effect<MemoryDocument<Namespace>, MemoryWriteError>;
+}>;
+/**
+ * Optional conditional writer. Implement only where atomic expected-revision checks and
+ * durable idempotency receipts can be guaranteed. Apply authorization before calling it.
+ * Reconcile an existing operation receipt before evaluating tombstones or expected revisions:
+ * identical commands return the original result; changed commands fail MemoryOperationConflict.
+ * Original results include content, even for a historical Put replayed after withdrawal;
+ * replay does not change the current head. Revalidate a source before using recalled content.
+ * A failed acknowledgement can hide a committed change: retain and retry the exact command.
+ * Successful withdrawal excludes checks begun afterward; already captured views may finish.
+ * Receipts and original Thread history are separate retention concerns.
+ */
+declare class MemoryWriter extends MemoryWriter_base {
+  static fromAdapter(adapter: {
+    readonly change: (write: MemoryWrite) => Effect.Effect<MemoryDocument, MemoryWriteError>;
+  }): MemoryWriter["Service"];
+}
+/**
+ * Transition mechanics for an authoritative document store. Revisions identify this readable
+ * source, not the original activity from which a consumer extracted it. The adapter reconciles
+ * receipts first and owns atomicity and the clock. Original evidence belongs in provenance.
+ */
+declare const applyMemoryWrite: <Namespace extends Any>(current: MemoryDocument<NoInfer<Namespace>> | null, write: MemoryWrite<Namespace>, modifiedAt: number) => Effect.Effect<MemoryDocument<Namespace>, MemoryConflict | MemoryStorageError | MemoryWithdrawn, never>;
+//#endregion
+export { ActiveMemoryDocument, MemoryConflict, MemoryDocument, MemoryKey, MemoryMutationFailpoint, MemoryMutationFailure, MemoryMutationPoint, MemoryOperationConflict, MemoryReader, MemoryScope, MemoryStorageError, MemoryWithdrawn, MemoryWrite, MemoryWriteError, MemoryWriter, WithdrawnMemoryDocument, applyMemoryWrite, MemoryStore_d_exports as t };
+//# sourceMappingURL=MemoryStore.d.mts.map

package/dist/core/MemoryStore.mjs

@@ -0,0 +1,243 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { MemoryContent, MemorySourceReference } from "./MemoryReference.mjs";
+import { Any, equals } from "./MemoryNamespace.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+//#region src/core/MemoryStore.ts
+var MemoryStore_exports = /* @__PURE__ */ __exportAll({
+	ActiveMemoryDocument: () => ActiveMemoryDocument,
+	MemoryConflict: () => MemoryConflict,
+	MemoryDocument: () => MemoryDocument,
+	MemoryKey: () => MemoryKey,
+	MemoryMutationFailpoint: () => MemoryMutationFailpoint,
+	MemoryMutationFailure: () => MemoryMutationFailure,
+	MemoryMutationPoint: () => MemoryMutationPoint,
+	MemoryOperationConflict: () => MemoryOperationConflict,
+	MemoryReader: () => MemoryReader,
+	MemoryScope: () => MemoryScope,
+	MemoryStorageError: () => MemoryStorageError,
+	MemoryWithdrawn: () => MemoryWithdrawn,
+	MemoryWrite: () => MemoryWrite,
+	MemoryWriter: () => MemoryWriter,
+	WithdrawnMemoryDocument: () => WithdrawnMemoryDocument,
+	applyMemoryWrite: () => applyMemoryWrite
+});
+const Identity = Schema.NonEmptyString.check(Schema.isMaxLength(1024));
+const Timestamp = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0));
+/** Host-defined recall visibility label. A scope identifies access policy; it does not grant it. */
+const MemoryScope = Identity.pipe(Schema.brand("@effect-agent/core/MemoryScope"));
+/** A host-selected namespace prevents accidental cross-tenant document lookup. */
+var MemoryKeyWire = class extends Schema.Class("@effect-agent/core/MemoryKey")({
+	namespace: Any,
+	id: MemorySourceReference.fields.id
+}) {};
+const MemoryKey = {
+	Wire: MemoryKeyWire,
+	make: (fields) => Object.assign(Schema.decodeUnknownSync(MemoryKeyWire)(fields), { namespace: fields.namespace })
+};
+const KnownSource = Schema.Struct({
+	...MemorySourceReference.fields,
+	revision: Identity
+});
+const AccessScopes = Schema.Array(MemoryScope).check(Schema.isMaxLength(128), Schema.makeFilter((scopes) => new Set(scopes).size === scopes.length, { expected: "unique access scopes" }));
+const DocumentFields = {
+	version: Schema.Literal(1),
+	key: MemoryKey.Wire,
+	source: KnownSource,
+	generation: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: Number.MAX_SAFE_INTEGER
+	})),
+	predecessor: Schema.NullOr(MemorySourceReference),
+	modifiedAt: Timestamp
+};
+var ActiveMemoryDocumentWire = class extends Schema.TaggedClass()("ActiveMemoryDocument", {
+	...DocumentFields,
+	content: MemoryContent,
+	/** Explicit application-defined scope names. Empty grants no recall access. */
+	scopes: AccessScopes
+}) {};
+/** Terminal tombstone. Reusing its ID cannot restore the source through delayed work. */
+var WithdrawnMemoryDocumentWire = class extends Schema.TaggedClass()("WithdrawnMemoryDocument", {
+	...DocumentFields,
+	reason: Schema.String.check(Schema.isMaxLength(4096))
+}) {};
+const ActiveMemoryDocument = {
+	Wire: ActiveMemoryDocumentWire,
+	make: (fields) => Object.assign(Schema.decodeUnknownSync(ActiveMemoryDocumentWire)({
+		_tag: "ActiveMemoryDocument",
+		...fields
+	}), { key: MemoryKey.make(fields.key) })
+};
+const WithdrawnMemoryDocument = {
+	Wire: WithdrawnMemoryDocumentWire,
+	make: (fields) => Object.assign(Schema.decodeUnknownSync(WithdrawnMemoryDocumentWire)({
+		_tag: "WithdrawnMemoryDocument",
+		...fields
+	}), { key: MemoryKey.make(fields.key) })
+};
+const MemoryDocument = {
+	Wire: Schema.Union([ActiveMemoryDocument.Wire, WithdrawnMemoryDocument.Wire]),
+	restore: Effect.fn("MemoryDocument.restore")(function* (namespace, input) {
+		const document = yield* Schema.decodeUnknownEffect(MemoryDocument.Wire)(input).pipe(Effect.mapError(() => MemoryStorageError.make({
+			operation: "restore memory document",
+			reason: "corrupt"
+		})));
+		if (!equals(namespace, document.key.namespace)) return yield* MemoryStorageError.make({
+			operation: "restore memory namespace",
+			reason: "corrupt"
+		});
+		const key = MemoryKey.make({
+			...document.key,
+			namespace
+		});
+		return document._tag === "ActiveMemoryDocument" ? ActiveMemoryDocument.make({
+			...document,
+			key
+		}) : WithdrawnMemoryDocument.make({
+			...document,
+			key
+		});
+	})
+};
+const WriteFields = {
+	key: MemoryKey.Wire,
+	/** The same operation ID must always carry exactly the same Schema-encoded command. */
+	operationId: Identity
+};
+const MemoryWriteWire = Schema.Union([Schema.TaggedStruct("Put", {
+	...WriteFields,
+	expectedRevision: Schema.NullOr(Identity),
+	locator: MemorySourceReference.fields.locator,
+	content: MemoryContent,
+	scopes: AccessScopes
+}), Schema.TaggedStruct("Withdraw", {
+	...WriteFields,
+	expectedRevision: Identity,
+	reason: WithdrawnMemoryDocument.Wire.fields.reason
+})]);
+const MemoryWrite = {
+	Wire: MemoryWriteWire,
+	make: (fields) => Object.assign(Schema.decodeUnknownSync(MemoryWriteWire)(fields), { key: MemoryKey.make(fields.key) })
+};
+var MemoryConflict = class extends Schema.TaggedError()("MemoryConflict", {
+	key: MemoryKey.Wire,
+	expectedRevision: Schema.NullOr(Identity),
+	actualRevision: Schema.NullOr(Identity)
+}) {};
+var MemoryWithdrawn = class extends Schema.TaggedError()("MemoryWithdrawn", {
+	key: MemoryKey.Wire,
+	revision: Identity
+}) {};
+var MemoryOperationConflict = class extends Schema.TaggedError()("MemoryOperationConflict", {
+	key: MemoryKey.Wire,
+	operationId: Identity
+}) {};
+var MemoryStorageError = class extends Schema.TaggedError()("MemoryStorageError", {
+	operation: Schema.NonEmptyString,
+	reason: Schema.Literals([
+		"invalid-input",
+		"unavailable",
+		"corrupt",
+		"incompatible"
+	])
+}) {};
+const MemoryMutationPoint = Schema.Literals([
+	"memory:initialize:before",
+	"memory:initialize:before-accounting",
+	"memory:initialize:after-accounting",
+	"memory:initialize:after",
+	"memory:change:before",
+	"memory:change:after-state",
+	"memory:change:after-receipt",
+	"memory:change:after"
+]);
+var MemoryMutationFailure = class extends Schema.TaggedError()("MemoryMutationFailure", { point: MemoryMutationPoint }) {};
+/** Explicit fault-injection seam; production adapters install the no-op Layer. */
+var MemoryMutationFailpoint = class extends Context.Service()("@effect-agent/core/MemoryMutationFailpoint") {
+	static layer = Layer.succeed(this, { hit: () => Effect.void });
+};
+/**
+* Read capability independent of editing. A get begun after a committed write must observe
+* that write or a later revision. An adapter unable to provide that view must fail typed.
+* Host code binds namespace and access scope; cached candidates do not implement this port.
+*/
+var MemoryReader = class extends Context.Service()("@effect-agent/core/MemoryReader") {
+	static fromAdapter(adapter) {
+		return { get: Effect.fn("MemoryReader.get")(function* (key) {
+			const document = yield* adapter.get(key);
+			return document === null ? null : yield* MemoryDocument.restore(key.namespace, document);
+		}) };
+	}
+};
+/**
+* Optional conditional writer. Implement only where atomic expected-revision checks and
+* durable idempotency receipts can be guaranteed. Apply authorization before calling it.
+* Reconcile an existing operation receipt before evaluating tombstones or expected revisions:
+* identical commands return the original result; changed commands fail MemoryOperationConflict.
+* Original results include content, even for a historical Put replayed after withdrawal;
+* replay does not change the current head. Revalidate a source before using recalled content.
+* A failed acknowledgement can hide a committed change: retain and retry the exact command.
+* Successful withdrawal excludes checks begun afterward; already captured views may finish.
+* Receipts and original Thread history are separate retention concerns.
+*/
+var MemoryWriter = class extends Context.Service()("@effect-agent/core/MemoryWriter") {
+	static fromAdapter(adapter) {
+		return { change: Effect.fn("MemoryWriter.change")(function* (write) {
+			const document = yield* adapter.change(write);
+			return yield* MemoryDocument.restore(write.key.namespace, document);
+		}) };
+	}
+};
+/**
+* Transition mechanics for an authoritative document store. Revisions identify this readable
+* source, not the original activity from which a consumer extracted it. The adapter reconciles
+* receipts first and owns atomicity and the clock. Original evidence belongs in provenance.
+*/
+const applyMemoryWrite = Effect.fn("applyMemoryWrite")(function* (current, write, modifiedAt) {
+	if (current !== null && (!equals(current.key.namespace, write.key.namespace) || current.key.id !== write.key.id || current.source.id !== write.key.id)) return yield* MemoryStorageError.make({
+		operation: "memory transition identity",
+		reason: "corrupt"
+	});
+	if (current?._tag === "WithdrawnMemoryDocument") return yield* MemoryWithdrawn.make({
+		key: write.key,
+		revision: current.source.revision
+	});
+	const actualRevision = current?.source.revision ?? null;
+	if (actualRevision !== write.expectedRevision) return yield* MemoryConflict.make({
+		key: write.key,
+		expectedRevision: write.expectedRevision,
+		actualRevision
+	});
+	const generation = (current?.generation ?? 0) + 1;
+	const fields = {
+		version: 1,
+		key: write.key,
+		source: {
+			id: write.key.id,
+			locator: write._tag === "Put" ? write.locator : current?.source.locator ?? "",
+			revision: String(generation)
+		},
+		generation,
+		predecessor: current?.source ?? null,
+		modifiedAt
+	};
+	const next = write._tag === "Put" ? {
+		_tag: "ActiveMemoryDocument",
+		...fields,
+		content: write.content,
+		scopes: write.scopes
+	} : {
+		_tag: "WithdrawnMemoryDocument",
+		...fields,
+		reason: write.reason
+	};
+	const document = yield* Schema.decodeUnknownEffect(MemoryDocument.Wire)(next).pipe(Effect.mapError(() => MemoryStorageError.make({
+		operation: "memory transition",
+		reason: "invalid-input"
+	})));
+	return yield* MemoryDocument.restore(write.key.namespace, document);
+});
+//#endregion
+export { ActiveMemoryDocument, MemoryConflict, MemoryDocument, MemoryKey, MemoryMutationFailpoint, MemoryMutationFailure, MemoryMutationPoint, MemoryOperationConflict, MemoryReader, MemoryScope, MemoryStorageError, MemoryWithdrawn, MemoryWrite, MemoryWriter, WithdrawnMemoryDocument, applyMemoryWrite, MemoryStore_exports as t };
+
+//# sourceMappingURL=MemoryStore.mjs.map

package/dist/core/MemoryStore.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryStore.mjs","names":["MemoryNamespace.Any","MemoryNamespace.equals"],"sources":["../../src/core/MemoryStore.ts"],"sourcesContent":["import { Context, Effect, Layer, Schema } from \"effect\";\n\nimport * as MemoryNamespace from \"./MemoryNamespace.ts\";\nimport { MemoryContent, MemorySourceReference } from \"./MemoryReference.ts\";\n\nconst Identity = Schema.NonEmptyString.check(Schema.isMaxLength(1_024));\nconst Timestamp = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0));\n\n/** Host-defined recall visibility label. A scope identifies access policy; it does not grant it. */\nexport const MemoryScope = Identity.pipe(Schema.brand(\"@effect-agent/core/MemoryScope\"));\nexport type MemoryScope = typeof MemoryScope.Type;\n\n/** A host-selected namespace prevents accidental cross-tenant document lookup. */\nclass MemoryKeyWire extends Schema.Class<MemoryKeyWire>(\"@effect-agent/core/MemoryKey\")({\n  namespace: MemoryNamespace.Any,\n  id: MemorySourceReference.fields.id,\n}) {}\n\nexport type MemoryKey<Namespace extends MemoryNamespace.Any = MemoryNamespace.Any> = Omit<\n  MemoryKeyWire,\n  \"namespace\"\n> & { readonly namespace: Namespace };\n\nexport const MemoryKey = {\n  Wire: MemoryKeyWire,\n  make: <Namespace extends MemoryNamespace.Any>(\n    fields: MemoryKey<Namespace>,\n  ): MemoryKey<Namespace> =>\n    Object.assign(Schema.decodeUnknownSync(MemoryKeyWire)(fields), { namespace: fields.namespace }),\n};\n\nconst KnownSource = Schema.Struct({\n  ...MemorySourceReference.fields,\n  revision: Identity,\n});\n\nconst AccessScopes = Schema.Array(MemoryScope).check(\n  Schema.isMaxLength(128),\n  Schema.makeFilter((scopes) => new Set(scopes).size === scopes.length, {\n    expected: \"unique access scopes\",\n  }),\n);\n\nconst DocumentFields = {\n  version: Schema.Literal(1),\n  key: MemoryKey.Wire,\n  source: KnownSource,\n  generation: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER })),\n  predecessor: Schema.NullOr(MemorySourceReference),\n  modifiedAt: Timestamp,\n};\n\nclass ActiveMemoryDocumentWire extends Schema.TaggedClass<ActiveMemoryDocumentWire>()(\n  \"ActiveMemoryDocument\",\n  {\n    ...DocumentFields,\n    content: MemoryContent,\n    /** Explicit application-defined scope names. Empty grants no recall access. */\n    scopes: AccessScopes,\n  },\n) {}\n\n/** Terminal tombstone. Reusing its ID cannot restore the source through delayed work. */\nclass WithdrawnMemoryDocumentWire extends Schema.TaggedClass<WithdrawnMemoryDocumentWire>()(\n  \"WithdrawnMemoryDocument\",\n  {\n    ...DocumentFields,\n    reason: Schema.String.check(Schema.isMaxLength(4_096)),\n  },\n) {}\n\nexport type ActiveMemoryDocument<Namespace extends MemoryNamespace.Any = MemoryNamespace.Any> =\n  Omit<ActiveMemoryDocumentWire, \"key\"> & { readonly key: MemoryKey<Namespace> };\n\nexport const ActiveMemoryDocument = {\n  Wire: ActiveMemoryDocumentWire,\n  make: <Namespace extends MemoryNamespace.Any>(\n    fields: Omit<ActiveMemoryDocument<Namespace>, \"_tag\"> & {\n      readonly _tag?: \"ActiveMemoryDocument\";\n    },\n  ): ActiveMemoryDocument<Namespace> =>\n    Object.assign(\n      Schema.decodeUnknownSync(ActiveMemoryDocumentWire)({\n        _tag: \"ActiveMemoryDocument\",\n        ...fields,\n      }),\n      { key: MemoryKey.make(fields.key) },\n    ),\n};\n\nexport type WithdrawnMemoryDocument<Namespace extends MemoryNamespace.Any = MemoryNamespace.Any> =\n  Omit<WithdrawnMemoryDocumentWire, \"key\"> & { readonly key: MemoryKey<Namespace> };\n\nexport const WithdrawnMemoryDocument = {\n  Wire: WithdrawnMemoryDocumentWire,\n  make: <Namespace extends MemoryNamespace.Any>(\n    fields: Omit<WithdrawnMemoryDocument<Namespace>, \"_tag\"> & {\n      readonly _tag?: \"WithdrawnMemoryDocument\";\n    },\n  ): WithdrawnMemoryDocument<Namespace> =>\n    Object.assign(\n      Schema.decodeUnknownSync(WithdrawnMemoryDocumentWire)({\n        _tag: \"WithdrawnMemoryDocument\",\n        ...fields,\n      }),\n      { key: MemoryKey.make(fields.key) },\n    ),\n};\n\nexport type MemoryDocument<Namespace extends MemoryNamespace.Any = MemoryNamespace.Any> =\n  | ActiveMemoryDocument<Namespace>\n  | WithdrawnMemoryDocument<Namespace>;\n\nexport const MemoryDocument = {\n  Wire: Schema.Union([ActiveMemoryDocument.Wire, WithdrawnMemoryDocument.Wire]),\n  restore: Effect.fn(\"MemoryDocument.restore\")(function* <Namespace extends MemoryNamespace.Any>(\n    namespace: Namespace,\n    input: unknown,\n  ): Effect.fn.Return<MemoryDocument<Namespace>, MemoryStorageError> {\n    const document = yield* Schema.decodeUnknownEffect(MemoryDocument.Wire)(input).pipe(\n      Effect.mapError(() =>\n        MemoryStorageError.make({ operation: \"restore memory document\", reason: \"corrupt\" }),\n      ),\n    );\n\n    if (!MemoryNamespace.equals(namespace, document.key.namespace))\n      return yield* MemoryStorageError.make({\n        operation: \"restore memory namespace\",\n        reason: \"corrupt\",\n      });\n    const key = MemoryKey.make({ ...document.key, namespace });\n\n    return document._tag === \"ActiveMemoryDocument\"\n      ? ActiveMemoryDocument.make({ ...document, key })\n      : WithdrawnMemoryDocument.make({ ...document, key });\n  }),\n};\n\nconst WriteFields = {\n  key: MemoryKey.Wire,\n  /** The same operation ID must always carry exactly the same Schema-encoded command. */\n  operationId: Identity,\n};\n\nconst MemoryWriteWire = Schema.Union([\n  Schema.TaggedStruct(\"Put\", {\n    ...WriteFields,\n    expectedRevision: Schema.NullOr(Identity),\n    locator: MemorySourceReference.fields.locator,\n    content: MemoryContent,\n    scopes: AccessScopes,\n  }),\n  Schema.TaggedStruct(\"Withdraw\", {\n    ...WriteFields,\n    expectedRevision: Identity,\n    reason: WithdrawnMemoryDocument.Wire.fields.reason,\n  }),\n]);\n\nexport type MemoryWrite<Namespace extends MemoryNamespace.Any = MemoryNamespace.Any> = (\n  | Omit<(typeof MemoryWriteWire.members)[0][\"Type\"], \"key\">\n  | Omit<(typeof MemoryWriteWire.members)[1][\"Type\"], \"key\">\n) & { readonly key: MemoryKey<Namespace> };\n\nexport const MemoryWrite = {\n  Wire: MemoryWriteWire,\n  make: <Namespace extends MemoryNamespace.Any>(\n    fields: MemoryWrite<Namespace>,\n  ): MemoryWrite<Namespace> =>\n    Object.assign(Schema.decodeUnknownSync(MemoryWriteWire)(fields), {\n      key: MemoryKey.make(fields.key),\n    }),\n};\n\nexport class MemoryConflict extends Schema.TaggedError<MemoryConflict>()(\"MemoryConflict\", {\n  key: MemoryKey.Wire,\n  expectedRevision: Schema.NullOr(Identity),\n  actualRevision: Schema.NullOr(Identity),\n}) {}\n\nexport class MemoryWithdrawn extends Schema.TaggedError<MemoryWithdrawn>()(\"MemoryWithdrawn\", {\n  key: MemoryKey.Wire,\n  revision: Identity,\n}) {}\n\nexport class MemoryOperationConflict extends Schema.TaggedError<MemoryOperationConflict>()(\n  \"MemoryOperationConflict\",\n  {\n    key: MemoryKey.Wire,\n    operationId: Identity,\n  },\n) {}\n\nexport class MemoryStorageError extends Schema.TaggedError<MemoryStorageError>()(\n  \"MemoryStorageError\",\n  {\n    operation: Schema.NonEmptyString,\n    reason: Schema.Literals([\"invalid-input\", \"unavailable\", \"corrupt\", \"incompatible\"]),\n  },\n) {}\n\nexport const MemoryMutationPoint = Schema.Literals([\n  \"memory:initialize:before\",\n  \"memory:initialize:before-accounting\",\n  \"memory:initialize:after-accounting\",\n  \"memory:initialize:after\",\n  \"memory:change:before\",\n  \"memory:change:after-state\",\n  \"memory:change:after-receipt\",\n  \"memory:change:after\",\n]);\n\nexport type MemoryMutationPoint = typeof MemoryMutationPoint.Type;\n\nexport class MemoryMutationFailure extends Schema.TaggedError<MemoryMutationFailure>()(\n  \"MemoryMutationFailure\",\n  {\n    point: MemoryMutationPoint,\n  },\n) {}\n\n/** Explicit fault-injection seam; production adapters install the no-op Layer. */\nexport class MemoryMutationFailpoint extends Context.Service<\n  MemoryMutationFailpoint,\n  {\n    readonly hit: (point: MemoryMutationPoint) => Effect.Effect<void, MemoryMutationFailure>;\n  }\n>()(\"@effect-agent/core/MemoryMutationFailpoint\") {\n  static readonly layer = Layer.succeed(this, { hit: () => Effect.void });\n}\n\nexport type MemoryWriteError =\n  | MemoryStorageError\n  | MemoryConflict\n  | MemoryWithdrawn\n  | MemoryOperationConflict\n  | MemoryMutationFailure;\n\n/**\n * Read capability independent of editing. A get begun after a committed write must observe\n * that write or a later revision. An adapter unable to provide that view must fail typed.\n * Host code binds namespace and access scope; cached candidates do not implement this port.\n */\nexport class MemoryReader extends Context.Service<\n  MemoryReader,\n  {\n    readonly get: <Namespace extends MemoryNamespace.Any>(\n      key: MemoryKey<Namespace>,\n    ) => Effect.Effect<MemoryDocument<Namespace> | null, MemoryStorageError>;\n  }\n>()(\"@effect-agent/core/MemoryReader\") {\n  static fromAdapter(adapter: {\n    readonly get: (key: MemoryKey) => Effect.Effect<MemoryDocument | null, MemoryStorageError>;\n  }): MemoryReader[\"Service\"] {\n    return {\n      get: Effect.fn(\"MemoryReader.get\")(function* <Namespace extends MemoryNamespace.Any>(\n        key: MemoryKey<Namespace>,\n      ) {\n        const document = yield* adapter.get(key);\n\n        return document === null ? null : yield* MemoryDocument.restore(key.namespace, document);\n      }),\n    };\n  }\n}\n\n/**\n * Optional conditional writer. Implement only where atomic expected-revision checks and\n * durable idempotency receipts can be guaranteed. Apply authorization before calling it.\n * Reconcile an existing operation receipt before evaluating tombstones or expected revisions:\n * identical commands return the original result; changed commands fail MemoryOperationConflict.\n * Original results include content, even for a historical Put replayed after withdrawal;\n * replay does not change the current head. Revalidate a source before using recalled content.\n * A failed acknowledgement can hide a committed change: retain and retry the exact command.\n * Successful withdrawal excludes checks begun afterward; already captured views may finish.\n * Receipts and original Thread history are separate retention concerns.\n */\nexport class MemoryWriter extends Context.Service<\n  MemoryWriter,\n  {\n    readonly change: <Namespace extends MemoryNamespace.Any>(\n      write: MemoryWrite<Namespace>,\n    ) => Effect.Effect<MemoryDocument<Namespace>, MemoryWriteError>;\n  }\n>()(\"@effect-agent/core/MemoryWriter\") {\n  static fromAdapter(adapter: {\n    readonly change: (write: MemoryWrite) => Effect.Effect<MemoryDocument, MemoryWriteError>;\n  }): MemoryWriter[\"Service\"] {\n    return {\n      change: Effect.fn(\"MemoryWriter.change\")(function* <Namespace extends MemoryNamespace.Any>(\n        write: MemoryWrite<Namespace>,\n      ) {\n        const document = yield* adapter.change(write);\n\n        return yield* MemoryDocument.restore(write.key.namespace, document);\n      }),\n    };\n  }\n}\n\n/**\n * Transition mechanics for an authoritative document store. Revisions identify this readable\n * source, not the original activity from which a consumer extracted it. The adapter reconciles\n * receipts first and owns atomicity and the clock. Original evidence belongs in provenance.\n */\nexport const applyMemoryWrite = Effect.fn(\"applyMemoryWrite\")(function* <\n  Namespace extends MemoryNamespace.Any,\n>(\n  current: MemoryDocument<NoInfer<Namespace>> | null,\n  write: MemoryWrite<Namespace>,\n  modifiedAt: number,\n) {\n  if (\n    current !== null &&\n    (!MemoryNamespace.equals(current.key.namespace, write.key.namespace) ||\n      current.key.id !== write.key.id ||\n      current.source.id !== write.key.id)\n  ) {\n    return yield* MemoryStorageError.make({\n      operation: \"memory transition identity\",\n      reason: \"corrupt\",\n    });\n  }\n  if (current?._tag === \"WithdrawnMemoryDocument\") {\n    return yield* MemoryWithdrawn.make({ key: write.key, revision: current.source.revision });\n  }\n  const actualRevision = current?.source.revision ?? null;\n\n  if (actualRevision !== write.expectedRevision) {\n    return yield* MemoryConflict.make({\n      key: write.key,\n      expectedRevision: write.expectedRevision,\n      actualRevision,\n    });\n  }\n  const generation = (current?.generation ?? 0) + 1;\n\n  const fields = {\n    version: 1 as const,\n    key: write.key,\n    source: {\n      id: write.key.id,\n      locator: write._tag === \"Put\" ? write.locator : (current?.source.locator ?? \"\"),\n      revision: String(generation),\n    },\n    generation,\n    predecessor: current?.source ?? null,\n    modifiedAt,\n  };\n\n  const next =\n    write._tag === \"Put\"\n      ? {\n          _tag: \"ActiveMemoryDocument\" as const,\n          ...fields,\n          content: write.content,\n          scopes: write.scopes,\n        }\n      : { _tag: \"WithdrawnMemoryDocument\" as const, ...fields, reason: write.reason };\n\n  const document = yield* Schema.decodeUnknownEffect(MemoryDocument.Wire)(next).pipe(\n    Effect.mapError(() =>\n      MemoryStorageError.make({ operation: \"memory transition\", reason: \"invalid-input\" }),\n    ),\n  );\n\n  return yield* MemoryDocument.restore(write.key.namespace, document);\n});\n"],"mappings":"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"}

package/dist/core/Receipt.d.mts

@@ -0,0 +1,2 @@
+import { a as Receipt, i as QueueSequence, n as JoinedToHost, r as Principal, t as IdempotencyKey } from "../Receipt-BAHyigAF.mjs";
+export { IdempotencyKey, JoinedToHost, Principal, QueueSequence, Receipt };