effect-agent 0.0.1-beta.6 → 0.1.0-beta.100

package/dist/core/SemanticMemoryIndex.d.mts

@@ -0,0 +1,826 @@
+import { i as MemoryNamespace_d_exports, t as Any } from "../MemoryNamespace-BbRW5p71.mjs";
+import { MemoryKey } from "./MemoryStore.mjs";
+import { Context, Effect, Schema } from "effect";
+declare namespace SemanticMemoryIndex_d_exports {
+  export { MemoryIndexCandidate, MemoryIndexError, MemoryIndexQuery, MemoryIndexReplacement, MemoryIndexSearch, MemoryIndexSource, SemanticMemoryChunk, SemanticMemoryIndex, SemanticMemoryProfile };
+}
+declare const SemanticMemoryProfile_base: Schema.Class<SemanticMemoryProfile, Schema.Struct<{
+  readonly version: Schema.Literal<1>;
+  readonly provider: Schema.NonEmptyString;
+  readonly model: Schema.NonEmptyString;
+  readonly modelRevision: Schema.NonEmptyString;
+  readonly dimensions: Schema.Int;
+  readonly chunker: Schema.Literal<"utf8-codepoint@1">;
+  readonly maxChunkBytes: Schema.Int;
+  readonly distance: Schema.Literal<"cosine">;
+}>, {}>;
+/** A host declaration of the exact embedding space and deterministic chunking policy. */
+export declare class SemanticMemoryProfile extends SemanticMemoryProfile_base {}
+declare const SemanticMemoryChunk_base: Schema.Class<SemanticMemoryChunk, Schema.Struct<{
+  readonly passageId: Schema.NonEmptyString;
+  readonly ordinal: Schema.Int;
+  readonly startByte: Schema.Natural;
+  readonly endByte: Schema.Natural;
+  readonly text: Schema.NonEmptyString;
+  readonly vector: Schema.$Array<Schema.Finite>;
+}>, {}>;
+export declare class SemanticMemoryChunk extends SemanticMemoryChunk_base {}
+declare const MemoryIndexSourceWire_base: Schema.Class<MemoryIndexSourceWire, Schema.Struct<{
+  key: {
+    new (props: {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, options?: Schema.MakeOptions | undefined): {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    };
+    pipe<A>(this: A): A;
+    pipe<A, B = never>(this: A, ab: (_: A) => B): B;
+    pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
+    pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
+    pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
+    pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N): N;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O): O;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P): P;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q): Q;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R): R;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S): S;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T): T;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
+    readonly Rebuild: Schema.decodeTo<Schema.declareConstructor<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, {
+      readonly namespace: {
+        readonly address: string;
+      };
+      readonly id: string;
+    }, readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>], {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>, Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>, never, never>;
+    readonly "~effect/Schema/Schema": "~effect/Schema/Schema";
+    readonly ast: import("effect/SchemaAST").Declaration;
+    readonly "~type.parameters": readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>];
+    readonly "~type.constructor.default": "no-default";
+    readonly "~type.mutability": "readonly";
+    readonly "~type.optionality": "required";
+    readonly "~encoded.mutability": "readonly";
+    readonly "~encoded.optionality": "required";
+    annotate(annotations: Schema.Annotations.Bottom<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>]>): Schema.decodeTo<Schema.declareConstructor<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, {
+      readonly namespace: {
+        readonly address: string;
+      };
+      readonly id: string;
+    }, readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>], {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>, Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>, never, never>;
+    annotateKey(annotations: Schema.Annotations.Key<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>): Schema.decodeTo<Schema.declareConstructor<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, {
+      readonly namespace: {
+        readonly address: string;
+      };
+      readonly id: string;
+    }, readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>], {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>, Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>, never, never>;
+    check(checks_0: import("effect/SchemaAST").Check<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>, ...checks: import("effect/SchemaAST").Check<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>[]): Schema.decodeTo<Schema.declareConstructor<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, {
+      readonly namespace: {
+        readonly address: string;
+      };
+      readonly id: string;
+    }, readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>], {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>, Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>, never, never>;
+    rebuild(ast: import("effect/SchemaAST").Declaration): Schema.decodeTo<Schema.declareConstructor<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, {
+      readonly namespace: {
+        readonly address: string;
+      };
+      readonly id: string;
+    }, readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>], {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>, Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>, never, never>;
+    make(input: {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, options?: Schema.MakeOptions): {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    };
+    makeOption(input: {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, options?: Schema.MakeOptions): import("effect/Option").Option<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>;
+    makeEffect(input: {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, options?: Schema.MakeOptions): Effect.Effect<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, import("effect/SchemaIssue").Issue, never>;
+    readonly Type: {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    };
+    readonly Encoded: {
+      readonly namespace: {
+        readonly address: string;
+      };
+      readonly id: string;
+    };
+    readonly DecodingServices: never;
+    readonly EncodingServices: never;
+    readonly "~type.make.in": {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    };
+    readonly "~type.make": {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    };
+    readonly Iso: {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    };
+    readonly identifier: string;
+    readonly fields: {
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    };
+    mapFields<To extends Schema.Struct.Fields>(f: (fields: {
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }) => To, options?: {
+      readonly unsafePreserveChecks?: boolean | undefined;
+    } | undefined): Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
+    extend<Extended = never, Static = {}, Brand = {}>(identifier: string): {
+      <NewFields extends Schema.Struct.Fields>(fields: NewFields, annotations?: Schema.Annotations.Declaration<Extended, readonly [Schema.Struct<((("id" | "namespace") & keyof NewFields extends never ? {
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      } & NewFields : Omit<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }, ("id" | "namespace") & keyof NewFields> & NewFields) extends (infer T_1) ? { [K in keyof T_1]: T_1[K]; } : never) extends (infer T) ? { [K in keyof T]: T[K]; } : never>]> | undefined): [Extended] extends [never] ? "Missing `Self` generic - use `class Self extends Base.extend<Self>(...)`" : Schema.Class<Extended, Schema.Struct<((("id" | "namespace") & keyof NewFields extends never ? {
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      } & NewFields : Omit<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }, ("id" | "namespace") & keyof NewFields> & NewFields) extends (infer T_1) ? { [K in keyof T_1]: T_1[K]; } : never) extends (infer T) ? { [K in keyof T]: T[K]; } : never>, {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      } & Brand> & Pick<Static, Exclude<keyof Static, keyof Schema.Class<Extended_1, Schema.Struct<((keyof S["fields"] & keyof NewFields_1 extends never ? S["fields"] & NewFields_1 : Omit<S["fields"], keyof S["fields"] & keyof NewFields_1> & NewFields_1) extends (infer T_3) ? { [K in keyof T_3]: T_3[K]; } : never) extends (infer T_2) ? { [K in keyof T_2]: T_2[K]; } : never>, Self & Brand_1>>>;
+      <Extension extends Schema.Struct<Schema.Struct.Fields>>(schema: Extension, annotations?: Schema.Annotations.Declaration<Extended, readonly [Schema.Struct<((("id" | "namespace") & keyof Extension["fields"] extends never ? {
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      } & Extension["fields"] : Omit<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }, ("id" | "namespace") & keyof Extension["fields"]> & Extension["fields"]) extends (infer T_1) ? { [K in keyof T_1]: T_1[K]; } : never) extends (infer T) ? { [K in keyof T]: T[K]; } : never>]> | undefined): [Extended] extends [never] ? "Missing `Self` generic - use `class Self extends Base.extend<Self>(...)`" : Schema.Class<Extended, Schema.Struct<((("id" | "namespace") & keyof Extension["fields"] extends never ? {
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      } & Extension["fields"] : Omit<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }, ("id" | "namespace") & keyof Extension["fields"]> & Extension["fields"]) extends (infer T_1) ? { [K in keyof T_1]: T_1[K]; } : never) extends (infer T) ? { [K in keyof T]: T[K]; } : never>, {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      } & Brand> & Pick<Static, Exclude<keyof Static, keyof Schema.Class<Extended_1, Schema.Struct<((keyof S["fields"] & keyof Extension_1["fields"] extends never ? S["fields"] & Extension_1["fields"] : Omit<S["fields"], keyof S["fields"] & keyof Extension_1["fields"]> & Extension_1["fields"]) extends (infer T_3) ? { [K in keyof T_3]: T_3[K]; } : never) extends (infer T_2) ? { [K in keyof T_2]: T_2[K]; } : never>, Self & Brand_1>>>;
+    };
+  };
+  source: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly locator: Schema.NonEmptyString;
+    readonly revision: Schema.NonEmptyString;
+  }>;
+  sourceGeneration: Schema.Int;
+}>, {}>;
+declare class MemoryIndexSourceWire extends MemoryIndexSourceWire_base {}
+export type MemoryIndexSource<Namespace extends Any = Any> = Omit<MemoryIndexSourceWire, "key"> & {
+  readonly key: MemoryKey<Namespace>;
+};
+export declare const MemoryIndexSource: {
+  Wire: typeof MemoryIndexSourceWire;
+  make: <Namespace extends Any>(fields: MemoryIndexSource<Namespace>) => MemoryIndexSource<Namespace>;
+};
+declare const MemoryIndexReplacementWire_base: Schema.Class<MemoryIndexReplacementWire, Schema.Struct<{
+  readonly source: typeof MemoryIndexSourceWire;
+  readonly profile: typeof SemanticMemoryProfile;
+  readonly chunks: Schema.$Array<typeof SemanticMemoryChunk>;
+}>, {}>;
+/** A complete replacement, prepared before touching the disposable index. */
+declare class MemoryIndexReplacementWire extends MemoryIndexReplacementWire_base {}
+export type MemoryIndexReplacement<Namespace extends Any = Any> = Omit<MemoryIndexReplacementWire, "source"> & {
+  readonly source: MemoryIndexSource<Namespace>;
+};
+export declare const MemoryIndexReplacement: {
+  Wire: typeof MemoryIndexReplacementWire;
+  make: <Namespace extends Any>(fields: MemoryIndexReplacement<Namespace>) => MemoryIndexReplacement<Namespace>;
+};
+declare const MemoryIndexCandidateWire_base: Schema.Class<MemoryIndexCandidateWire, Schema.Struct<{
+  readonly key: {
+    new (props: {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, options?: Schema.MakeOptions | undefined): {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    };
+    pipe<A>(this: A): A;
+    pipe<A, B = never>(this: A, ab: (_: A) => B): B;
+    pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
+    pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
+    pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
+    pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N): N;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O): O;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P): P;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q): Q;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R): R;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S): S;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T): T;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
+    readonly Rebuild: Schema.decodeTo<Schema.declareConstructor<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, {
+      readonly namespace: {
+        readonly address: string;
+      };
+      readonly id: string;
+    }, readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>], {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>, Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>, never, never>;
+    readonly "~effect/Schema/Schema": "~effect/Schema/Schema";
+    readonly ast: import("effect/SchemaAST").Declaration;
+    readonly "~type.parameters": readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>];
+    readonly "~type.constructor.default": "no-default";
+    readonly "~type.mutability": "readonly";
+    readonly "~type.optionality": "required";
+    readonly "~encoded.mutability": "readonly";
+    readonly "~encoded.optionality": "required";
+    annotate(annotations: Schema.Annotations.Bottom<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>]>): Schema.decodeTo<Schema.declareConstructor<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, {
+      readonly namespace: {
+        readonly address: string;
+      };
+      readonly id: string;
+    }, readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>], {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>, Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>, never, never>;
+    annotateKey(annotations: Schema.Annotations.Key<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>): Schema.decodeTo<Schema.declareConstructor<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, {
+      readonly namespace: {
+        readonly address: string;
+      };
+      readonly id: string;
+    }, readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>], {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>, Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>, never, never>;
+    check(checks_0: import("effect/SchemaAST").Check<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>, ...checks: import("effect/SchemaAST").Check<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>[]): Schema.decodeTo<Schema.declareConstructor<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, {
+      readonly namespace: {
+        readonly address: string;
+      };
+      readonly id: string;
+    }, readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>], {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>, Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>, never, never>;
+    rebuild(ast: import("effect/SchemaAST").Declaration): Schema.decodeTo<Schema.declareConstructor<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, {
+      readonly namespace: {
+        readonly address: string;
+      };
+      readonly id: string;
+    }, readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>], {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>, Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>, never, never>;
+    make(input: {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, options?: Schema.MakeOptions): {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    };
+    makeOption(input: {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, options?: Schema.MakeOptions): import("effect/Option").Option<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>;
+    makeEffect(input: {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, options?: Schema.MakeOptions): Effect.Effect<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, import("effect/SchemaIssue").Issue, never>;
+    readonly Type: {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    };
+    readonly Encoded: {
+      readonly namespace: {
+        readonly address: string;
+      };
+      readonly id: string;
+    };
+    readonly DecodingServices: never;
+    readonly EncodingServices: never;
+    readonly "~type.make.in": {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    };
+    readonly "~type.make": {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    };
+    readonly Iso: {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    };
+    readonly identifier: string;
+    readonly fields: {
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    };
+    mapFields<To extends Schema.Struct.Fields>(f: (fields: {
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }) => To, options?: {
+      readonly unsafePreserveChecks?: boolean | undefined;
+    } | undefined): Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
+    extend<Extended = never, Static = {}, Brand = {}>(identifier: string): {
+      <NewFields extends Schema.Struct.Fields>(fields: NewFields, annotations?: Schema.Annotations.Declaration<Extended, readonly [Schema.Struct<((("id" | "namespace") & keyof NewFields extends never ? {
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      } & NewFields : Omit<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }, ("id" | "namespace") & keyof NewFields> & NewFields) extends (infer T_1) ? { [K in keyof T_1]: T_1[K]; } : never) extends (infer T) ? { [K in keyof T]: T[K]; } : never>]> | undefined): [Extended] extends [never] ? "Missing `Self` generic - use `class Self extends Base.extend<Self>(...)`" : Schema.Class<Extended, Schema.Struct<((("id" | "namespace") & keyof NewFields extends never ? {
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      } & NewFields : Omit<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }, ("id" | "namespace") & keyof NewFields> & NewFields) extends (infer T_1) ? { [K in keyof T_1]: T_1[K]; } : never) extends (infer T) ? { [K in keyof T]: T[K]; } : never>, {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      } & Brand> & Pick<Static, Exclude<keyof Static, keyof Schema.Class<Extended_1, Schema.Struct<((keyof S["fields"] & keyof NewFields_1 extends never ? S["fields"] & NewFields_1 : Omit<S["fields"], keyof S["fields"] & keyof NewFields_1> & NewFields_1) extends (infer T_3) ? { [K in keyof T_3]: T_3[K]; } : never) extends (infer T_2) ? { [K in keyof T_2]: T_2[K]; } : never>, Self & Brand_1>>>;
+      <Extension extends Schema.Struct<Schema.Struct.Fields>>(schema: Extension, annotations?: Schema.Annotations.Declaration<Extended, readonly [Schema.Struct<((("id" | "namespace") & keyof Extension["fields"] extends never ? {
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      } & Extension["fields"] : Omit<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }, ("id" | "namespace") & keyof Extension["fields"]> & Extension["fields"]) extends (infer T_1) ? { [K in keyof T_1]: T_1[K]; } : never) extends (infer T) ? { [K in keyof T]: T[K]; } : never>]> | undefined): [Extended] extends [never] ? "Missing `Self` generic - use `class Self extends Base.extend<Self>(...)`" : Schema.Class<Extended, Schema.Struct<((("id" | "namespace") & keyof Extension["fields"] extends never ? {
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      } & Extension["fields"] : Omit<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }, ("id" | "namespace") & keyof Extension["fields"]> & Extension["fields"]) extends (infer T_1) ? { [K in keyof T_1]: T_1[K]; } : never) extends (infer T) ? { [K in keyof T]: T[K]; } : never>, {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      } & Brand> & Pick<Static, Exclude<keyof Static, keyof Schema.Class<Extended_1, Schema.Struct<((keyof S["fields"] & keyof Extension_1["fields"] extends never ? S["fields"] & Extension_1["fields"] : Omit<S["fields"], keyof S["fields"] & keyof Extension_1["fields"]> & Extension_1["fields"]) extends (infer T_3) ? { [K in keyof T_3]: T_3[K]; } : never) extends (infer T_2) ? { [K in keyof T_2]: T_2[K]; } : never>, Self & Brand_1>>>;
+    };
+  };
+  readonly source: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly locator: Schema.NonEmptyString;
+    readonly revision: Schema.NonEmptyString;
+  }>;
+  readonly sourceGeneration: Schema.Int;
+  readonly passageId: Schema.NonEmptyString;
+  readonly ordinal: Schema.Int;
+  readonly startByte: Schema.Natural;
+  readonly endByte: Schema.Natural;
+  readonly text: Schema.NonEmptyString;
+  readonly score: Schema.Finite;
+  readonly indexedAt: Schema.Finite;
+}>, {}>;
+declare class MemoryIndexCandidateWire extends MemoryIndexCandidateWire_base {}
+export type MemoryIndexCandidate<Namespace extends Any = Any> = Omit<MemoryIndexCandidateWire, "key"> & {
+  readonly key: MemoryKey<Namespace>;
+};
+export declare const MemoryIndexCandidate: {
+  Wire: typeof MemoryIndexCandidateWire;
+  make: <Namespace extends Any>(fields: MemoryIndexCandidate<Namespace>) => MemoryIndexCandidate<Namespace>;
+};
+declare const MemoryIndexQueryWire_base: Schema.Class<MemoryIndexQueryWire, Schema.Struct<{
+  readonly namespace: Schema.Struct<{
+    readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+  }>;
+  readonly vector: Schema.$Array<Schema.Finite>;
+  readonly limit: Schema.Int;
+  readonly minScore: Schema.Finite;
+  readonly maxScannedChunks: Schema.Int;
+}>, {}>;
+declare class MemoryIndexQueryWire extends MemoryIndexQueryWire_base {}
+export type MemoryIndexQuery<Namespace extends Any = Any> = Omit<MemoryIndexQueryWire, "namespace"> & {
+  readonly namespace: Namespace;
+};
+export declare const MemoryIndexQuery: {
+  Wire: typeof MemoryIndexQueryWire;
+  make: <Namespace extends Any>(fields: MemoryIndexQuery<Namespace>) => MemoryIndexQuery<Namespace>;
+};
+declare const MemoryIndexSearchWire_base: Schema.Class<MemoryIndexSearchWire, Schema.Struct<{
+  readonly candidates: Schema.$Array<typeof MemoryIndexCandidateWire>;
+  readonly scannedChunks: Schema.Natural;
+}>, {}>;
+declare class MemoryIndexSearchWire extends MemoryIndexSearchWire_base {}
+export type MemoryIndexSearch<Namespace extends Any = Any> = Omit<MemoryIndexSearchWire, "candidates"> & {
+  readonly candidates: ReadonlyArray<MemoryIndexCandidate<Namespace>>;
+};
+export declare const MemoryIndexSearch: {
+  Wire: typeof MemoryIndexSearchWire;
+  make: <Namespace extends Any>(fields: MemoryIndexSearch<Namespace>) => MemoryIndexSearch<Namespace>;
+};
+declare const MemoryIndexError_base: Schema.Class<MemoryIndexError, Schema.TaggedStruct<"MemoryIndexError", {
+  readonly operation: Schema.NonEmptyString;
+  readonly reason: Schema.Literals<readonly ["invalid-input", "unavailable", "corrupt", "incompatible", "fenced", "budget"]>;
+}>, import("effect/Cause").YieldableError>;
+export declare class MemoryIndexError extends MemoryIndexError_base {}
+declare const SemanticMemoryIndex_base: Context.ServiceClass<SemanticMemoryIndex, "@effect-agent/core/SemanticMemoryIndex", {
+  readonly profile: SemanticMemoryProfile;
+  readonly replace: <Namespace extends Any>(request: MemoryIndexReplacement<Namespace>) => Effect.Effect<void, MemoryIndexError>;
+  readonly withdraw: <Namespace extends Any>(source: MemoryIndexSource<Namespace>) => Effect.Effect<void, MemoryIndexError>;
+  readonly search: <Namespace extends Any>(query: MemoryIndexQuery<Namespace>) => Effect.Effect<MemoryIndexSearch<Namespace>, MemoryIndexError>;
+}>;
+/**
+ * Optional disposable ranking index with one fixed embedding/chunking profile.
+ * replace validates a complete replacement before atomically exchanging chunks. Failure leaves
+ * the last successful index intact. Older generations and divergent same-generation source
+ * identities are fenced; refreshing the same source is allowed. Source IDs must equal key IDs.
+ * withdraw retains a terminal tombstone that fences every later replacement for that key.
+ *
+ * Vectors match the profile dimensions and have positive finite squared norms. Chunks form a
+ * nonempty contiguous ordinal/byte sequence starting at zero, with unique passage IDs and exact
+ * UTF-8 byte ranges bounded by maxChunkBytes. Implementations snapshot mutable caller values.
+ *
+ * Bounded adapters count every source key, including tombstones, against capacity. Replacement
+ * capacity is measured after removing the old chunks. Search rejects scans over maxScannedChunks
+ * instead of ranking a truncated prefix. scannedChunks counts all indexed chunks in the namespace
+ * before threshold/limit. Ties sort by source ID, revision, then ordinal in UTF-16 code-unit order.
+ * Scope close clears the index and makes captured methods fail unavailable.
+ *
+ * Search is ranking only: callers MUST recheck authoritative revision, access, and withdrawal.
+ * This port tracks no builds, extraction progress, or corpus completeness. The host owns source
+ * discovery, refresh scheduling, and required freshness.
+ */
+export declare class SemanticMemoryIndex extends SemanticMemoryIndex_base {
+  static fromAdapter(adapter: {
+    readonly profile: SemanticMemoryProfile;
+    readonly replace: (request: MemoryIndexReplacement) => Effect.Effect<void, MemoryIndexError>;
+    readonly withdraw: (source: MemoryIndexSource) => Effect.Effect<void, MemoryIndexError>;
+    readonly search: (query: MemoryIndexQuery) => Effect.Effect<MemoryIndexSearch, MemoryIndexError>;
+  }): SemanticMemoryIndex["Service"];
+}
+//#endregion
+export { SemanticMemoryIndex_d_exports as t };
+//# sourceMappingURL=SemanticMemoryIndex.d.mts.map