arborkit 1.0.0 → 1.1.0

package/dist/arbor.js

@@ -1,1540 +1,28 @@
-// src/decompose.ts
-function byteSize(value) {
-  return Buffer.byteLength(JSON.stringify(value), "utf8");
-}
-function kindOf(value, opaque) {
-  if (opaque) return "leaf";
-  return Array.isArray(value) ? "array" : "object";
-}
-function sizeBasedDecision(maxOpaqueBytes) {
-  return {
-    isOpaque(value) {
-      if (value === null || typeof value !== "object") return true;
-      return byteSize(value) <= maxOpaqueBytes;
-    }
-  };
-}
-
-// src/errors.ts
-var ArborError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = new.target.name;
-  }
-  code;
-};
-var NodeNotFoundError = class extends ArborError {
-  constructor(ref) {
-    super("NODE_NOT_FOUND", `Node not found: ${JSON.stringify(ref)}`);
-    this.ref = ref;
-  }
-  ref;
-};
-var ScopeViolationError = class extends ArborError {
-  constructor(targetPath, scope) {
-    super("SCOPE_VIOLATION", `Access outside scope: ${targetPath} (scope: ${scope})`);
-    this.targetPath = targetPath;
-    this.scope = scope;
-  }
-  targetPath;
-  scope;
-};
-var StaleVersionError = class extends ArborError {
-  constructor(id, expected, actual) {
-    super("STALE_VERSION", `Stale version for ${id}: expected ${expected}, actual ${actual}`);
-    this.id = id;
-    this.expected = expected;
-    this.actual = actual;
-  }
-  id;
-  expected;
-  actual;
-};
-var InvalidOpError = class extends ArborError {
-  constructor(message) {
-    super("INVALID_OP", message);
-  }
-};
-
-// src/artifact-tree.ts
-var ArtifactTree = class _ArtifactTree {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  deps;
-  nodes = /* @__PURE__ */ new Map();
-  rootId;
-  /** Lazily built per-parent key→childId maps for O(1) object-child lookup.
-   *  A cache OUTSIDE the nodes (ArbNode/StoredArtifact stay byte-identical);
-   *  invalidated on every child-set change, rebuilt on read. Arrays never
-   *  populate it (index lookup is already O(1)). */
-  keyMaps = /* @__PURE__ */ new Map();
-  static fromJson(json, deps) {
-    const tree = new _ArtifactTree(deps);
-    tree.rootId = tree.build(json, null, null);
-    return tree;
-  }
-  build(value, parentId, key, type) {
-    const opaque = this.deps.decision.isOpaque(value, type);
-    const kind = kindOf(value, opaque);
-    const id = this.deps.idGen.next();
-    const node = {
-      id,
-      parentId,
-      key,
-      kind,
-      content: kind === "leaf" ? value : null,
-      childIds: [],
-      meta: { version: 0, updatedAt: this.deps.clock.now(), embedding: { state: "none" } }
-    };
-    if (type !== void 0) node.type = type;
-    this.nodes.set(id, node);
-    if (kind === "object") {
-      for (const [k, v] of Object.entries(value)) {
-        node.childIds.push(this.build(v, id, k));
-      }
-    } else if (kind === "array") {
-      value.forEach((v, i) => {
-        node.childIds.push(this.build(v, id, i));
-      });
-    }
-    return id;
-  }
-  get(id) {
-    return this.nodes.get(id);
-  }
-  root() {
-    return this.nodes.get(this.rootId);
-  }
-  rootIdValue() {
-    return this.rootId;
-  }
-  /** O(1) child lookup: arrays by index, objects via a lazily built key map. */
-  childByKey(parentId, key) {
-    const parent = this.nodes.get(parentId);
-    if (!parent) return void 0;
-    if (parent.kind === "array") {
-      if (!/^(0|[1-9]\d*)$/.test(key)) return void 0;
-      const i = Number(key);
-      if (i >= parent.childIds.length) return void 0;
-      return this.nodes.get(parent.childIds[i]);
-    }
-    let map = this.keyMaps.get(parentId);
-    if (!map) {
-      map = /* @__PURE__ */ new Map();
-      for (const cid2 of parent.childIds) map.set(String(this.nodes.get(cid2).key), cid2);
-      this.keyMaps.set(parentId, map);
-    }
-    const cid = map.get(key);
-    return cid === void 0 ? void 0 : this.nodes.get(cid);
-  }
-  children(id) {
-    const n = this.nodes.get(id);
-    if (!n) return [];
-    return n.childIds.map((cid) => this.nodes.get(cid));
-  }
-  has(id) {
-    return this.nodes.has(id);
-  }
-  size() {
-    return this.nodes.size;
-  }
-  /** Reconstruct the JSON value rooted at `id` (defaults to the tree root). */
-  toJson(id = this.rootId) {
-    const n = this.nodes.get(id);
-    if (!n) throw new Error(`Unknown node: ${id}`);
-    if (n.kind === "leaf") return n.content;
-    if (n.kind === "array") return n.childIds.map((cid) => this.toJson(cid));
-    const obj = {};
-    for (const cid of n.childIds) {
-      const c = this.nodes.get(cid);
-      obj[String(c.key)] = this.toJson(cid);
-    }
-    return obj;
-  }
-  /** Replace the subtree value at `id` in place, keeping the node's id/key/parentId.
-   *  `clearType` explicitly un-types the node (used by type-aware revert). */
-  replaceValue(id, value, type, clearType = false) {
-    const node = this.nodes.get(id);
-    if (!node) throw new InvalidOpError(`Unknown node: ${id}`);
-    this.deleteDescendants(id);
-    this.keyMaps.delete(id);
-    const opaque = this.deps.decision.isOpaque(value, type);
-    const kind = kindOf(value, opaque);
-    node.kind = kind;
-    node.content = kind === "leaf" ? value : null;
-    node.childIds = [];
-    if (clearType) node.type = void 0;
-    else if (type !== void 0) node.type = type;
-    if (kind === "object") {
-      for (const [k, v] of Object.entries(value)) {
-        node.childIds.push(this.build(v, id, k));
-      }
-    } else if (kind === "array") {
-      value.forEach((v, i) => {
-        node.childIds.push(this.build(v, id, i));
-      });
-    }
-  }
-  /** Recursively remove all descendants of `id` from the node map (keeps `id` itself). */
-  deleteDescendants(id) {
-    const node = this.nodes.get(id);
-    if (!node) return;
-    for (const cid of node.childIds) {
-      this.deleteDescendants(cid);
-      this.nodes.delete(cid);
-      this.keyMaps.delete(cid);
-    }
-    node.childIds = [];
-  }
-  /** Deep, independent copy of the tree state for transaction rollback.
-   *  `restore` consumes the snapshot; do not reuse it afterwards. */
-  snapshot() {
-    const nodes = /* @__PURE__ */ new Map();
-    for (const [id, node] of this.nodes) {
-      nodes.set(id, structuredClone(node));
-    }
-    return { nodes, rootId: this.rootId };
-  }
-  /** Replace the tree state with a previously taken snapshot. The snapshot's
-   *  nodes are adopted BY REFERENCE — restore consumes the snapshot; do not
-   *  reuse it afterwards. */
-  restore(snap) {
-    this.nodes.clear();
-    this.keyMaps.clear();
-    for (const [id, node] of snap.nodes) {
-      this.nodes.set(id, node);
-    }
-    this.rootId = snap.rootId;
-  }
-  /** Insert a decomposed `value` as a child of `parentId`. For objects `keyOrIndex` is the string key; for arrays it is the insert index. Returns the new child's id. */
-  insertChild(parentId, keyOrIndex, value, type) {
-    const parent = this.nodes.get(parentId);
-    if (!parent) throw new InvalidOpError(`Unknown node: ${parentId}`);
-    if (parent.kind === "object") {
-      if (typeof keyOrIndex !== "string") {
-        throw new InvalidOpError("object insert requires a string key");
-      }
-      if (parent.childIds.some((cid2) => this.nodes.get(cid2).key === keyOrIndex)) {
-        throw new InvalidOpError(`key already exists: ${keyOrIndex}`);
-      }
-      const cid = this.build(value, parentId, keyOrIndex, type);
-      parent.childIds.push(cid);
-      this.keyMaps.delete(parentId);
-      return cid;
-    }
-    if (parent.kind === "array") {
-      if (typeof keyOrIndex !== "number") {
-        throw new InvalidOpError("array insert requires a numeric index");
-      }
-      const at = Math.max(0, Math.min(keyOrIndex, parent.childIds.length));
-      const cid = this.build(value, parentId, at, type);
-      parent.childIds.splice(at, 0, cid);
-      this.renumberArray(parentId);
-      return cid;
-    }
-    throw new InvalidOpError("cannot insert into a leaf node");
-  }
-  /** Remove `childId` (and its subtree) from `parentId`. Renumbers array siblings. */
-  removeChild(parentId, childId) {
-    const parent = this.nodes.get(parentId);
-    if (!parent) throw new InvalidOpError(`Unknown node: ${parentId}`);
-    const idx = parent.childIds.indexOf(childId);
-    if (idx < 0) throw new InvalidOpError(`${childId} is not a child of ${parentId}`);
-    this.deleteDescendants(childId);
-    this.nodes.delete(childId);
-    this.keyMaps.delete(childId);
-    parent.childIds.splice(idx, 1);
-    this.keyMaps.delete(parentId);
-    if (parent.kind === "array") this.renumberArray(parentId);
-  }
-  /** Move `id` under `newParentId` at `keyOrIndex`, preserving `id`. Renumbers affected arrays.
-   *  ALL validation happens before any mutation — a rejected move leaves the tree untouched. */
-  moveNode(id, newParentId, keyOrIndex) {
-    const node = this.nodes.get(id);
-    if (!node) throw new InvalidOpError(`Unknown node: ${id}`);
-    if (node.parentId === null) throw new InvalidOpError("cannot move the root");
-    const newParent = this.nodes.get(newParentId);
-    if (!newParent) throw new InvalidOpError(`Unknown node: ${newParentId}`);
-    if (newParent.kind === "leaf") throw new InvalidOpError("cannot move into a leaf node");
-    let anc = newParentId;
-    while (anc !== null) {
-      if (anc === id) throw new InvalidOpError("cannot move a node into itself or its own subtree");
-      anc = this.nodes.get(anc)?.parentId ?? null;
-    }
-    if (newParent.kind === "object") {
-      if (typeof keyOrIndex !== "string") throw new InvalidOpError("object move requires a string key");
-      if (newParent.childIds.some((cid) => cid !== id && this.nodes.get(cid).key === keyOrIndex)) {
-        throw new InvalidOpError(`key already exists: ${keyOrIndex}`);
-      }
-    }
-    const oldParent = this.nodes.get(node.parentId);
-    const oldIdx = oldParent.childIds.indexOf(id);
-    oldParent.childIds.splice(oldIdx, 1);
-    this.keyMaps.delete(oldParent.id);
-    this.keyMaps.delete(newParentId);
-    if (oldParent.kind === "array") this.renumberArray(oldParent.id);
-    if (newParent.kind === "object") {
-      node.parentId = newParentId;
-      node.key = keyOrIndex;
-      newParent.childIds.push(id);
-    } else {
-      const at = typeof keyOrIndex === "number" ? Math.max(0, Math.min(keyOrIndex, newParent.childIds.length)) : newParent.childIds.length;
-      node.parentId = newParentId;
-      newParent.childIds.splice(at, 0, id);
-      this.renumberArray(newParentId);
-    }
-  }
-  /** Set each array child's `key` to its current position. */
-  renumberArray(parentId) {
-    const parent = this.nodes.get(parentId);
-    if (!parent) return;
-    parent.childIds.forEach((cid, i) => {
-      this.nodes.get(cid).key = i;
-    });
-  }
-  /** All nodes in the tree (for serialization). */
-  allNodes() {
-    return [...this.nodes.values()];
-  }
-  /** Rebuild a tree from previously serialized nodes, preserving their ids. */
-  static fromStored(nodes, rootId, deps) {
-    const tree = new _ArtifactTree(deps);
-    for (const node of nodes) tree.nodes.set(node.id, node);
-    tree.rootId = rootId;
-    return tree;
-  }
-  /** All transitive descendant ids of `id` (depth-first), excluding `id` itself. */
-  descendantIds(id) {
-    const out = [];
-    const node = this.nodes.get(id);
-    if (!node) return out;
-    for (const cid of node.childIds) {
-      out.push(cid);
-      out.push(...this.descendantIds(cid));
-    }
-    return out;
-  }
-};
-
-// src/jsonpointer.ts
-function encodeSegment(s) {
-  return s.replace(/~/g, "~0").replace(/\//g, "~1");
-}
-function decodeSegment(s) {
-  return s.replace(/~1/g, "/").replace(/~0/g, "~");
-}
-function buildPointer(segments) {
-  if (segments.length === 0) return "";
-  return "/" + segments.map((s) => encodeSegment(String(s))).join("/");
-}
-function appendPointer(parent, key) {
-  return parent + "/" + encodeSegment(String(key));
-}
-function isWithin(path, scope) {
-  return scope === void 0 || path === scope || path.startsWith(scope + "/");
-}
-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/addressing.ts
-var Addressing = class {
-  constructor(tree) {
-    this.tree = tree;
-  }
-  tree;
-  byId(id) {
-    return this.tree.get(id);
-  }
-  /** Compute the JSON Pointer for a node by walking parent links to the root. */
-  pathOf(id) {
-    const cur0 = this.tree.get(id);
-    if (!cur0) throw new Error(`Unknown node: ${id}`);
-    const segments = [];
-    let cur = cur0;
-    while (cur && cur.parentId !== null) {
-      segments.unshift(cur.key);
-      cur = this.tree.get(cur.parentId);
-    }
-    return buildPointer(segments);
-  }
-  /** Resolve a JSON Pointer to a node, or undefined if any segment is missing. */
-  byPath(pointer) {
-    const segments = parsePointer(pointer);
-    let cur = this.tree.root();
-    for (const seg of segments) {
-      if (!cur) return void 0;
-      cur = this.tree.childByKey(cur.id, seg);
-      if (!cur) return void 0;
-    }
-    return cur;
-  }
-};
-
-// src/event-log.ts
-var EventLog = class _EventLog {
-  events = [];
-  baseSeq = 0;
-  // count of compacted-away events; events[0].seq === baseSeq
-  append(event) {
-    const full = { ...event, seq: this.baseSeq + this.events.length };
-    this.events.push(full);
-    return full;
-  }
-  entries() {
-    return this.events;
-  }
-  /** Absolute seq of the oldest retained event (0 until compaction). Versions below
-   *  this have been compacted away and are no longer reconstructable. */
-  baseSeqValue() {
-    return this.baseSeq;
-  }
-  /** The event at absolute `seq`, or undefined if compacted away / past the end. */
-  at(seq) {
-    const i = seq - this.baseSeq;
-    return i >= 0 && i < this.events.length ? this.events[i] : void 0;
-  }
-  since(seq) {
-    return this.events.filter((e) => e.seq >= seq);
-  }
-  /** Absolute next-seq / current version (unchanged across compaction). */
-  length() {
-    return this.baseSeq + this.events.length;
-  }
-  /** Drop events past absolute `length` — used to roll back a failed transaction.
-   *  Throws below the compaction floor: that history is gone and the log cannot roll
-   *  back past it — `compactTo` must never run inside a transaction. */
-  truncateTo(length) {
-    if (length < this.baseSeq) {
-      throw new InvalidOpError(
-        `cannot truncate to ${length}: events before ${this.baseSeq} were compacted away (compactTo must not run inside a transaction)`
-      );
-    }
-    this.events.length = length - this.baseSeq;
-  }
-  /** Compaction: drop every retained event with seq < `floorSeq` (history before it
-   *  becomes unreconstructable). `floorSeq` is clamped to [baseSeq, length()].
-   *  Returns the number of events dropped. Must NOT be called inside a Mutator
-   *  transaction (rollback would need the dropped events). */
-  compactTo(floorSeq) {
-    const floor = Math.max(this.baseSeq, Math.min(floorSeq, this.length()));
-    const drop = floor - this.baseSeq;
-    if (drop > 0) {
-      this.events.splice(0, drop);
-      this.baseSeq = floor;
-    }
-    return drop;
-  }
-  /** Rebuild a log from previously serialized events, preserving their seq + the
-   *  compaction floor. */
-  static fromStored(events, baseSeq = 0) {
-    const log = new _EventLog();
-    log.baseSeq = baseSeq;
-    for (const e of events) log.events.push({ ...e });
-    return log;
-  }
-};
-
-// src/mutator.ts
-var Mutator = class {
-  constructor(tree, addressing, log, deps) {
-    this.tree = tree;
-    this.addressing = addressing;
-    this.log = log;
-    this.deps = deps;
-  }
-  tree;
-  addressing;
-  log;
-  deps;
-  resolve(ref) {
-    const node = "id" in ref ? this.addressing.byId(ref.id) : this.addressing.byPath(ref.path);
-    if (!node) throw new NodeNotFoundError(ref);
-    return node;
-  }
-  checkScope(node, writeScope) {
-    if (writeScope === void 0) return;
-    const path = this.addressing.pathOf(node.id);
-    if (!isWithin(path, writeScope)) throw new ScopeViolationError(path, writeScope);
-  }
-  checkVersion(node, ifVersion) {
-    if (ifVersion !== void 0 && node.meta.version !== ifVersion) {
-      throw new StaleVersionError(node.id, ifVersion, node.meta.version);
-    }
-  }
-  bump(node, owner) {
-    node.meta.version += 1;
-    node.meta.updatedAt = this.deps.clock.now();
-    if (owner !== void 0) node.meta.owner = owner;
-  }
-  set(ref, value, opts = {}) {
-    const node = this.resolve(ref);
-    this.checkScope(node, opts.writeScope);
-    this.checkVersion(node, opts.ifVersion);
-    const cloned = structuredClone(value);
-    const clearType = opts.type === null;
-    const type = clearType ? void 0 : opts.type ?? node.type;
-    this.deps.validate?.({ node, proposed: cloned, type, op: "set" });
-    const before = this.tree.toJson(node.id);
-    const typeBefore = node.type;
-    const tagsBefore = [...node.tags ?? []];
-    const orphaned = this.tree.descendantIds(node.id);
-    this.tree.replaceValue(node.id, cloned, type, clearType);
-    if (opts.tags !== void 0) node.tags = [...opts.tags];
-    this.bump(node, opts.owner);
-    this.deps.onChange?.(node);
-    if (this.deps.onChange) {
-      for (const id of this.tree.descendantIds(node.id)) {
-        const child = this.tree.get(id);
-        if (child) this.deps.onChange(child);
-      }
-    }
-    if (this.deps.onRemove) {
-      for (const id of orphaned) this.deps.onRemove(id);
-    }
-    this.log.append({
-      kind: "set",
-      targetId: node.id,
-      parentId: node.parentId,
-      key: node.key,
-      path: this.addressing.pathOf(node.id),
-      before,
-      after: cloned,
-      nodeTypeBefore: typeBefore ?? null,
-      nodeType: type ?? null,
-      tagsBefore,
-      tags: [...node.tags ?? []],
-      actor: opts.owner,
-      ts: this.deps.clock.now()
-    });
-  }
-  insert(parentRef, keyOrIndex, value, opts = {}) {
-    const parent = this.resolve(parentRef);
-    this.checkScope(parent, opts.writeScope);
-    this.checkVersion(parent, opts.ifVersion);
-    const cloned = structuredClone(value);
-    const type = opts.type === null ? void 0 : opts.type;
-    this.deps.validate?.({ node: null, proposed: cloned, type, op: "insert" });
-    const newId = this.tree.insertChild(parent.id, keyOrIndex, cloned, type);
-    const child = this.tree.get(newId);
-    if (opts.tags !== void 0) child.tags = [...opts.tags];
-    this.bump(parent, opts.owner);
-    this.deps.onChange?.(child);
-    if (this.deps.onChange) {
-      for (const id of this.tree.descendantIds(newId)) {
-        const desc = this.tree.get(id);
-        if (desc) this.deps.onChange(desc);
-      }
-    }
-    this.log.append({
-      kind: "insert",
-      targetId: newId,
-      parentId: parent.id,
-      key: child.key,
-      path: this.addressing.pathOf(newId),
-      after: cloned,
-      nodeType: child.type ?? null,
-      tags: [...child.tags ?? []],
-      actor: opts.owner,
-      ts: this.deps.clock.now()
-    });
-    return newId;
-  }
-  remove(ref, opts = {}) {
-    const node = this.resolve(ref);
-    if (node.parentId === null) throw new InvalidOpError("cannot remove the root");
-    this.checkScope(node, opts.writeScope);
-    this.checkVersion(node, opts.ifVersion);
-    const before = this.tree.toJson(node.id);
-    const path = this.addressing.pathOf(node.id);
-    const removedIds = [node.id, ...this.tree.descendantIds(node.id)];
-    const parent = this.tree.get(node.parentId);
-    const removedKey = node.key;
-    this.tree.removeChild(node.parentId, node.id);
-    this.bump(parent, opts.owner);
-    if (this.deps.onRemove) {
-      for (const id of removedIds) this.deps.onRemove(id);
-    }
-    this.deps.onChange?.(parent);
-    this.log.append({
-      kind: "remove",
-      targetId: node.id,
-      parentId: parent.id,
-      key: removedKey,
-      path,
-      before,
-      nodeTypeBefore: node.type ?? null,
-      tagsBefore: [...node.tags ?? []],
-      actor: opts.owner,
-      ts: this.deps.clock.now()
-    });
-  }
-  move(ref, toParentRef, keyOrIndex, opts = {}) {
-    const node = this.resolve(ref);
-    if (node.parentId === null) throw new InvalidOpError("cannot move the root");
-    const toParent = this.resolve(toParentRef);
-    this.checkScope(node, opts.writeScope);
-    this.checkScope(toParent, opts.writeScope);
-    this.checkVersion(node, opts.ifVersion);
-    const oldParentId = node.parentId;
-    const from = { parentId: node.parentId, key: node.key };
-    const fromPath = this.addressing.pathOf(node.id);
-    this.tree.moveNode(node.id, toParent.id, keyOrIndex);
-    const toPath = this.addressing.pathOf(node.id);
-    const bumped = /* @__PURE__ */ new Set();
-    for (const id of [node.id, oldParentId, toParent.id]) {
-      if (id !== null && !bumped.has(id)) {
-        const n = this.tree.get(id);
-        if (n) this.bump(n, opts.owner);
-        bumped.add(id);
-      }
-    }
-    if (this.deps.onChange) {
-      this.deps.onChange(node);
-      for (const id of this.tree.descendantIds(node.id)) {
-        const d = this.tree.get(id);
-        if (d) this.deps.onChange(d);
-      }
-      const oldP = oldParentId !== null ? this.tree.get(oldParentId) : void 0;
-      if (oldP) this.deps.onChange(oldP);
-      const newP = this.tree.get(toParent.id);
-      if (newP) this.deps.onChange(newP);
-    }
-    this.log.append({
-      kind: "move",
-      targetId: node.id,
-      parentId: toParent.id,
-      key: node.key,
-      from,
-      to: { parentId: toParent.id, key: node.key },
-      fromPath,
-      toPath,
-      actor: opts.owner,
-      ts: this.deps.clock.now()
-    });
-  }
-  /** Run `fn` atomically: if it throws, the tree, log, and any hooked index state are restored. */
-  transaction(fn) {
-    const snap = this.tree.snapshot();
-    const logLen = this.log.length();
-    const hookSnap = this.deps.onTxSnapshot?.();
-    try {
-      fn();
-    } catch (err) {
-      this.tree.restore(snap);
-      this.log.truncateTo(logLen);
-      if (this.deps.onTxRestore) this.deps.onTxRestore(hookSnap);
-      throw err;
-    }
-  }
-};
-
-// 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);
-  }
-};
-
-// 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/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() };
-  }
-};
-
-// src/path-glob.ts
-function matchSegments(pattern, path) {
-  if (pattern.length === 0) return path.length === 0;
-  const [head, ...rest] = pattern;
-  if (head === "**") {
-    for (let i = 0; i <= path.length; i++) {
-      if (matchSegments(rest, path.slice(i))) return true;
-    }
-    return false;
-  }
-  if (path.length === 0) return false;
-  if (head === "*" || head === path[0]) {
-    return matchSegments(rest, path.slice(1));
-  }
-  return false;
-}
-function compileGlob(pattern) {
-  const patternSegs = parsePointer(pattern);
-  return (path) => matchSegments(patternSegs, parsePointer(path));
-}
-
-// src/navigator.ts
-var DEFAULT_LIMIT = 100;
-var PREVIEW_MAX = 50;
-function previewOf(node) {
-  if (node.kind === "leaf") {
-    const s = JSON.stringify(node.content);
-    return s.length <= PREVIEW_MAX ? s : s.slice(0, PREVIEW_MAX) + "\u2026";
-  }
-  return node.kind === "array" ? `[${node.childIds.length} items]` : `{${node.childIds.length} keys}`;
-}
-var Navigator = class {
-  constructor(tree, addressing) {
-    this.tree = tree;
-    this.addressing = addressing;
-  }
-  tree;
-  addressing;
-  resolve(ref) {
-    const node = "id" in ref ? this.addressing.byId(ref.id) : this.addressing.byPath(ref.path);
-    if (!node) throw new NodeNotFoundError(ref);
-    return node;
-  }
-  summarize(node) {
-    return {
-      id: node.id,
-      key: node.key,
-      kind: node.kind,
-      type: node.type,
-      hasChildren: node.childIds.length > 0,
-      size: node.kind === "leaf" ? byteSize(node.content) : node.childIds.length,
-      preview: previewOf(node)
-    };
-  }
-  describe(ref = { path: "" }, opts = {}) {
-    const node = this.resolve(ref);
-    const all = this.tree.children(node.id);
-    const total = all.length;
-    const offset = opts.offset ?? 0;
-    const limit = opts.limit ?? DEFAULT_LIMIT;
-    const page = all.slice(offset, offset + limit);
-    const result = {
-      node: {
-        id: node.id,
-        path: this.addressing.pathOf(node.id),
-        key: node.key,
-        kind: node.kind,
-        type: node.type
-      },
-      children: page.map((c) => this.summarize(c))
-    };
-    const nextOffset = offset + page.length;
-    if (nextOffset < total) {
-      result.truncated = { shown: page.length, total, nextOffset };
-    }
-    return result;
-  }
-  get(ref, opts = {}) {
-    const node = this.resolve(ref);
-    const maxDepth = opts.maxDepth;
-    let truncated = false;
-    const reconstruct = (id, depth) => {
-      const n = this.tree.get(id);
-      if (n.kind === "leaf") return n.content;
-      if (maxDepth !== void 0 && depth >= maxDepth) {
-        truncated = true;
-        const label = n.kind === "array" ? `${n.childIds.length} items` : `${n.childIds.length} keys`;
-        return `[truncated: ${label}]`;
-      }
-      if (n.kind === "array") return n.childIds.map((cid) => reconstruct(cid, depth + 1));
-      const obj = {};
-      for (const cid of n.childIds) {
-        const c = this.tree.get(cid);
-        obj[String(c.key)] = reconstruct(cid, depth + 1);
-      }
-      return obj;
-    };
-    const content = reconstruct(node.id, 0);
-    const result = {
-      id: node.id,
-      path: this.addressing.pathOf(node.id),
-      type: node.type,
-      content,
-      meta: node.meta
-    };
-    if (truncated) result.truncated = true;
-    return result;
-  }
-  matches(node, sel, path, glob) {
-    if (sel.type !== void 0 && node.type !== sel.type) return false;
-    if (sel.tag !== void 0 && !(node.tags?.includes(sel.tag) ?? false)) return false;
-    if (glob !== void 0 && !glob(path)) return false;
-    return true;
-  }
-  /** Find nodes matching ALL provided selector fields (exact `type`, `tag` membership, glob `pathPattern`). */
-  find(selector, opts = {}) {
-    const limit = opts.limit ?? DEFAULT_LIMIT;
-    const within = opts.within;
-    const glob = selector.pathPattern !== void 0 ? compileGlob(selector.pathPattern) : void 0;
-    const hits = [];
-    let truncated = false;
-    const visit = (id, path) => {
-      if (hits.length >= limit) {
-        truncated = true;
-        return;
-      }
-      const node = this.tree.get(id);
-      if (this.matches(node, selector, path, glob)) {
-        if (isWithin(path, within)) {
-          hits.push({ id: node.id, path, type: node.type });
-        }
-      }
-      for (const cid of node.childIds) {
-        if (hits.length >= limit) {
-          truncated = true;
-          break;
-        }
-        const child = this.tree.get(cid);
-        visit(cid, appendPointer(path, child.key));
-      }
-    };
-    visit(this.tree.rootIdValue(), "");
-    return { hits, truncated };
-  }
-};
-
-// src/toolset.ts
-function eventWithinScope(e, scope) {
-  if (e.path !== void 0 && isWithin(e.path, scope)) return true;
-  if (e.toPath !== void 0 && isWithin(e.toPath, scope)) return true;
-  if (e.fromPath !== void 0 && isWithin(e.fromPath, scope)) return true;
-  return false;
-}
-async function run(fn) {
-  try {
-    return { ok: true, value: await fn() };
-  } catch (e) {
-    if (e instanceof ArborError) return { ok: false, error: { code: e.code, message: e.message } };
-    const message = e instanceof Error ? e.message : String(e);
-    return { ok: false, error: { code: "ERROR", message } };
-  }
-}
-function makeToolset(deps, binding = {}) {
-  const { tree, addressing } = deps;
-  const navigator = new Navigator(tree, addressing);
-  return {
-    describe: (ref, opts) => run(() => {
-      const target = ref ?? (binding.readScope !== void 0 ? { path: binding.readScope } : { path: "" });
-      const r = navigator.describe(target, opts);
-      if (!isWithin(r.node.path, binding.readScope)) {
-        throw new ScopeViolationError(r.node.path, binding.readScope);
-      }
-      return r;
-    }),
-    get: (ref, opts) => run(() => {
-      const r = navigator.get(ref, opts);
-      if (!isWithin(r.path, binding.readScope)) {
-        throw new ScopeViolationError(r.path, binding.readScope);
-      }
-      return structuredClone(r);
-    }),
-    find: (selector, opts) => run(() => {
-      if (binding.readScope !== void 0 && opts?.within !== void 0 && !isWithin(opts.within, binding.readScope)) {
-        throw new ScopeViolationError(opts.within, binding.readScope);
-      }
-      return navigator.find(selector, { ...opts, within: opts?.within ?? binding.readScope });
-    }),
-    search: (query, opts = {}) => run(async () => {
-      if (!deps.index) throw new InvalidOpError("no semantic index configured for this toolset");
-      if (binding.readScope !== void 0 && opts.under !== void 0 && !isWithin(opts.under, binding.readScope)) {
-        throw new ScopeViolationError(opts.under, binding.readScope);
-      }
-      const under = opts.under ?? binding.readScope;
-      return deps.index.search(query, { ...opts, under });
-    }),
-    patch: (ref, op) => run(() => {
-      const common = { owner: binding.owner, writeScope: binding.writeScope, ifVersion: op.ifVersion };
-      const resolve = (r) => {
-        const node = "id" in r ? addressing.byId(r.id) : addressing.byPath(r.path);
-        if (!node) throw new NodeNotFoundError(r);
-        return node;
-      };
-      switch (op.op) {
-        case "set": {
-          deps.mutator.set(ref, op.value, common);
-          const node = resolve(ref);
-          return { id: node.id, path: addressing.pathOf(node.id), version: node.meta.version };
-        }
-        case "insert": {
-          const id = deps.mutator.insert(ref, op.key, op.value, common);
-          const node = tree.get(id);
-          return { id, path: addressing.pathOf(id), version: node.meta.version };
-        }
-        case "remove": {
-          const node = resolve(ref);
-          const removed = { id: node.id, path: addressing.pathOf(node.id) };
-          const parentId = node.parentId;
-          deps.mutator.remove(ref, common);
-          const parent = parentId !== null ? tree.get(parentId) : void 0;
-          return { id: removed.id, path: removed.path, version: parent?.meta.version ?? 0 };
-        }
-        case "move": {
-          const node = resolve(ref);
-          deps.mutator.move(ref, op.to, op.key, common);
-          return { id: node.id, path: addressing.pathOf(node.id), version: node.meta.version };
-        }
-      }
-    }),
-    history: (ref, opts = {}) => run(() => {
-      let events = [...deps.log.entries()];
-      if (ref !== void 0) {
-        const node = "id" in ref ? addressing.byId(ref.id) : addressing.byPath(ref.path);
-        if (!node) throw new NodeNotFoundError(ref);
-        const path = addressing.pathOf(node.id);
-        if (!isWithin(path, binding.readScope)) throw new ScopeViolationError(path, binding.readScope);
-        const id = node.id;
-        events = events.filter((e) => e.targetId === id);
-      } else if (binding.readScope !== void 0) {
-        const scope = binding.readScope;
-        events = events.filter((e) => eventWithinScope(e, scope));
-      }
-      return structuredClone(opts.limit !== void 0 ? events.slice(-opts.limit) : events);
-    })
-  };
-}
-
-// src/registry-validator.ts
-function makeRegistryValidator(registry) {
-  return ({ proposed, type }) => {
-    if (type === void 0) return;
-    registry.get(type)?.validate?.(proposed);
-  };
-}
-
-// src/type-aware-decision.ts
-function typeAwareDecision(base, registry) {
-  return {
-    isOpaque(value, type) {
-      if (type !== void 0) {
-        const override = registry.get(type)?.decompose;
-        if (override === "opaque") return true;
-        if (override === "children") return false;
-      }
-      return base.isOpaque(value, type);
-    }
-  };
-}
-
-// src/ids.ts
-import { randomUUID } from "crypto";
-var UuidIdGen = class {
-  next() {
-    return randomUUID();
-  }
-};
-
-// src/clock.ts
-var SystemClock = class {
-  now() {
-    return Date.now();
-  }
-};
-
-// src/vector-index-port.ts
-function normalize(v) {
-  const out = new Float32Array(v.length);
-  let n = 0;
-  for (let i = 0; i < v.length; i++) n += v[i] * v[i];
-  if (n === 0) return out;
-  const inv = 1 / Math.sqrt(n);
-  for (let i = 0; i < v.length; i++) out[i] = v[i] * inv;
-  return out;
-}
-function dot(a, b) {
-  const len = Math.min(a.length, b.length);
-  let d = 0;
-  for (let i = 0; i < len; i++) d += a[i] * b[i];
-  return d;
-}
-var MemoryVectorIndex = class {
-  vectors = /* @__PURE__ */ new Map();
-  async upsert(entries) {
-    for (const e of entries) {
-      this.vectors.set(e.nodeId, { raw: Float32Array.from(e.vector), unit: normalize(e.vector) });
-    }
-  }
-  async remove(nodeId) {
-    this.vectors.delete(nodeId);
-  }
-  async has(nodeId) {
-    return this.vectors.has(nodeId);
-  }
-  async size() {
-    return this.vectors.size;
-  }
-  async search(query, k) {
-    const q = normalize(query);
-    const hits = [];
-    for (const [nodeId, { unit }] of this.vectors) {
-      hits.push({ nodeId, score: dot(q, unit) });
-    }
-    hits.sort((a, b) => b.score - a.score);
-    return hits.slice(0, k);
-  }
-  async entries() {
-    return [...this.vectors].map(([nodeId, { raw }]) => ({ nodeId, vector: Array.from(raw) }));
-  }
-};
-
-// src/storage.ts
-async function serializeArtifact(tree, log, vectors) {
-  return {
-    version: 2,
-    rootId: tree.rootIdValue(),
-    nodes: tree.allNodes(),
-    events: [...log.entries()],
-    baseSeq: log.baseSeqValue(),
-    vectors: await vectors.entries()
-  };
-}
-async function restoreArtifact(stored, deps, vectors) {
-  const tree = ArtifactTree.fromStored(stored.nodes, stored.rootId, deps);
-  const log = EventLog.fromStored(stored.events, stored.baseSeq ?? 0);
-  await vectors.upsert(stored.vectors);
-  return { tree, log };
-}
-
-// src/delta.ts
-function parentPointer(pointer) {
-  const i = pointer.lastIndexOf("/");
-  return i <= 0 ? "" : pointer.slice(0, i);
-}
-function applyEventForward(mutator, e) {
-  switch (e.kind) {
-    case "set": {
-      if (e.path === void 0) return;
-      const opts = {};
-      if (e.nodeType !== void 0) opts.type = e.nodeType;
-      if (e.tags !== void 0) opts.tags = e.tags;
-      mutator.set({ path: e.path }, e.after ?? null, opts);
-      return;
-    }
-    case "insert": {
-      if (e.path === void 0 || e.key === null) return;
-      const opts = {};
-      if (e.nodeType !== void 0) opts.type = e.nodeType;
-      if (e.tags !== void 0) opts.tags = e.tags;
-      mutator.insert({ path: parentPointer(e.path) }, e.key, e.after ?? null, opts);
-      return;
-    }
-    case "remove":
-      if (e.path === void 0) return;
-      mutator.remove({ path: e.path });
-      return;
-    case "move":
-      if (e.fromPath === void 0 || e.toPath === void 0 || !e.to || e.to.key === null) return;
-      mutator.move({ path: e.fromPath }, { path: parentPointer(e.toPath) }, e.to.key);
-      return;
-  }
-}
-function replayForward(mutator, events) {
-  for (const e of events) applyEventForward(mutator, e);
-}
-async function persistDelta(store, log, sinceSeq) {
-  if (sinceSeq < log.baseSeqValue()) {
-    throw new InvalidOpError(
-      `persistDelta: events [${sinceSeq}, ${log.baseSeqValue()}) were compacted before being journaled`
-    );
-  }
-  const fresh = log.since(sinceSeq);
-  if (fresh.length > 0) await store.appendEvents(fresh);
-  return log.length();
-}
-async function persistCheckpoint(store, tree, log, vectors) {
-  await store.writeCheckpoint(await serializeArtifact(tree, log, vectors));
-  return log.length();
-}
-async function restoreFromDelta(store, deps, vectors) {
-  const { checkpoint, journal } = await store.loadDelta();
-  if (!checkpoint) return null;
-  const checkpointVersion = (checkpoint.baseSeq ?? 0) + checkpoint.events.length;
-  for (let i = 0; i < journal.length; i++) {
-    if (journal[i].seq !== checkpointVersion + i) {
-      throw new InvalidOpError(
-        `restoreFromDelta: journal not contiguous with checkpoint (expected seq ${checkpointVersion + i}, got ${journal[i].seq})`
-      );
-    }
-  }
-  const usedIds = new Set(checkpoint.nodes.map((n) => n.id));
-  const guardedDeps = {
-    ...deps,
-    idGen: {
-      next: () => {
-        let id = deps.idGen.next();
-        while (usedIds.has(id)) id = deps.idGen.next();
-        usedIds.add(id);
-        return id;
-      }
-    }
-  };
-  const { tree } = await restoreArtifact(checkpoint, guardedDeps, vectors);
-  const addressing = new Addressing(tree);
-  const replayLog = new EventLog();
-  const removedIds = [];
-  const mutator = new Mutator(tree, addressing, replayLog, {
-    clock: deps.clock,
-    onChange: (node) => {
-      node.meta.embedding = { state: "stale" };
-    },
-    onRemove: (id) => {
-      removedIds.push(id);
-    }
-  });
-  replayForward(mutator, journal);
-  for (const id of removedIds) await vectors.remove(id);
-  const log = EventLog.fromStored([...checkpoint.events, ...journal], checkpoint.baseSeq ?? 0);
-  return { tree, log };
-}
-
-// src/arbor.ts
-function buildDeps(opts) {
-  const base = opts.decompose ?? sizeBasedDecision(200);
-  return {
-    idGen: opts.idGen ?? new UuidIdGen(),
-    clock: opts.clock ?? new SystemClock(),
-    decision: opts.registry ? typeAwareDecision(base, opts.registry) : base
-  };
-}
-function guardIdGen(idGen, used) {
-  return {
-    next: () => {
-      let id = idGen.next();
-      while (used.has(id)) id = idGen.next();
-      used.add(id);
-      return id;
-    }
-  };
-}
-function assemble(opts, tree, log, vectors, clock, hasCheckpoint) {
-  const addressing = new Addressing(tree);
-  const index = opts.embedding ? new SemanticIndex(tree, addressing, opts.embedding, vectors, opts.registry) : void 0;
-  const mdeps = { clock };
-  if (opts.registry) mdeps.validate = makeRegistryValidator(opts.registry);
-  if (index) Object.assign(mdeps, index.hooks());
-  const mutator = new Mutator(tree, addressing, log, mdeps);
-  const replay = new Replay(tree, log);
-  let highWater = log.length();
-  let checkpointed = hasCheckpoint;
-  async function doCheckpoint(keepLast) {
-    if (!opts.delta) throw new InvalidOpError("checkpoint(): no delta storage configured");
-    if (keepLast !== void 0) log.compactTo(log.length() - keepLast);
-    highWater = await persistCheckpoint(opts.delta, tree, log, vectors);
-    checkpointed = true;
-  }
-  return {
-    tree,
-    addressing,
-    log,
-    mutator,
-    replay,
-    index,
-    vectors,
-    toolset: (binding) => makeToolset({ tree, addressing, log, mutator, index }, binding),
-    save: async () => {
-      if (!opts.storage) throw new InvalidOpError("save(): no storage configured");
-      await opts.storage.save(await serializeArtifact(tree, log, vectors));
-    },
-    saveDelta: async () => {
-      if (!opts.delta) throw new InvalidOpError("saveDelta(): no delta storage configured");
-      if (!checkpointed) {
-        await doCheckpoint();
-        return;
-      }
-      highWater = await persistDelta(opts.delta, log, highWater);
-    },
-    checkpoint: (o) => doCheckpoint(o?.keepLast)
-  };
-}
-function createArbor(opts = {}) {
-  const deps = buildDeps(opts);
-  const tree = ArtifactTree.fromJson(opts.initial ?? {}, deps);
-  const log = new EventLog();
-  const vectors = opts.vectors ?? new MemoryVectorIndex();
-  const arbor = assemble(opts, tree, log, vectors, deps.clock, false);
-  if (arbor.index) {
-    for (const node of tree.allNodes()) arbor.index.onChange(node);
-  }
-  return arbor;
-}
-async function restoreArbor(opts) {
-  const deps = buildDeps(opts);
-  const vectors = opts.vectors ?? new MemoryVectorIndex();
-  if (opts.delta) {
-    const restored = await restoreFromDelta(opts.delta, deps, vectors);
-    if (restored) return assemble(opts, restored.tree, restored.log, vectors, deps.clock, true);
-  }
-  if (opts.storage) {
-    const stored = await opts.storage.load();
-    if (stored) {
-      const guarded = {
-        ...deps,
-        idGen: guardIdGen(deps.idGen, new Set(stored.nodes.map((n) => n.id)))
-      };
-      const { tree, log } = await restoreArtifact(stored, guarded, vectors);
-      return assemble(opts, tree, log, vectors, deps.clock, false);
-    }
-  }
-  return null;
-}
+import {
+  createArbor,
+  restoreArbor
+} from "./chunk-WEO5KBRI.js";
+import "./chunk-ZDANDXJ6.js";
+import "./chunk-6DOI4FNX.js";
+import "./chunk-OZCCBVUV.js";
+import "./chunk-QRGDUGY6.js";
+import "./chunk-ZBBMJMLG.js";
+import "./chunk-XWCA5XHZ.js";
+import "./chunk-L4HFSLBD.js";
+import "./chunk-53XPRLFF.js";
+import "./chunk-YCDDDYGG.js";
+import "./chunk-U3NXJNUY.js";
+import "./chunk-AGPH62II.js";
+import "./chunk-TEJZF3IR.js";
+import "./chunk-32FKMLEA.js";
+import "./chunk-KRJCSJL4.js";
+import "./chunk-YWY2EK2Q.js";
+import "./chunk-2UY5KJ5P.js";
+import "./chunk-M72UOSPG.js";
+import "./chunk-VG5BEOBI.js";
+import "./chunk-UTJZYWK3.js";
+import "./chunk-V3HDDWER.js";
+import "./chunk-XT7WR7OF.js";
 export {
   createArbor,
   restoreArbor