arborkit 1.0.0

package/dist/registry-validator.d.ts

@@ -0,0 +1,15 @@
+import { Validator } from './mutator.js';
+import { TypeRegistry } from './type-registry.js';
+import './types.js';
+import './clock.js';
+import './artifact-tree.js';
+import './ids.js';
+import './decompose.js';
+import './addressing.js';
+import './event-log.js';
+import './errors.js';
+
+/** Build a Mutator `Validator` that runs the registered `validate()` for the node's type. */
+declare function makeRegistryValidator(registry: TypeRegistry): Validator;
+
+export { makeRegistryValidator };

package/dist/registry-validator.js

@@ -0,0 +1,11 @@
+// src/registry-validator.ts
+function makeRegistryValidator(registry) {
+  return ({ proposed, type }) => {
+    if (type === void 0) return;
+    registry.get(type)?.validate?.(proposed);
+  };
+}
+export {
+  makeRegistryValidator
+};
+//# sourceMappingURL=registry-validator.js.map

package/dist/registry-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/registry-validator.ts"],"sourcesContent":["import type { Validator } from \"./mutator\";\r\nimport type { TypeRegistry } from \"./type-registry\";\r\n\r\n/** Build a Mutator `Validator` that runs the registered `validate()` for the node's type. */\r\nexport function makeRegistryValidator(registry: TypeRegistry): Validator {\r\n  return ({ proposed, type }) => {\r\n    if (type === undefined) return;\r\n    registry.get(type)?.validate?.(proposed);\r\n  };\r\n}\r\n"],"mappings":";AAIO,SAAS,sBAAsB,UAAmC;AACvE,SAAO,CAAC,EAAE,UAAU,KAAK,MAAM;AAC7B,QAAI,SAAS,OAAW;AACxB,aAAS,IAAI,IAAI,GAAG,WAAW,QAAQ;AAAA,EACzC;AACF;","names":[]}

package/dist/replay.d.ts

@@ -0,0 +1,38 @@
+import { Json } from './types.js';
+import { ArtifactTree } from './artifact-tree.js';
+import { Addressing } from './addressing.js';
+import { EventLog, MutationEvent } from './event-log.js';
+import { Mutator } from './mutator.js';
+import { Ref } from './errors.js';
+import './ids.js';
+import './clock.js';
+import './decompose.js';
+
+/** Value-level time-travel over the reversible event-log. */
+declare class Replay {
+    private readonly tree;
+    private readonly log;
+    constructor(tree: ArtifactTree, log: EventLog);
+    /** The whole artifact's JSON value as of `version` (0 = initial, log.length = current).
+     *  Throws if `version` is below the compaction floor (that history was dropped). */
+    reconstructValueAt(version: number): Json;
+    /** The value at JSON Pointer `path` as of `version`, or undefined if absent then. */
+    getAt(path: string, version: number): Json | undefined;
+    /** The mutations applied between version `vA` (inclusive) and `vB` (exclusive).
+     *  Events compacted away are not included. */
+    diff(vA: number, vB: number): MutationEvent[];
+    /** The node's {type, tags} as of `version`, by scanning later events on its path.
+     *  Move-aware: if the version-`version` occupant was moved away, follow it to its
+     *  new path and keep scanning — its type/tags travel with it. If the scan exhausts
+     *  on a FOLLOWED path, the occupant is the live node there — read it directly
+     *  ("keep current" would read whatever now sits at the original path).
+     *  type: string | null (untyped/absent) | undefined (unknown — keep current).
+     *  tags: string[] ([] = untagged) | undefined (unknown/pre-M14 — keep current).
+     *  Limitation (same as pre-M14): array-index paths can mis-resolve across sibling
+     *  index shifts; exact for object paths. */
+    private stateAt;
+    /** Restore the node at `ref` to its value, type, AND tags as of `toVersion`, as a new live mutation. */
+    revert(mutator: Mutator, addressing: Addressing, ref: Ref, toVersion: number): void;
+}
+
+export { Replay };

package/dist/replay.js

@@ -0,0 +1,183 @@
+// src/errors.ts
+var ArborError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = new.target.name;
+  }
+  code;
+};
+var InvalidOpError = class extends ArborError {
+  constructor(message) {
+    super("INVALID_OP", message);
+  }
+};
+
+// src/jsonpointer.ts
+function decodeSegment(s) {
+  return s.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function parsePointer(pointer) {
+  if (pointer === "") return [];
+  if (!pointer.startsWith("/")) {
+    throw new Error(`Invalid JSON Pointer (must be "" or start with "/"): ${pointer}`);
+  }
+  return pointer.slice(1).split("/").map(decodeSegment);
+}
+
+// src/json-edit.ts
+function getAtPath(value, pointer) {
+  const segs = parsePointer(pointer);
+  let cur = value;
+  for (const seg of segs) {
+    if (Array.isArray(cur)) {
+      const i = Number(seg);
+      cur = Number.isInteger(i) && i >= 0 && i < cur.length ? cur[i] : void 0;
+    } else if (cur !== null && typeof cur === "object") {
+      cur = seg in cur ? cur[seg] : void 0;
+    } else {
+      return void 0;
+    }
+    if (cur === void 0) return void 0;
+  }
+  return cur;
+}
+function navParent(root, pointer) {
+  const segs = parsePointer(pointer);
+  if (segs.length === 0) return void 0;
+  let cur = root;
+  for (let i = 0; i < segs.length - 1; i++) {
+    const seg = segs[i];
+    if (Array.isArray(cur)) cur = cur[Number(seg)];
+    else if (cur !== null && typeof cur === "object") cur = cur[seg];
+    else return void 0;
+    if (cur === void 0 || cur === null) return void 0;
+  }
+  return { parent: cur, key: segs[segs.length - 1] };
+}
+function setAtPathMut(value, pointer, newVal) {
+  if (pointer === "") return newVal;
+  const pk = navParent(value, pointer);
+  if (!pk || pk.parent === null || typeof pk.parent !== "object") return value;
+  if (Array.isArray(pk.parent)) pk.parent[Number(pk.key)] = newVal;
+  else pk.parent[pk.key] = newVal;
+  return value;
+}
+function removeAtPathMut(value, pointer) {
+  if (pointer === "") return null;
+  const pk = navParent(value, pointer);
+  if (!pk || pk.parent === null || typeof pk.parent !== "object") return value;
+  if (Array.isArray(pk.parent)) pk.parent.splice(Number(pk.key), 1);
+  else delete pk.parent[pk.key];
+  return value;
+}
+function insertAtPathMut(value, pointer, val) {
+  if (pointer === "") return val;
+  const pk = navParent(value, pointer);
+  if (!pk || pk.parent === null || typeof pk.parent !== "object") return value;
+  if (Array.isArray(pk.parent)) pk.parent.splice(Number(pk.key), 0, val);
+  else pk.parent[pk.key] = val;
+  return value;
+}
+
+// src/replay.ts
+function reverseApplyValue(value, e) {
+  switch (e.kind) {
+    case "set":
+      return e.path === void 0 ? value : setAtPathMut(value, e.path, structuredClone(e.before ?? null));
+    case "insert":
+      return e.path === void 0 ? value : removeAtPathMut(value, e.path);
+    case "remove":
+      return e.path === void 0 ? value : insertAtPathMut(value, e.path, structuredClone(e.before ?? null));
+    case "move": {
+      if (e.toPath === void 0 || e.fromPath === void 0) return value;
+      const moved = getAtPath(value, e.toPath) ?? null;
+      const withoutMoved = removeAtPathMut(value, e.toPath);
+      return insertAtPathMut(withoutMoved, e.fromPath, moved);
+    }
+  }
+}
+var Replay = class {
+  constructor(tree, log) {
+    this.tree = tree;
+    this.log = log;
+  }
+  tree;
+  log;
+  /** The whole artifact's JSON value as of `version` (0 = initial, log.length = current).
+   *  Throws if `version` is below the compaction floor (that history was dropped). */
+  reconstructValueAt(version) {
+    const total = this.log.length();
+    const floor = this.log.baseSeqValue();
+    if (version < floor) {
+      throw new InvalidOpError(`cannot reconstruct version ${version}: history before ${floor} was compacted`);
+    }
+    const target = Math.min(version, total);
+    let value = structuredClone(this.tree.toJson());
+    for (let seq = total - 1; seq >= target; seq--) {
+      value = reverseApplyValue(value, this.log.at(seq));
+    }
+    return value;
+  }
+  /** The value at JSON Pointer `path` as of `version`, or undefined if absent then. */
+  getAt(path, version) {
+    return getAtPath(this.reconstructValueAt(version), path);
+  }
+  /** The mutations applied between version `vA` (inclusive) and `vB` (exclusive).
+   *  Events compacted away are not included. */
+  diff(vA, vB) {
+    return this.log.since(vA).filter((e) => e.seq < vB);
+  }
+  /** The node's {type, tags} as of `version`, by scanning later events on its path.
+   *  Move-aware: if the version-`version` occupant was moved away, follow it to its
+   *  new path and keep scanning — its type/tags travel with it. If the scan exhausts
+   *  on a FOLLOWED path, the occupant is the live node there — read it directly
+   *  ("keep current" would read whatever now sits at the original path).
+   *  type: string | null (untyped/absent) | undefined (unknown — keep current).
+   *  tags: string[] ([] = untagged) | undefined (unknown/pre-M14 — keep current).
+   *  Limitation (same as pre-M14): array-index paths can mis-resolve across sibling
+   *  index shifts; exact for object paths. */
+  stateAt(path, version, addressing) {
+    const total = this.log.length();
+    let p = path;
+    for (let seq = Math.max(version, this.log.baseSeqValue()); seq < total; seq++) {
+      const e = this.log.at(seq);
+      if (e.kind === "move") {
+        if (e.fromPath === p) {
+          p = e.toPath ?? p;
+          continue;
+        }
+        if (e.toPath === p) return { type: null, tags: [] };
+        continue;
+      }
+      if (e.path !== p) continue;
+      if (e.kind === "set" || e.kind === "remove") {
+        return {
+          type: e.nodeTypeBefore === void 0 ? void 0 : e.nodeTypeBefore,
+          tags: e.tagsBefore
+          // absent (pre-M14) → undefined = keep current
+        };
+      }
+      if (e.kind === "insert") return { type: null, tags: [] };
+    }
+    if (p !== path) {
+      const live = addressing.byPath(p);
+      return { type: live?.type ?? null, tags: live?.tags ?? [] };
+    }
+    return { type: void 0, tags: void 0 };
+  }
+  /** Restore the node at `ref` to its value, type, AND tags as of `toVersion`, as a new live mutation. */
+  revert(mutator, addressing, ref, toVersion) {
+    const path = "id" in ref ? addressing.pathOf(ref.id) : ref.path;
+    const past = this.getAt(path, toVersion);
+    const { type, tags } = this.stateAt(path, toVersion, addressing);
+    const opts = {};
+    if (type !== void 0) opts.type = type;
+    if (tags !== void 0) opts.tags = tags;
+    mutator.set({ path }, past ?? null, opts);
+  }
+};
+export {
+  Replay
+};
+//# sourceMappingURL=replay.js.map

package/dist/replay.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts","../src/jsonpointer.ts","../src/json-edit.ts","../src/replay.ts"],"sourcesContent":["import type { NodeId } from \"./types\";\r\n\r\n/** A reference to a node: by stable id or by JSON Pointer path. */\r\nexport type Ref = { id: NodeId } | { path: string };\r\n\r\nexport class ArborError extends Error {\r\n  constructor(\r\n    public readonly code: string,\r\n    message: string,\r\n  ) {\r\n    super(message);\r\n    this.name = new.target.name;\r\n  }\r\n}\r\n\r\nexport class NodeNotFoundError extends ArborError {\r\n  constructor(public readonly ref: Ref) {\r\n    super(\"NODE_NOT_FOUND\", `Node not found: ${JSON.stringify(ref)}`);\r\n  }\r\n}\r\n\r\nexport class ScopeViolationError extends ArborError {\r\n  constructor(\r\n    public readonly targetPath: string,\r\n    public readonly scope: string,\r\n  ) {\r\n    super(\"SCOPE_VIOLATION\", `Access outside scope: ${targetPath} (scope: ${scope})`);\r\n  }\r\n}\r\n\r\nexport class StaleVersionError extends ArborError {\r\n  constructor(\r\n    public readonly id: NodeId,\r\n    public readonly expected: number,\r\n    public readonly actual: number,\r\n  ) {\r\n    super(\"STALE_VERSION\", `Stale version for ${id}: expected ${expected}, actual ${actual}`);\r\n  }\r\n}\r\n\r\nexport class InvalidOpError extends ArborError {\r\n  constructor(message: string) {\r\n    super(\"INVALID_OP\", message);\r\n  }\r\n}\r\n\r\nexport class ValidationError extends ArborError {\r\n  constructor(\r\n    public readonly type: string | undefined,\r\n    public readonly details: string,\r\n  ) {\r\n    super(\"VALIDATION_ERROR\", `Validation failed${type ? ` for type ${type}` : \"\"}: ${details}`);\r\n  }\r\n}\r\n","/** Escape a single reference token per RFC 6901: ~ -> ~0, / -> ~1. */\r\nexport function encodeSegment(s: string): string {\r\n  return s.replace(/~/g, \"~0\").replace(/\\//g, \"~1\");\r\n}\r\n\r\n/** Unescape a single reference token per RFC 6901: ~1 -> /, then ~0 -> ~. */\r\nexport function decodeSegment(s: string): string {\r\n  return s.replace(/~1/g, \"/\").replace(/~0/g, \"~\");\r\n}\r\n\r\n/** Build a JSON Pointer string. Empty segment list => \"\" (root). */\r\nexport function buildPointer(segments: ReadonlyArray<string | number>): string {\r\n  if (segments.length === 0) return \"\";\r\n  return \"/\" + segments.map((s) => encodeSegment(String(s))).join(\"/\");\r\n}\r\n\r\n/** Append one child key to a parent pointer, escaping the key exactly as `buildPointer` does. */\r\nexport function appendPointer(parent: string, key: string | number): string {\r\n  return parent + \"/\" + encodeSegment(String(key));\r\n}\r\n\r\n/** True when `path` is at or under `scope` (JSON Pointer prefix). Undefined scope = everywhere. */\r\nexport function isWithin(path: string, scope: string | undefined): boolean {\r\n  return scope === undefined || path === scope || path.startsWith(scope + \"/\");\r\n}\r\n\r\n/** Parse a JSON Pointer into decoded segments. \"\" => [] (root). */\r\nexport function parsePointer(pointer: string): string[] {\r\n  if (pointer === \"\") return [];\r\n  if (!pointer.startsWith(\"/\")) {\r\n    throw new Error(`Invalid JSON Pointer (must be \"\" or start with \"/\"): ${pointer}`);\r\n  }\r\n  return pointer.slice(1).split(\"/\").map(decodeSegment);\r\n}\r\n","import type { Json } from \"./types\";\r\nimport { parsePointer } from \"./jsonpointer\";\r\n\r\n/** Read the value at a JSON Pointer, or undefined if any segment is missing. */\r\nexport function getAtPath(value: Json, pointer: string): Json | undefined {\r\n  const segs = parsePointer(pointer);\r\n  let cur: Json | undefined = value;\r\n  for (const seg of segs) {\r\n    if (Array.isArray(cur)) {\r\n      const i = Number(seg);\r\n      cur = Number.isInteger(i) && i >= 0 && i < cur.length ? cur[i] : undefined;\r\n    } else if (cur !== null && typeof cur === \"object\") {\r\n      cur = seg in cur ? (cur as Record<string, Json>)[seg] : undefined;\r\n    } else {\r\n      return undefined;\r\n    }\r\n    if (cur === undefined) return undefined;\r\n  }\r\n  return cur;\r\n}\r\n\r\n/** Navigate (within `root`) to the container holding the pointer's last segment. */\r\nfunction navParent(root: Json, pointer: string): { parent: Json; key: string } | undefined {\r\n  const segs = parsePointer(pointer);\r\n  if (segs.length === 0) return undefined;\r\n  let cur: Json | undefined = root;\r\n  for (let i = 0; i < segs.length - 1; i++) {\r\n    const seg = segs[i];\r\n    if (Array.isArray(cur)) cur = cur[Number(seg)];\r\n    else if (cur !== null && typeof cur === \"object\") cur = (cur as Record<string, Json>)[seg];\r\n    else return undefined;\r\n    if (cur === undefined || cur === null) return undefined;\r\n  }\r\n  return { parent: cur, key: segs[segs.length - 1] };\r\n}\r\n\r\n/** In-place variant of setAtPath: mutates `value` (root pointer returns `newVal`). */\r\nexport function setAtPathMut(value: Json, pointer: string, newVal: Json): Json {\r\n  if (pointer === \"\") return newVal;\r\n  const pk = navParent(value, pointer);\r\n  if (!pk || pk.parent === null || typeof pk.parent !== \"object\") return value;\r\n  if (Array.isArray(pk.parent)) pk.parent[Number(pk.key)] = newVal;\r\n  else (pk.parent as Record<string, Json>)[pk.key] = newVal;\r\n  return value;\r\n}\r\n\r\n/** In-place variant of removeAtPath: mutates `value` (root pointer returns null). */\r\nexport function removeAtPathMut(value: Json, pointer: string): Json {\r\n  if (pointer === \"\") return null;\r\n  const pk = navParent(value, pointer);\r\n  if (!pk || pk.parent === null || typeof pk.parent !== \"object\") return value;\r\n  if (Array.isArray(pk.parent)) pk.parent.splice(Number(pk.key), 1);\r\n  else delete (pk.parent as Record<string, Json>)[pk.key];\r\n  return value;\r\n}\r\n\r\n/** In-place variant of insertAtPath: mutates `value` (root pointer returns `val`). */\r\nexport function insertAtPathMut(value: Json, pointer: string, val: Json): Json {\r\n  if (pointer === \"\") return val;\r\n  const pk = navParent(value, pointer);\r\n  if (!pk || pk.parent === null || typeof pk.parent !== \"object\") return value;\r\n  if (Array.isArray(pk.parent)) pk.parent.splice(Number(pk.key), 0, val);\r\n  else (pk.parent as Record<string, Json>)[pk.key] = val;\r\n  return value;\r\n}\r\n\r\n/** Return a copy of `value` with the value at `pointer` replaced (root → returns `newVal`). */\r\nexport function setAtPath(value: Json, pointer: string, newVal: Json): Json {\r\n  return setAtPathMut(structuredClone(value), pointer, newVal);\r\n}\r\n\r\n/** Return a copy of `value` with the element at `pointer` removed (object delete / array splice). */\r\nexport function removeAtPath(value: Json, pointer: string): Json {\r\n  return removeAtPathMut(structuredClone(value), pointer);\r\n}\r\n\r\n/** Return a copy of `value` with `val` inserted at `pointer` (object set / array splice-in). */\r\nexport function insertAtPath(value: Json, pointer: string, val: Json): Json {\r\n  return insertAtPathMut(structuredClone(value), pointer, val);\r\n}\r\n","import type { Json } from \"./types\";\r\nimport type { ArtifactTree } from \"./artifact-tree\";\r\nimport type { Addressing } from \"./addressing\";\r\nimport type { EventLog, MutationEvent } from \"./event-log\";\r\nimport type { Mutator } from \"./mutator\";\r\nimport { type Ref, InvalidOpError } from \"./errors\";\r\nimport { getAtPath, setAtPathMut, removeAtPathMut, insertAtPathMut } from \"./json-edit\";\r\n\r\n/** Undo a single event on a JSON value IN PLACE (the caller owns `value` — it is the\r\n *  single upfront clone made by `reconstructValueAt`). The spliced-in `before` values\r\n *  are still cloned (M14): they protect the LOG from mutation through the output. */\r\nfunction reverseApplyValue(value: Json, e: MutationEvent): Json {\r\n  switch (e.kind) {\r\n    case \"set\":\r\n      return e.path === undefined ? value : setAtPathMut(value, e.path, structuredClone(e.before ?? null));\r\n    case \"insert\":\r\n      return e.path === undefined ? value : removeAtPathMut(value, e.path);\r\n    case \"remove\":\r\n      return e.path === undefined ? value : insertAtPathMut(value, e.path, structuredClone(e.before ?? null));\r\n    case \"move\": {\r\n      if (e.toPath === undefined || e.fromPath === undefined) return value;\r\n      const moved = getAtPath(value, e.toPath) ?? null;\r\n      const withoutMoved = removeAtPathMut(value, e.toPath);\r\n      return insertAtPathMut(withoutMoved, e.fromPath, moved);\r\n    }\r\n  }\r\n}\r\n\r\n/** Value-level time-travel over the reversible event-log. */\r\nexport class Replay {\r\n  constructor(\r\n    private readonly tree: ArtifactTree,\r\n    private readonly log: EventLog,\r\n  ) {}\r\n\r\n  /** The whole artifact's JSON value as of `version` (0 = initial, log.length = current).\r\n   *  Throws if `version` is below the compaction floor (that history was dropped). */\r\n  reconstructValueAt(version: number): Json {\r\n    const total = this.log.length();\r\n    const floor = this.log.baseSeqValue();\r\n    if (version < floor) {\r\n      throw new InvalidOpError(`cannot reconstruct version ${version}: history before ${floor} was compacted`);\r\n    }\r\n    const target = Math.min(version, total);\r\n    let value: Json = structuredClone(this.tree.toJson());\r\n    for (let seq = total - 1; seq >= target; seq--) {\r\n      value = reverseApplyValue(value, this.log.at(seq)!);\r\n    }\r\n    return value;\r\n  }\r\n\r\n  /** The value at JSON Pointer `path` as of `version`, or undefined if absent then. */\r\n  getAt(path: string, version: number): Json | undefined {\r\n    return getAtPath(this.reconstructValueAt(version), path);\r\n  }\r\n\r\n  /** The mutations applied between version `vA` (inclusive) and `vB` (exclusive).\r\n   *  Events compacted away are not included. */\r\n  diff(vA: number, vB: number): MutationEvent[] {\r\n    return this.log.since(vA).filter((e) => e.seq < vB);\r\n  }\r\n\r\n  /** The node's {type, tags} as of `version`, by scanning later events on its path.\r\n   *  Move-aware: if the version-`version` occupant was moved away, follow it to its\r\n   *  new path and keep scanning — its type/tags travel with it. If the scan exhausts\r\n   *  on a FOLLOWED path, the occupant is the live node there — read it directly\r\n   *  (\"keep current\" would read whatever now sits at the original path).\r\n   *  type: string | null (untyped/absent) | undefined (unknown — keep current).\r\n   *  tags: string[] ([] = untagged) | undefined (unknown/pre-M14 — keep current).\r\n   *  Limitation (same as pre-M14): array-index paths can mis-resolve across sibling\r\n   *  index shifts; exact for object paths. */\r\n  private stateAt(\r\n    path: string,\r\n    version: number,\r\n    addressing: Addressing,\r\n  ): { type: string | null | undefined; tags: string[] | undefined } {\r\n    const total = this.log.length();\r\n    let p = path;\r\n    for (let seq = Math.max(version, this.log.baseSeqValue()); seq < total; seq++) {\r\n      const e = this.log.at(seq)!;\r\n      if (e.kind === \"move\") {\r\n        if (e.fromPath === p) {\r\n          p = e.toPath ?? p; // occupant moved away — follow it\r\n          continue;\r\n        }\r\n        if (e.toPath === p) return { type: null, tags: [] }; // something ELSE moved in → vacant at `version`\r\n        continue;\r\n      }\r\n      if (e.path !== p) continue;\r\n      if (e.kind === \"set\" || e.kind === \"remove\") {\r\n        return {\r\n          type: e.nodeTypeBefore === undefined ? undefined : e.nodeTypeBefore,\r\n          tags: e.tagsBefore, // absent (pre-M14) → undefined = keep current\r\n        };\r\n      }\r\n      if (e.kind === \"insert\") return { type: null, tags: [] }; // node did not exist at `version`\r\n    }\r\n    if (p !== path) {\r\n      // Followed through moves and nothing later touched the occupant: it is the\r\n      // live node at `p` — its type/tags are the version-`version` answer.\r\n      const live = addressing.byPath(p);\r\n      return { type: live?.type ?? null, tags: live?.tags ?? [] };\r\n    }\r\n    return { type: undefined, tags: undefined }; // untouched since `version` — keep current\r\n  }\r\n\r\n  /** Restore the node at `ref` to its value, type, AND tags as of `toVersion`, as a new live mutation. */\r\n  revert(mutator: Mutator, addressing: Addressing, ref: Ref, toVersion: number): void {\r\n    const path = \"id\" in ref ? addressing.pathOf(ref.id) : ref.path;\r\n    const past = this.getAt(path, toVersion);\r\n    const { type, tags } = this.stateAt(path, toVersion, addressing);\r\n    const opts: { type?: string | null; tags?: string[] } = {};\r\n    if (type !== undefined) opts.type = type;\r\n    if (tags !== undefined) opts.tags = tags;\r\n    mutator.set({ path }, past ?? null, opts);\r\n  }\r\n}\r\n"],"mappings":"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","names":[]}

package/dist/semantic-index.d.ts

@@ -0,0 +1,88 @@
+import { ArbNode, NodeId } from './types.js';
+import { ArtifactTree } from './artifact-tree.js';
+import { Addressing } from './addressing.js';
+import { TypeRegistry } from './type-registry.js';
+import { EmbeddingPort } from './embedding-port.js';
+import { VectorIndexPort } from './vector-index-port.js';
+import './ids.js';
+import './clock.js';
+import './decompose.js';
+
+interface SearchOpts {
+    k?: number;
+    under?: string;
+    type?: string;
+    tag?: string;
+    freshness?: "best-effort" | "wait";
+}
+interface SearchHit {
+    id: NodeId;
+    path: string;
+    type?: string;
+    score: number;
+    snippet: string;
+}
+interface SearchResult {
+    results: SearchHit[];
+    staleCount: number;
+}
+/**
+ * Owns the per-node semantic index: a stale queue fed by mutation hooks, an async
+ * batched reindexer, and (Task 6) search. Embedding is never in the mutation path —
+ * mutations only mark stale; reindex does the async embedding work.
+ */
+declare class SemanticIndex {
+    private readonly tree;
+    private readonly addressing;
+    private readonly embedding;
+    private readonly vectors;
+    private readonly registry?;
+    private readonly stale;
+    private readonly pendingRemoval;
+    constructor(tree: ArtifactTree, addressing: Addressing, embedding: EmbeddingPort, vectors: VectorIndexPort, registry?: TypeRegistry | undefined);
+    /** The nearest ancestor whose type declares embedText — the semantic unit that
+     *  owns this shard — or undefined. (O(depth) walk per call — fine at v1 sizes.) */
+    private embedTextAncestor;
+    /**
+     * A node is a suppressed decomposition shard iff some ANCESTOR has a typed
+     * embedText AND the node does not itself declare a typed embedText.
+     */
+    private isSuppressedShard;
+    /** Mutation hook: a node's content changed (set/insert). Marks it stale if its embedding-text changed. */
+    onChange(node: ArbNode): void;
+    /** Mutation hook: a node was removed. Drops it from the index and the stale queue. */
+    onRemove(nodeId: NodeId): void;
+    /**
+     * Snapshot of both queues for transaction rollback.
+     *
+     * The sync hooks (`onChange`, `onRemove`) only move ids between the `stale`
+     * queue and the `pendingRemoval` queue; all actual vector mutations happen in
+     * the async `reindex()`. This snapshot covers both queues so that a rollback
+     * fully restores the observable state of the index without touching vectors.
+     */
+    txSnapshot(): unknown;
+    /** Restore both queues captured by `txSnapshot`. */
+    txRestore(snapshot: unknown): void;
+    /** Convenience: the hooks to wire into `MutatorDeps`. */
+    hooks(): {
+        onChange: (node: ArbNode) => void;
+        onRemove: (nodeId: NodeId) => void;
+        onTxSnapshot: () => unknown;
+        onTxRestore: (snapshot: unknown) => void;
+    };
+    staleCount(): number;
+    /** Embed every stale node (one batch), upsert vectors, mark fresh, clear the processed ids.
+     *  Interleave-safe: mutations landing during the embed await are respected — a node
+     *  removed mid-flight is dropped (never resurrected), and a node whose text changed
+     *  stays queued for the next pass instead of being marked fresh for the old text. */
+    reindex(): Promise<void>;
+    private snippetOf;
+    /**
+     * Semantic search: embed the query, rank indexed nodes by cosine, post-filter by
+     * under/type/tag, return top-k. `freshness: "wait"` flushes the reindexer first;
+     * default `best-effort` searches what's indexed and reports `staleCount`.
+     */
+    search(queryText: string, opts?: SearchOpts): Promise<SearchResult>;
+}
+
+export { type SearchHit, type SearchOpts, type SearchResult, SemanticIndex };

package/dist/semantic-index.js

@@ -0,0 +1,226 @@
+// src/embedding-text.ts
+function toEmbeddingText(node, value, typeDef) {
+  if (typeDef?.embedText) return typeDef.embedText(value);
+  if (node.kind !== "leaf") return null;
+  if (typeof value === "string") return value;
+  if (value !== null && typeof value === "object") return JSON.stringify(value);
+  return null;
+}
+function textHash(text) {
+  let h = 2166136261 >>> 0;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(16);
+}
+
+// src/jsonpointer.ts
+function isWithin(path, scope) {
+  return scope === void 0 || path === scope || path.startsWith(scope + "/");
+}
+
+// src/semantic-index.ts
+var SemanticIndex = class {
+  constructor(tree, addressing, embedding, vectors, registry) {
+    this.tree = tree;
+    this.addressing = addressing;
+    this.embedding = embedding;
+    this.vectors = vectors;
+    this.registry = registry;
+    for (const node of tree.allNodes()) {
+      if (node.meta.embedding.state === "stale") this.stale.add(node.id);
+    }
+  }
+  tree;
+  addressing;
+  embedding;
+  vectors;
+  registry;
+  stale = /* @__PURE__ */ new Set();
+  pendingRemoval = /* @__PURE__ */ new Set();
+  /** The nearest ancestor whose type declares embedText — the semantic unit that
+   *  owns this shard — or undefined. (O(depth) walk per call — fine at v1 sizes.) */
+  embedTextAncestor(node) {
+    let pid = node.parentId;
+    while (pid !== null) {
+      const anc = this.tree.get(pid);
+      const ancDef = anc?.type ? this.registry?.get(anc.type) : void 0;
+      if (ancDef?.embedText) return anc;
+      pid = anc?.parentId ?? null;
+    }
+    return void 0;
+  }
+  /**
+   * A node is a suppressed decomposition shard iff some ANCESTOR has a typed
+   * embedText AND the node does not itself declare a typed embedText.
+   */
+  isSuppressedShard(node) {
+    const ownTypeDef = node.type ? this.registry?.get(node.type) : void 0;
+    if (ownTypeDef?.embedText) return false;
+    return this.embedTextAncestor(node) !== void 0;
+  }
+  /** Mutation hook: a node's content changed (set/insert). Marks it stale if its embedding-text changed. */
+  onChange(node) {
+    if (this.isSuppressedShard(node)) {
+      node.meta.embedding = { state: "none" };
+      this.pendingRemoval.add(node.id);
+      this.stale.delete(node.id);
+      const anc = this.embedTextAncestor(node);
+      if (anc) this.onChange(anc);
+      return;
+    }
+    const value = this.tree.toJson(node.id);
+    const typeDef = node.type ? this.registry?.get(node.type) : void 0;
+    const text = toEmbeddingText(node, value, typeDef);
+    if (text === null) {
+      node.meta.embedding = { state: "none" };
+      this.pendingRemoval.add(node.id);
+      this.stale.delete(node.id);
+      return;
+    }
+    const hash = textHash(text);
+    if (node.meta.embedding.state === "fresh" && node.meta.embedding.textHash === hash) {
+      return;
+    }
+    node.meta.embedding = { state: "stale", textHash: hash };
+    this.pendingRemoval.delete(node.id);
+    this.stale.add(node.id);
+  }
+  /** Mutation hook: a node was removed. Drops it from the index and the stale queue. */
+  onRemove(nodeId) {
+    this.pendingRemoval.add(nodeId);
+    this.stale.delete(nodeId);
+  }
+  /**
+   * Snapshot of both queues for transaction rollback.
+   *
+   * The sync hooks (`onChange`, `onRemove`) only move ids between the `stale`
+   * queue and the `pendingRemoval` queue; all actual vector mutations happen in
+   * the async `reindex()`. This snapshot covers both queues so that a rollback
+   * fully restores the observable state of the index without touching vectors.
+   */
+  txSnapshot() {
+    return {
+      stale: new Set(this.stale),
+      pendingRemoval: new Set(this.pendingRemoval)
+    };
+  }
+  /** Restore both queues captured by `txSnapshot`. */
+  txRestore(snapshot) {
+    const snap = snapshot;
+    this.stale.clear();
+    for (const id of snap.stale) this.stale.add(id);
+    this.pendingRemoval.clear();
+    for (const id of snap.pendingRemoval) this.pendingRemoval.add(id);
+  }
+  /** Convenience: the hooks to wire into `MutatorDeps`. */
+  hooks() {
+    return {
+      onChange: (node) => this.onChange(node),
+      onRemove: (nodeId) => this.onRemove(nodeId),
+      onTxSnapshot: () => this.txSnapshot(),
+      onTxRestore: (snapshot) => this.txRestore(snapshot)
+    };
+  }
+  staleCount() {
+    return this.stale.size;
+  }
+  /** Embed every stale node (one batch), upsert vectors, mark fresh, clear the processed ids.
+   *  Interleave-safe: mutations landing during the embed await are respected — a node
+   *  removed mid-flight is dropped (never resurrected), and a node whose text changed
+   *  stays queued for the next pass instead of being marked fresh for the old text. */
+  async reindex() {
+    for (const id of this.pendingRemoval) await this.vectors.remove(id);
+    this.pendingRemoval.clear();
+    const ids = [...this.stale];
+    if (ids.length === 0) return;
+    const completed = /* @__PURE__ */ new Set();
+    const items = [];
+    for (const id of ids) {
+      const node = this.tree.get(id);
+      if (!node) {
+        completed.add(id);
+        continue;
+      }
+      if (this.isSuppressedShard(node)) {
+        node.meta.embedding = { state: "none" };
+        await this.vectors.remove(id);
+        completed.add(id);
+        continue;
+      }
+      const value = this.tree.toJson(id);
+      const typeDef = node.type ? this.registry?.get(node.type) : void 0;
+      const text = toEmbeddingText(node, value, typeDef);
+      if (text === null) {
+        node.meta.embedding = { state: "none" };
+        await this.vectors.remove(id);
+        completed.add(id);
+        continue;
+      }
+      items.push({ id, text, hash: textHash(text) });
+    }
+    if (items.length > 0) {
+      const embedded = await this.embedding.embed(items.map((it) => it.text));
+      const upserts = [];
+      for (const [i, it] of items.entries()) {
+        const node = this.tree.get(it.id);
+        if (!node) {
+          await this.vectors.remove(it.id);
+          completed.add(it.id);
+          continue;
+        }
+        const cur = node.meta.embedding;
+        if (cur.state !== "stale" || cur.textHash !== void 0 && cur.textHash !== it.hash) {
+          if (node.meta.embedding.state === "none") completed.add(it.id);
+          continue;
+        }
+        upserts.push({ nodeId: it.id, vector: embedded[i] });
+        node.meta.embedding = { state: "fresh", textHash: it.hash };
+        completed.add(it.id);
+      }
+      if (upserts.length > 0) await this.vectors.upsert(upserts);
+    }
+    for (const id of ids) {
+      if (completed.has(id)) this.stale.delete(id);
+    }
+  }
+  snippetOf(value) {
+    const s = JSON.stringify(value);
+    return s.length <= 80 ? s : s.slice(0, 80) + "\u2026";
+  }
+  /**
+   * Semantic search: embed the query, rank indexed nodes by cosine, post-filter by
+   * under/type/tag, return top-k. `freshness: "wait"` flushes the reindexer first;
+   * default `best-effort` searches what's indexed and reports `staleCount`.
+   */
+  async search(queryText, opts = {}) {
+    if (opts.freshness === "wait") await this.reindex();
+    const k = opts.k ?? 8;
+    const [queryVec] = await this.embedding.embed([queryText]);
+    const ranked = await this.vectors.search(queryVec, await this.vectors.size());
+    const results = [];
+    for (const hit of ranked) {
+      if (results.length >= k) break;
+      if (this.pendingRemoval.has(hit.nodeId)) continue;
+      const node = this.tree.get(hit.nodeId);
+      if (!node) continue;
+      const path = this.addressing.pathOf(node.id);
+      if (opts.under !== void 0 && !isWithin(path, opts.under)) continue;
+      if (opts.type !== void 0 && node.type !== opts.type) continue;
+      if (opts.tag !== void 0 && !(node.tags?.includes(opts.tag) ?? false)) continue;
+      results.push({
+        id: node.id,
+        path,
+        type: node.type,
+        score: hit.score,
+        snippet: this.snippetOf(this.tree.toJson(node.id))
+      });
+    }
+    return { results, staleCount: this.staleCount() };
+  }
+};
+export {
+  SemanticIndex
+};
+//# sourceMappingURL=semantic-index.js.map

package/dist/semantic-index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/embedding-text.ts","../src/jsonpointer.ts","../src/semantic-index.ts"],"sourcesContent":["import type { ArbNode, Json } from \"./types\";\r\nimport type { TypeDef } from \"./type-registry\";\r\n\r\n/**\r\n * The text used to embed a node, or null if the node is not embedded.\r\n * A registered type's `embedText` wins; otherwise: string leaf → its value;\r\n * opaque object/array leaf → its JSON; numeric/boolean/null leaves and all\r\n * structural containers → null.\r\n */\r\nexport function toEmbeddingText(node: ArbNode, value: Json, typeDef?: TypeDef): string | null {\r\n  if (typeDef?.embedText) return typeDef.embedText(value);\r\n  if (node.kind !== \"leaf\") return null;\r\n  if (typeof value === \"string\") return value;\r\n  if (value !== null && typeof value === \"object\") return JSON.stringify(value);\r\n  return null;\r\n}\r\n\r\n/** Deterministic 32-bit FNV-1a hash, hex-encoded — used to dedupe re-embedding. */\r\nexport function textHash(text: string): string {\r\n  let h = 2166136261 >>> 0;\r\n  for (let i = 0; i < text.length; i++) {\r\n    h ^= text.charCodeAt(i);\r\n    h = Math.imul(h, 16777619) >>> 0;\r\n  }\r\n  return h.toString(16);\r\n}\r\n","/** Escape a single reference token per RFC 6901: ~ -> ~0, / -> ~1. */\r\nexport function encodeSegment(s: string): string {\r\n  return s.replace(/~/g, \"~0\").replace(/\\//g, \"~1\");\r\n}\r\n\r\n/** Unescape a single reference token per RFC 6901: ~1 -> /, then ~0 -> ~. */\r\nexport function decodeSegment(s: string): string {\r\n  return s.replace(/~1/g, \"/\").replace(/~0/g, \"~\");\r\n}\r\n\r\n/** Build a JSON Pointer string. Empty segment list => \"\" (root). */\r\nexport function buildPointer(segments: ReadonlyArray<string | number>): string {\r\n  if (segments.length === 0) return \"\";\r\n  return \"/\" + segments.map((s) => encodeSegment(String(s))).join(\"/\");\r\n}\r\n\r\n/** Append one child key to a parent pointer, escaping the key exactly as `buildPointer` does. */\r\nexport function appendPointer(parent: string, key: string | number): string {\r\n  return parent + \"/\" + encodeSegment(String(key));\r\n}\r\n\r\n/** True when `path` is at or under `scope` (JSON Pointer prefix). Undefined scope = everywhere. */\r\nexport function isWithin(path: string, scope: string | undefined): boolean {\r\n  return scope === undefined || path === scope || path.startsWith(scope + \"/\");\r\n}\r\n\r\n/** Parse a JSON Pointer into decoded segments. \"\" => [] (root). */\r\nexport function parsePointer(pointer: string): string[] {\r\n  if (pointer === \"\") return [];\r\n  if (!pointer.startsWith(\"/\")) {\r\n    throw new Error(`Invalid JSON Pointer (must be \"\" or start with \"/\"): ${pointer}`);\r\n  }\r\n  return pointer.slice(1).split(\"/\").map(decodeSegment);\r\n}\r\n","import type { ArbNode, NodeId, Json } from \"./types\";\r\nimport type { ArtifactTree } from \"./artifact-tree\";\r\nimport type { Addressing } from \"./addressing\";\r\nimport type { TypeRegistry } from \"./type-registry\";\r\nimport type { EmbeddingPort } from \"./embedding-port\";\r\nimport type { VectorIndexPort } from \"./vector-index-port\";\r\nimport { toEmbeddingText, textHash } from \"./embedding-text\";\r\nimport { isWithin } from \"./jsonpointer\";\r\n\r\nexport interface SearchOpts {\r\n  k?: number;\r\n  under?: string;\r\n  type?: string;\r\n  tag?: string;\r\n  freshness?: \"best-effort\" | \"wait\";\r\n}\r\n\r\nexport interface SearchHit {\r\n  id: NodeId;\r\n  path: string;\r\n  type?: string;\r\n  score: number;\r\n  snippet: string;\r\n}\r\n\r\nexport interface SearchResult {\r\n  results: SearchHit[];\r\n  staleCount: number;\r\n}\r\n\r\n/**\r\n * Owns the per-node semantic index: a stale queue fed by mutation hooks, an async\r\n * batched reindexer, and (Task 6) search. Embedding is never in the mutation path —\r\n * mutations only mark stale; reindex does the async embedding work.\r\n */\r\nexport class SemanticIndex {\r\n  private readonly stale = new Set<NodeId>();\r\n  private readonly pendingRemoval = new Set<NodeId>();\r\n\r\n  constructor(\r\n    private readonly tree: ArtifactTree,\r\n    private readonly addressing: Addressing,\r\n    private readonly embedding: EmbeddingPort,\r\n    private readonly vectors: VectorIndexPort,\r\n    private readonly registry?: TypeRegistry,\r\n  ) {\r\n    // Recover the stale queue after a restore: `stale` itself is not persisted,\r\n    // but each node's `meta.embedding.state` is. A fresh tree has only \"none\"\r\n    // states, so this is a no-op there.\r\n    for (const node of tree.allNodes()) {\r\n      if (node.meta.embedding.state === \"stale\") this.stale.add(node.id);\r\n    }\r\n  }\r\n\r\n  /** The nearest ancestor whose type declares embedText — the semantic unit that\r\n   *  owns this shard — or undefined. (O(depth) walk per call — fine at v1 sizes.) */\r\n  private embedTextAncestor(node: ArbNode): ArbNode | undefined {\r\n    let pid = node.parentId;\r\n    while (pid !== null) {\r\n      const anc = this.tree.get(pid);\r\n      const ancDef = anc?.type ? this.registry?.get(anc.type) : undefined;\r\n      if (ancDef?.embedText) return anc;\r\n      pid = anc?.parentId ?? null;\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  /**\r\n   * A node is a suppressed decomposition shard iff some ANCESTOR has a typed\r\n   * embedText AND the node does not itself declare a typed embedText.\r\n   */\r\n  private isSuppressedShard(node: ArbNode): boolean {\r\n    const ownTypeDef = node.type ? this.registry?.get(node.type) : undefined;\r\n    if (ownTypeDef?.embedText) return false; // node is its own semantic unit\r\n    return this.embedTextAncestor(node) !== undefined;\r\n  }\r\n\r\n  /** Mutation hook: a node's content changed (set/insert). Marks it stale if its embedding-text changed. */\r\n  onChange(node: ArbNode): void {\r\n    if (this.isSuppressedShard(node)) {\r\n      node.meta.embedding = { state: \"none\" };\r\n      this.pendingRemoval.add(node.id);\r\n      this.stale.delete(node.id);\r\n      // The owning typed unit's embed text covers this shard — re-hash IT.\r\n      // (Terminates: the ancestor has its own embedText, so it takes the\r\n      // normal branch below.)\r\n      const anc = this.embedTextAncestor(node);\r\n      if (anc) this.onChange(anc);\r\n      return;\r\n    }\r\n    const value = this.tree.toJson(node.id);\r\n    const typeDef = node.type ? this.registry?.get(node.type) : undefined;\r\n    const text = toEmbeddingText(node, value, typeDef);\r\n    if (text === null) {\r\n      node.meta.embedding = { state: \"none\" };\r\n      this.pendingRemoval.add(node.id);\r\n      this.stale.delete(node.id);\r\n      return;\r\n    }\r\n    const hash = textHash(text);\r\n    if (node.meta.embedding.state === \"fresh\" && node.meta.embedding.textHash === hash) {\r\n      return;\r\n    }\r\n    node.meta.embedding = { state: \"stale\", textHash: hash };\r\n    this.pendingRemoval.delete(node.id);\r\n    this.stale.add(node.id);\r\n  }\r\n\r\n  /** Mutation hook: a node was removed. Drops it from the index and the stale queue. */\r\n  onRemove(nodeId: NodeId): void {\r\n    this.pendingRemoval.add(nodeId);\r\n    this.stale.delete(nodeId);\r\n  }\r\n\r\n  /**\r\n   * Snapshot of both queues for transaction rollback.\r\n   *\r\n   * The sync hooks (`onChange`, `onRemove`) only move ids between the `stale`\r\n   * queue and the `pendingRemoval` queue; all actual vector mutations happen in\r\n   * the async `reindex()`. This snapshot covers both queues so that a rollback\r\n   * fully restores the observable state of the index without touching vectors.\r\n   */\r\n  txSnapshot(): unknown {\r\n    return {\r\n      stale: new Set(this.stale),\r\n      pendingRemoval: new Set(this.pendingRemoval),\r\n    };\r\n  }\r\n\r\n  /** Restore both queues captured by `txSnapshot`. */\r\n  txRestore(snapshot: unknown): void {\r\n    const snap = snapshot as { stale: Set<NodeId>; pendingRemoval: Set<NodeId> };\r\n    this.stale.clear();\r\n    for (const id of snap.stale) this.stale.add(id);\r\n    this.pendingRemoval.clear();\r\n    for (const id of snap.pendingRemoval) this.pendingRemoval.add(id);\r\n  }\r\n\r\n  /** Convenience: the hooks to wire into `MutatorDeps`. */\r\n  hooks(): {\r\n    onChange: (node: ArbNode) => void;\r\n    onRemove: (nodeId: NodeId) => void;\r\n    onTxSnapshot: () => unknown;\r\n    onTxRestore: (snapshot: unknown) => void;\r\n  } {\r\n    return {\r\n      onChange: (node) => this.onChange(node),\r\n      onRemove: (nodeId) => this.onRemove(nodeId),\r\n      onTxSnapshot: () => this.txSnapshot(),\r\n      onTxRestore: (snapshot) => this.txRestore(snapshot),\r\n    };\r\n  }\r\n\r\n  staleCount(): number {\r\n    return this.stale.size;\r\n  }\r\n\r\n  /** Embed every stale node (one batch), upsert vectors, mark fresh, clear the processed ids.\r\n   *  Interleave-safe: mutations landing during the embed await are respected — a node\r\n   *  removed mid-flight is dropped (never resurrected), and a node whose text changed\r\n   *  stays queued for the next pass instead of being marked fresh for the old text. */\r\n  async reindex(): Promise<void> {\r\n    // First: drain deferred removals (HOLE 2 fix — removals queued by sync hooks).\r\n    for (const id of this.pendingRemoval) await this.vectors.remove(id);\r\n    this.pendingRemoval.clear();\r\n\r\n    const ids = [...this.stale];\r\n    if (ids.length === 0) return;\r\n    const completed = new Set<NodeId>();\r\n    const items: { id: NodeId; text: string; hash: string }[] = [];\r\n    for (const id of ids) {\r\n      const node = this.tree.get(id);\r\n      if (!node) {\r\n        completed.add(id);\r\n        continue;\r\n      }\r\n      // HOLE 1 fix: guard-aware reindex — suppress shards that belong to a typed\r\n      // ancestor's embedding unit.\r\n      if (this.isSuppressedShard(node)) {\r\n        node.meta.embedding = { state: \"none\" };\r\n        await this.vectors.remove(id);\r\n        completed.add(id);\r\n        continue;\r\n      }\r\n      const value = this.tree.toJson(id);\r\n      const typeDef = node.type ? this.registry?.get(node.type) : undefined;\r\n      const text = toEmbeddingText(node, value, typeDef);\r\n      if (text === null) {\r\n        node.meta.embedding = { state: \"none\" };\r\n        await this.vectors.remove(id);\r\n        completed.add(id);\r\n        continue;\r\n      }\r\n      items.push({ id, text, hash: textHash(text) });\r\n    }\r\n    if (items.length > 0) {\r\n      const embedded = await this.embedding.embed(items.map((it) => it.text));\r\n      // Mutations may have landed during the await — re-validate every item\r\n      // against the live tree before trusting the embedded batch.\r\n      const upserts: { nodeId: NodeId; vector: number[] }[] = [];\r\n      for (const [i, it] of items.entries()) {\r\n        const node = this.tree.get(it.id);\r\n        if (!node) {\r\n          await this.vectors.remove(it.id); // removed mid-flight — do not resurrect\r\n          completed.add(it.id);\r\n          continue;\r\n        }\r\n        // Positive trust check: mark fresh ONLY if the node still awaits exactly the\r\n        // text we embedded. \"none\" (text became null / became a suppressed shard\r\n        // mid-flight) means its removal is already queued — complete without\r\n        // upserting; any other divergence (new hash) stays queued for the next pass.\r\n        // A stale node with NO textHash (a delta-restored node — restoreFromDelta\r\n        // marks {state:\"stale\"} without a hash) cannot have been touched during the\r\n        // await: any mid-flight change writes a concrete hash (\"stale\"), \"none\", or\r\n        // removes the node. So an undefined hash means our pre-await snapshot is\r\n        // current — trust the batch.\r\n        const cur = node.meta.embedding;\r\n        if (cur.state !== \"stale\" || (cur.textHash !== undefined && cur.textHash !== it.hash)) {\r\n          if (node.meta.embedding.state === \"none\") completed.add(it.id);\r\n          continue;\r\n        }\r\n        upserts.push({ nodeId: it.id, vector: embedded[i] });\r\n        node.meta.embedding = { state: \"fresh\", textHash: it.hash };\r\n        completed.add(it.id);\r\n      }\r\n      if (upserts.length > 0) await this.vectors.upsert(upserts);\r\n    }\r\n    for (const id of ids) {\r\n      if (completed.has(id)) this.stale.delete(id);\r\n    }\r\n  }\r\n\r\n  private snippetOf(value: Json): string {\r\n    const s = JSON.stringify(value);\r\n    return s.length <= 80 ? s : s.slice(0, 80) + \"…\";\r\n  }\r\n\r\n  /**\r\n   * Semantic search: embed the query, rank indexed nodes by cosine, post-filter by\r\n   * under/type/tag, return top-k. `freshness: \"wait\"` flushes the reindexer first;\r\n   * default `best-effort` searches what's indexed and reports `staleCount`.\r\n   */\r\n  async search(queryText: string, opts: SearchOpts = {}): Promise<SearchResult> {\r\n    if (opts.freshness === \"wait\") await this.reindex();\r\n    const k = opts.k ?? 8;\r\n    const [queryVec] = await this.embedding.embed([queryText]);\r\n    const ranked = await this.vectors.search(queryVec, await this.vectors.size());\r\n    const results: SearchHit[] = [];\r\n    for (const hit of ranked) {\r\n      if (results.length >= k) break;\r\n      // Skip logically-removed entries that haven't been physically flushed yet.\r\n      if (this.pendingRemoval.has(hit.nodeId)) continue;\r\n      const node = this.tree.get(hit.nodeId);\r\n      if (!node) continue;\r\n      const path = this.addressing.pathOf(node.id);\r\n      if (opts.under !== undefined && !isWithin(path, opts.under)) continue;\r\n      if (opts.type !== undefined && node.type !== opts.type) continue;\r\n      if (opts.tag !== undefined && !(node.tags?.includes(opts.tag) ?? false)) continue;\r\n      results.push({\r\n        id: node.id,\r\n        path,\r\n        type: node.type,\r\n        score: hit.score,\r\n        snippet: this.snippetOf(this.tree.toJson(node.id)),\r\n      });\r\n    }\r\n    return { results, staleCount: this.staleCount() };\r\n  }\r\n}\r\n"],"mappings":"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","names":[]}