arborkit 1.0.0

package/dist/toolset.js

@@ -0,0 +1,306 @@
+// 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 InvalidOpError = class extends ArborError {
+  constructor(message) {
+    super("INVALID_OP", message);
+  }
+};
+
+// src/decompose.ts
+function byteSize(value) {
+  return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+
+// 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 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/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);
+    })
+  };
+}
+export {
+  makeToolset
+};
+//# sourceMappingURL=toolset.js.map

package/dist/toolset.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts","../src/decompose.ts","../src/jsonpointer.ts","../src/path-glob.ts","../src/navigator.ts","../src/toolset.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","import type { Json, NodeKind } from \"./types\";\r\n\r\n/** Policy deciding whether a value is stored whole (opaque leaf) or split into child nodes. */\r\nexport interface DecomposeDecision {\r\n  /** `type` is the optional registered node type (used by the by-type override in a later milestone). */\r\n  isOpaque(value: Json, type?: string): boolean;\r\n}\r\n\r\n/** UTF-8 byte length of the JSON serialization of a value. */\r\nexport function byteSize(value: Json): number {\r\n  return Buffer.byteLength(JSON.stringify(value), \"utf8\");\r\n}\r\n\r\n/** Structural kind of a value given whether it is being stored opaquely. */\r\nexport function kindOf(value: Json, opaque: boolean): NodeKind {\r\n  if (opaque) return \"leaf\";\r\n  return Array.isArray(value) ? \"array\" : \"object\";\r\n}\r\n\r\n/**\r\n * Default policy: scalars are always opaque leaves; containers stay opaque\r\n * while their serialized size is within `maxOpaqueBytes`, otherwise they split.\r\n */\r\nexport function sizeBasedDecision(maxOpaqueBytes: number): DecomposeDecision {\r\n  return {\r\n    isOpaque(value: Json): boolean {\r\n      if (value === null || typeof value !== \"object\") return true;\r\n      return byteSize(value) <= maxOpaqueBytes;\r\n    },\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 { parsePointer } from \"./jsonpointer\";\r\n\r\n/** Match parsed segment arrays. `*` = one segment; `**` = zero or more segments. */\r\nfunction matchSegments(pattern: string[], path: string[]): boolean {\r\n  if (pattern.length === 0) return path.length === 0;\r\n  const [head, ...rest] = pattern;\r\n  if (head === \"**\") {\r\n    for (let i = 0; i <= path.length; i++) {\r\n      if (matchSegments(rest, path.slice(i))) return true;\r\n    }\r\n    return false;\r\n  }\r\n  if (path.length === 0) return false;\r\n  if (head === \"*\" || head === path[0]) {\r\n    return matchSegments(rest, path.slice(1));\r\n  }\r\n  return false;\r\n}\r\n\r\n/**\r\n * Parse a glob `pattern` ONCE and return a reusable matcher over JSON Pointer paths.\r\n * `*` matches exactly one path segment; `**` matches zero or more segments.\r\n */\r\nexport function compileGlob(pattern: string): (path: string) => boolean {\r\n  const patternSegs = parsePointer(pattern);\r\n  return (path: string) => matchSegments(patternSegs, parsePointer(path));\r\n}\r\n\r\n/**\r\n * Glob-match a JSON Pointer `path` against a `pattern`.\r\n * `*` matches exactly one path segment; `**` matches zero or more segments.\r\n * One-shot convenience over `compileGlob` — prefer compiling when matching many paths.\r\n */\r\nexport function matchGlob(pattern: string, path: string): boolean {\r\n  return compileGlob(pattern)(path);\r\n}\r\n","import type { ArbNode, Json, NodeId, NodeKind, NodeMeta } from \"./types\";\r\nimport type { ArtifactTree } from \"./artifact-tree\";\r\nimport type { Addressing } from \"./addressing\";\r\nimport { type Ref, NodeNotFoundError } from \"./errors\";\r\nimport { byteSize } from \"./decompose\";\r\nimport { compileGlob } from \"./path-glob\";\r\nimport { isWithin, appendPointer } from \"./jsonpointer\";\r\n\r\nconst DEFAULT_LIMIT = 100;\r\nconst PREVIEW_MAX = 50;\r\n\r\nexport interface NodeSummary {\r\n  id: NodeId;\r\n  path: string;\r\n  key: string | number | null;\r\n  kind: NodeKind;\r\n  type?: string;\r\n}\r\n\r\nexport interface ChildSummary {\r\n  id: NodeId;\r\n  key: string | number | null;\r\n  kind: NodeKind;\r\n  type?: string;\r\n  hasChildren: boolean;\r\n  size: number;\r\n  preview: string;\r\n}\r\n\r\nexport interface DescribeOpts {\r\n  offset?: number;\r\n  limit?: number;\r\n}\r\n\r\nexport interface DescribeResult {\r\n  node: NodeSummary;\r\n  children: ChildSummary[];\r\n  truncated?: { shown: number; total: number; nextOffset: number };\r\n}\r\n\r\nexport interface GetOpts {\r\n  maxDepth?: number;\r\n}\r\n\r\nexport interface GetResult {\r\n  id: NodeId;\r\n  path: string;\r\n  type?: string;\r\n  content: Json;\r\n  meta: NodeMeta;\r\n  truncated?: boolean;\r\n}\r\n\r\nexport interface FindSelector {\r\n  type?: string;\r\n  tag?: string;\r\n  pathPattern?: string;\r\n}\r\n\r\nexport interface FindOpts {\r\n  limit?: number;\r\n  /** JSON Pointer prefix: only nodes at/under it are hits — checked BEFORE the\r\n   *  limit is consumed, so out-of-scope matches never eat the budget. */\r\n  within?: string;\r\n}\r\n\r\nexport interface FindHit {\r\n  id: NodeId;\r\n  path: string;\r\n  type?: string;\r\n}\r\n\r\nexport interface FindResult {\r\n  hits: FindHit[];\r\n  /** True when the walk stopped at `limit` — there MAY be more matches (an exact-fit\r\n   *  final hit also reports true). */\r\n  truncated: boolean;\r\n}\r\n\r\nfunction previewOf(node: ArbNode): string {\r\n  if (node.kind === \"leaf\") {\r\n    const s = JSON.stringify(node.content);\r\n    return s.length <= PREVIEW_MAX ? s : s.slice(0, PREVIEW_MAX) + \"…\";\r\n  }\r\n  return node.kind === \"array\" ? `[${node.childIds.length} items]` : `{${node.childIds.length} keys}`;\r\n}\r\n\r\n/** Read-only navigation over the artifact tree: describe (cheap listing) and get (bounded content). */\r\nexport class Navigator {\r\n  constructor(\r\n    private readonly tree: ArtifactTree,\r\n    private readonly addressing: Addressing,\r\n  ) {}\r\n\r\n  protected resolve(ref: Ref): ArbNode {\r\n    const node = \"id\" in ref ? this.addressing.byId(ref.id) : this.addressing.byPath(ref.path);\r\n    if (!node) throw new NodeNotFoundError(ref);\r\n    return node;\r\n  }\r\n\r\n  private summarize(node: ArbNode): ChildSummary {\r\n    return {\r\n      id: node.id,\r\n      key: node.key,\r\n      kind: node.kind,\r\n      type: node.type,\r\n      hasChildren: node.childIds.length > 0,\r\n      size: node.kind === \"leaf\" ? byteSize(node.content) : node.childIds.length,\r\n      preview: previewOf(node),\r\n    };\r\n  }\r\n\r\n  describe(ref: Ref = { path: \"\" }, opts: DescribeOpts = {}): DescribeResult {\r\n    const node = this.resolve(ref);\r\n    const all = this.tree.children(node.id);\r\n    const total = all.length;\r\n    const offset = opts.offset ?? 0;\r\n    const limit = opts.limit ?? DEFAULT_LIMIT;\r\n    const page = all.slice(offset, offset + limit);\r\n    const result: DescribeResult = {\r\n      node: {\r\n        id: node.id,\r\n        path: this.addressing.pathOf(node.id),\r\n        key: node.key,\r\n        kind: node.kind,\r\n        type: node.type,\r\n      },\r\n      children: page.map((c) => this.summarize(c)),\r\n    };\r\n    const nextOffset = offset + page.length;\r\n    if (nextOffset < total) {\r\n      result.truncated = { shown: page.length, total, nextOffset };\r\n    }\r\n    return result;\r\n  }\r\n\r\n  get(ref: Ref, opts: GetOpts = {}): GetResult {\r\n    const node = this.resolve(ref);\r\n    const maxDepth = opts.maxDepth;\r\n    let truncated = false;\r\n    const reconstruct = (id: NodeId, depth: number): Json => {\r\n      const n = this.tree.get(id)!;\r\n      if (n.kind === \"leaf\") return n.content;\r\n      if (maxDepth !== undefined && depth >= maxDepth) {\r\n        truncated = true;\r\n        const label = n.kind === \"array\" ? `${n.childIds.length} items` : `${n.childIds.length} keys`;\r\n        return `[truncated: ${label}]`;\r\n      }\r\n      if (n.kind === \"array\") return n.childIds.map((cid) => reconstruct(cid, depth + 1));\r\n      const obj: Record<string, Json> = {};\r\n      for (const cid of n.childIds) {\r\n        const c = this.tree.get(cid)!;\r\n        obj[String(c.key)] = reconstruct(cid, depth + 1);\r\n      }\r\n      return obj;\r\n    };\r\n    const content = reconstruct(node.id, 0);\r\n    const result: GetResult = {\r\n      id: node.id,\r\n      path: this.addressing.pathOf(node.id),\r\n      type: node.type,\r\n      content,\r\n      meta: node.meta,\r\n    };\r\n    if (truncated) result.truncated = true;\r\n    return result;\r\n  }\r\n\r\n  private matches(node: ArbNode, sel: FindSelector, path: string, glob?: (path: string) => boolean): boolean {\r\n    if (sel.type !== undefined && node.type !== sel.type) return false;\r\n    if (sel.tag !== undefined && !(node.tags?.includes(sel.tag) ?? false)) return false;\r\n    if (glob !== undefined && !glob(path)) return false;\r\n    return true;\r\n  }\r\n\r\n  /** Find nodes matching ALL provided selector fields (exact `type`, `tag` membership, glob `pathPattern`). */\r\n  find(selector: FindSelector, opts: FindOpts = {}): FindResult {\r\n    const limit = opts.limit ?? DEFAULT_LIMIT;\r\n    const within = opts.within;\r\n    // The pattern is parsed ONCE per find; each node's path is built incrementally\r\n    // down the DFS (no per-node pathOf walk to the root).\r\n    const glob = selector.pathPattern !== undefined ? compileGlob(selector.pathPattern) : undefined;\r\n    const hits: FindHit[] = [];\r\n    let truncated = false;\r\n    const visit = (id: NodeId, path: string): void => {\r\n      if (hits.length >= limit) {\r\n        truncated = true;\r\n        return;\r\n      }\r\n      const node = this.tree.get(id)!;\r\n      if (this.matches(node, selector, path, glob)) {\r\n        if (isWithin(path, within)) {\r\n          hits.push({ id: node.id, path, type: node.type });\r\n        }\r\n      }\r\n      for (const cid of node.childIds) {\r\n        if (hits.length >= limit) {\r\n          truncated = true;\r\n          break;\r\n        }\r\n        const child = this.tree.get(cid)!;\r\n        visit(cid, appendPointer(path, child.key as string | number));\r\n      }\r\n    };\r\n    visit(this.tree.rootIdValue(), \"\");\r\n    return { hits, truncated };\r\n  }\r\n}\r\n","import 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 { SemanticIndex } from \"./semantic-index\";\r\nimport {\r\n  Navigator,\r\n  type DescribeOpts,\r\n  type DescribeResult,\r\n  type GetOpts,\r\n  type GetResult,\r\n  type FindSelector,\r\n  type FindOpts,\r\n  type FindResult,\r\n} from \"./navigator\";\r\nimport type { SearchOpts, SearchResult } from \"./semantic-index\";\r\nimport { type Ref, ArborError, ScopeViolationError, InvalidOpError, NodeNotFoundError } from \"./errors\";\r\nimport { isWithin } from \"./jsonpointer\";\r\nimport type { Json, NodeId } from \"./types\";\r\n\r\n/** Every toolset call returns this — errors are structured, never thrown across the agent boundary. */\r\nexport type ToolResult<T> = { ok: true; value: T } | { ok: false; error: { code: string; message: string } };\r\n\r\nexport type PatchOp =\r\n  | { op: \"set\"; value: Json; ifVersion?: number }\r\n  | { op: \"insert\"; key: string | number; value: Json; ifVersion?: number }\r\n  | { op: \"remove\"; ifVersion?: number }\r\n  | { op: \"move\"; to: Ref; key: string | number; ifVersion?: number };\r\n\r\nexport interface ToolsetDeps {\r\n  tree: ArtifactTree;\r\n  addressing: Addressing;\r\n  log: EventLog;\r\n  mutator: Mutator;\r\n  index?: SemanticIndex;\r\n}\r\n\r\nexport interface ToolsetBinding {\r\n  owner?: string;\r\n  /** JSON Pointer prefix: writes must be at or under it (enforced by the Mutator). */\r\n  writeScope?: string;\r\n  /** JSON Pointer prefix: reads are confined to it. */\r\n  readScope?: string;\r\n}\r\n\r\nexport interface PatchResult {\r\n  id: NodeId;\r\n  path: string;\r\n  /** The affected node's version AFTER the op (remove: the parent's). Feed into the next ifVersion. */\r\n  version: number;\r\n}\r\n\r\nexport interface Toolset {\r\n  describe(ref?: Ref, opts?: DescribeOpts): Promise<ToolResult<DescribeResult>>;\r\n  get(ref: Ref, opts?: GetOpts): Promise<ToolResult<GetResult>>;\r\n  find(selector: FindSelector, opts?: FindOpts): Promise<ToolResult<FindResult>>;\r\n  search(query: string, opts?: SearchOpts): Promise<ToolResult<SearchResult>>;\r\n  patch(ref: Ref, op: PatchOp): Promise<ToolResult<PatchResult>>;\r\n  history(ref?: Ref, opts?: { limit?: number }): Promise<ToolResult<MutationEvent[]>>;\r\n}\r\n\r\n/** An event is within scope if any of its recorded paths is within scope. */\r\nfunction eventWithinScope(e: MutationEvent, scope: string): boolean {\r\n  if (e.path !== undefined && isWithin(e.path, scope)) return true;\r\n  if (e.toPath !== undefined && isWithin(e.toPath, scope)) return true;\r\n  if (e.fromPath !== undefined && isWithin(e.fromPath, scope)) return true;\r\n  return false;\r\n}\r\n\r\n/** Run a tool body, converting thrown errors into a structured ToolResult. */\r\nasync function run<T>(fn: () => T | Promise<T>): Promise<ToolResult<T>> {\r\n  try {\r\n    return { ok: true, value: await fn() };\r\n  } catch (e) {\r\n    if (e instanceof ArborError) return { ok: false, error: { code: e.code, message: e.message } };\r\n    const message = e instanceof Error ? e.message : String(e);\r\n    return { ok: false, error: { code: \"ERROR\", message } };\r\n  }\r\n}\r\n\r\n/** A scoped, agent-facing bundle of tools returning structured results. */\r\nexport function makeToolset(deps: ToolsetDeps, binding: ToolsetBinding = {}): Toolset {\r\n  const { tree, addressing } = deps;\r\n  const navigator = new Navigator(tree, addressing);\r\n\r\n  return {\r\n    describe: (ref, opts) =>\r\n      run(() => {\r\n        const target: Ref = ref ?? (binding.readScope !== undefined ? { path: binding.readScope } : { path: \"\" });\r\n        const r = navigator.describe(target, opts);\r\n        if (!isWithin(r.node.path, binding.readScope)) {\r\n          throw new ScopeViolationError(r.node.path, binding.readScope!);\r\n        }\r\n        return r;\r\n      }),\r\n\r\n    get: (ref, opts) =>\r\n      run(() => {\r\n        const r = navigator.get(ref, opts);\r\n        if (!isWithin(r.path, binding.readScope)) {\r\n          throw new ScopeViolationError(r.path, binding.readScope!);\r\n        }\r\n        // Deep-clone the WHOLE result: `content` (and `meta`) come from the live\r\n        // tree by reference; handing them across the agent boundary would let a\r\n        // caller mutate the artifact without an event, bypassing write-scope.\r\n        return structuredClone(r);\r\n      }),\r\n\r\n    find: (selector, opts) =>\r\n      run(() => {\r\n        if (binding.readScope !== undefined && opts?.within !== undefined && !isWithin(opts.within, binding.readScope)) {\r\n          throw new ScopeViolationError(opts.within, binding.readScope);\r\n        }\r\n        return navigator.find(selector, { ...opts, within: opts?.within ?? binding.readScope });\r\n      }),\r\n\r\n    search: (query, opts = {}) =>\r\n      run(async () => {\r\n        if (!deps.index) throw new InvalidOpError(\"no semantic index configured for this toolset\");\r\n        if (binding.readScope !== undefined && opts.under !== undefined && !isWithin(opts.under, binding.readScope)) {\r\n          throw new ScopeViolationError(opts.under, binding.readScope);\r\n        }\r\n        const under = opts.under ?? binding.readScope;\r\n        return deps.index.search(query, { ...opts, under });\r\n      }),\r\n\r\n    patch: (ref, op) =>\r\n      run<PatchResult>(() => {\r\n        const common = { owner: binding.owner, writeScope: binding.writeScope, ifVersion: op.ifVersion };\r\n        const resolve = (r: Ref) => {\r\n          const node = \"id\" in r ? addressing.byId(r.id) : addressing.byPath(r.path);\r\n          if (!node) throw new NodeNotFoundError(r);\r\n          return node;\r\n        };\r\n        switch (op.op) {\r\n          case \"set\": {\r\n            deps.mutator.set(ref, op.value, common);\r\n            const node = resolve(ref);\r\n            return { id: node.id, path: addressing.pathOf(node.id), version: node.meta.version };\r\n          }\r\n          case \"insert\": {\r\n            const id = deps.mutator.insert(ref, op.key, op.value, common);\r\n            const node = tree.get(id)!;\r\n            return { id, path: addressing.pathOf(id), version: node.meta.version };\r\n          }\r\n          case \"remove\": {\r\n            const node = resolve(ref);\r\n            const removed = { id: node.id, path: addressing.pathOf(node.id) };\r\n            const parentId = node.parentId;\r\n            deps.mutator.remove(ref, common);\r\n            const parent = parentId !== null ? tree.get(parentId) : undefined;\r\n            return { id: removed.id, path: removed.path, version: parent?.meta.version ?? 0 };\r\n          }\r\n          case \"move\": {\r\n            const node = resolve(ref);\r\n            deps.mutator.move(ref, op.to, op.key, common);\r\n            return { id: node.id, path: addressing.pathOf(node.id), version: node.meta.version };\r\n          }\r\n        }\r\n      }),\r\n\r\n    history: (ref, opts = {}) =>\r\n      run(() => {\r\n        let events = [...deps.log.entries()];\r\n        if (ref !== undefined) {\r\n          const node = \"id\" in ref ? addressing.byId(ref.id) : addressing.byPath(ref.path);\r\n          if (!node) throw new NodeNotFoundError(ref);\r\n          const path = addressing.pathOf(node.id);\r\n          if (!isWithin(path, binding.readScope)) throw new ScopeViolationError(path, binding.readScope!);\r\n          const id = node.id;\r\n          events = events.filter((e) => e.targetId === id);\r\n        } else if (binding.readScope !== undefined) {\r\n          const scope = binding.readScope;\r\n          events = events.filter((e) => eventWithinScope(e, scope));\r\n        }\r\n        return structuredClone(opts.limit !== undefined ? events.slice(-opts.limit) : events);\r\n      }),\r\n  };\r\n}\r\n"],"mappings":"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","names":[]}

package/dist/type-aware-decision.d.ts

@@ -0,0 +1,8 @@
+import { DecomposeDecision } from './decompose.js';
+import { TypeRegistry } from './type-registry.js';
+import './types.js';
+
+/** Wrap a base decision so a node's registered type can override the size heuristic. */
+declare function typeAwareDecision(base: DecomposeDecision, registry: TypeRegistry): DecomposeDecision;
+
+export { typeAwareDecision };

package/dist/type-aware-decision.js

@@ -0,0 +1,17 @@
+// 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);
+    }
+  };
+}
+export {
+  typeAwareDecision
+};
+//# sourceMappingURL=type-aware-decision.js.map

package/dist/type-aware-decision.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/type-aware-decision.ts"],"sourcesContent":["import type { Json } from \"./types\";\r\nimport type { DecomposeDecision } from \"./decompose\";\r\nimport type { TypeRegistry } from \"./type-registry\";\r\n\r\n/** Wrap a base decision so a node's registered type can override the size heuristic. */\r\nexport function typeAwareDecision(base: DecomposeDecision, registry: TypeRegistry): DecomposeDecision {\r\n  return {\r\n    isOpaque(value: Json, type?: string): boolean {\r\n      if (type !== undefined) {\r\n        const override = registry.get(type)?.decompose;\r\n        if (override === \"opaque\") return true;\r\n        if (override === \"children\") return false;\r\n      }\r\n      return base.isOpaque(value, type);\r\n    },\r\n  };\r\n}\r\n"],"mappings":";AAKO,SAAS,kBAAkB,MAAyB,UAA2C;AACpG,SAAO;AAAA,IACL,SAAS,OAAa,MAAwB;AAC5C,UAAI,SAAS,QAAW;AACtB,cAAM,WAAW,SAAS,IAAI,IAAI,GAAG;AACrC,YAAI,aAAa,SAAU,QAAO;AAClC,YAAI,aAAa,WAAY,QAAO;AAAA,MACtC;AACA,aAAO,KAAK,SAAS,OAAO,IAAI;AAAA,IAClC;AAAA,EACF;AACF;","names":[]}

package/dist/type-registry.d.ts

@@ -0,0 +1,20 @@
+import { Json } from './types.js';
+
+/** Definition of a registered node type. */
+interface TypeDef {
+    /** Validate a value about to be stored at a node of this type. Throw to reject. */
+    validate?: (value: Json) => void;
+    /** Override the size-based decomposition for nodes of this type. */
+    decompose?: "opaque" | "children";
+    /** Override the text used to embed nodes of this type. Return null to skip embedding. */
+    embedText?: (value: Json) => string | null;
+}
+/** A registry of named node types (validator + decompose override). */
+declare class TypeRegistry {
+    private readonly types;
+    register(name: string, def: TypeDef): void;
+    get(name: string): TypeDef | undefined;
+    has(name: string): boolean;
+}
+
+export { type TypeDef, TypeRegistry };

package/dist/type-registry.js

@@ -0,0 +1,17 @@
+// src/type-registry.ts
+var TypeRegistry = class {
+  types = /* @__PURE__ */ new Map();
+  register(name, def) {
+    this.types.set(name, def);
+  }
+  get(name) {
+    return this.types.get(name);
+  }
+  has(name) {
+    return this.types.has(name);
+  }
+};
+export {
+  TypeRegistry
+};
+//# sourceMappingURL=type-registry.js.map

package/dist/type-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/type-registry.ts"],"sourcesContent":["import type { Json } from \"./types\";\r\n\r\n/** Definition of a registered node type. */\r\nexport interface TypeDef {\r\n  /** Validate a value about to be stored at a node of this type. Throw to reject. */\r\n  validate?: (value: Json) => void;\r\n  /** Override the size-based decomposition for nodes of this type. */\r\n  decompose?: \"opaque\" | \"children\";\r\n  /** Override the text used to embed nodes of this type. Return null to skip embedding. */\r\n  embedText?: (value: Json) => string | null;\r\n}\r\n\r\n/** A registry of named node types (validator + decompose override). */\r\nexport class TypeRegistry {\r\n  private readonly types = new Map<string, TypeDef>();\r\n\r\n  register(name: string, def: TypeDef): void {\r\n    this.types.set(name, def);\r\n  }\r\n\r\n  get(name: string): TypeDef | undefined {\r\n    return this.types.get(name);\r\n  }\r\n\r\n  has(name: string): boolean {\r\n    return this.types.has(name);\r\n  }\r\n}\r\n"],"mappings":";AAaO,IAAM,eAAN,MAAmB;AAAA,EACP,QAAQ,oBAAI,IAAqB;AAAA,EAElD,SAAS,MAAc,KAAoB;AACzC,SAAK,MAAM,IAAI,MAAM,GAAG;AAAA,EAC1B;AAAA,EAEA,IAAI,MAAmC;AACrC,WAAO,KAAK,MAAM,IAAI,IAAI;AAAA,EAC5B;AAAA,EAEA,IAAI,MAAuB;AACzB,WAAO,KAAK,MAAM,IAAI,IAAI;AAAA,EAC5B;AACF;","names":[]}

package/dist/types.d.ts

@@ -0,0 +1,28 @@
+type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json;
+};
+type NodeId = string;
+type NodeKind = "object" | "array" | "leaf";
+interface NodeMeta {
+    version: number;
+    updatedAt: number;
+    owner?: string;
+    embedding: {
+        state: "fresh" | "stale" | "none";
+        textHash?: string;
+        vecRef?: string;
+    };
+}
+interface ArbNode {
+    id: NodeId;
+    parentId: NodeId | null;
+    key: string | number | null;
+    kind: NodeKind;
+    content: Json | null;
+    childIds: NodeId[];
+    tags?: string[];
+    type?: string;
+    meta: NodeMeta;
+}
+
+export type { ArbNode, Json, NodeId, NodeKind, NodeMeta };

package/dist/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/vector-index-port.d.ts

@@ -0,0 +1,34 @@
+import { NodeId } from './types.js';
+
+interface VectorIndexEntry {
+    nodeId: NodeId;
+    vector: number[];
+}
+interface VectorHit {
+    nodeId: NodeId;
+    score: number;
+}
+/** Stores per-node vectors and ranks by similarity. Async so DB-backed adapters
+ *  (pgvector, sqlite-vec) can implement it; the in-memory default is sync inside. */
+interface VectorIndexPort {
+    upsert(entries: VectorIndexEntry[]): Promise<void>;
+    remove(nodeId: NodeId): Promise<void>;
+    search(query: number[], k: number): Promise<VectorHit[]>;
+    has(nodeId: NodeId): Promise<boolean>;
+    size(): Promise<number>;
+    entries(): Promise<VectorIndexEntry[]>;
+}
+/** In-memory brute-force index. Vectors are stored as Float32Arrays (raw for
+ *  `entries()`, unit-normalized for search) so `search` is a plain dot product
+ *  — the cosine of two normalized vectors. Correct and simple at current scale. */
+declare class MemoryVectorIndex implements VectorIndexPort {
+    private readonly vectors;
+    upsert(entries: VectorIndexEntry[]): Promise<void>;
+    remove(nodeId: NodeId): Promise<void>;
+    has(nodeId: NodeId): Promise<boolean>;
+    size(): Promise<number>;
+    search(query: number[], k: number): Promise<VectorHit[]>;
+    entries(): Promise<VectorIndexEntry[]>;
+}
+
+export { MemoryVectorIndex, type VectorHit, type VectorIndexEntry, type VectorIndexPort };

package/dist/vector-index-port.js

@@ -0,0 +1,49 @@
+// 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) }));
+  }
+};
+export {
+  MemoryVectorIndex
+};
+//# sourceMappingURL=vector-index-port.js.map

package/dist/vector-index-port.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/vector-index-port.ts"],"sourcesContent":["import type { NodeId } from \"./types\";\r\n\r\nexport interface VectorIndexEntry {\r\n  nodeId: NodeId;\r\n  vector: number[];\r\n}\r\n\r\nexport interface VectorHit {\r\n  nodeId: NodeId;\r\n  score: number;\r\n}\r\n\r\n/** Stores per-node vectors and ranks by similarity. Async so DB-backed adapters\r\n *  (pgvector, sqlite-vec) can implement it; the in-memory default is sync inside. */\r\nexport interface VectorIndexPort {\r\n  upsert(entries: VectorIndexEntry[]): Promise<void>;\r\n  remove(nodeId: NodeId): Promise<void>;\r\n  search(query: number[], k: number): Promise<VectorHit[]>;\r\n  has(nodeId: NodeId): Promise<boolean>;\r\n  size(): Promise<number>;\r\n  entries(): Promise<VectorIndexEntry[]>;\r\n}\r\n\r\n/** Unit-normalize into a Float32Array; zero-norm vectors stay all-zeros\r\n *  (their dot with anything is 0 — matches cosine's zero-magnitude behavior). */\r\nfunction normalize(v: ArrayLike<number>): Float32Array {\r\n  const out = new Float32Array(v.length);\r\n  let n = 0;\r\n  for (let i = 0; i < v.length; i++) n += v[i] * v[i];\r\n  if (n === 0) return out;\r\n  const inv = 1 / Math.sqrt(n);\r\n  for (let i = 0; i < v.length; i++) out[i] = v[i] * inv;\r\n  return out;\r\n}\r\n\r\nfunction dot(a: Float32Array, b: Float32Array): number {\r\n  const len = Math.min(a.length, b.length);\r\n  let d = 0;\r\n  for (let i = 0; i < len; i++) d += a[i] * b[i];\r\n  return d;\r\n}\r\n\r\n/** In-memory brute-force index. Vectors are stored as Float32Arrays (raw for\r\n *  `entries()`, unit-normalized for search) so `search` is a plain dot product\r\n *  — the cosine of two normalized vectors. Correct and simple at current scale. */\r\nexport class MemoryVectorIndex implements VectorIndexPort {\r\n  private readonly vectors = new Map<NodeId, { raw: Float32Array; unit: Float32Array }>();\r\n\r\n  async upsert(entries: VectorIndexEntry[]): Promise<void> {\r\n    for (const e of entries) {\r\n      this.vectors.set(e.nodeId, { raw: Float32Array.from(e.vector), unit: normalize(e.vector) });\r\n    }\r\n  }\r\n\r\n  async remove(nodeId: NodeId): Promise<void> {\r\n    this.vectors.delete(nodeId);\r\n  }\r\n\r\n  async has(nodeId: NodeId): Promise<boolean> {\r\n    return this.vectors.has(nodeId);\r\n  }\r\n\r\n  async size(): Promise<number> {\r\n    return this.vectors.size;\r\n  }\r\n\r\n  async search(query: number[], k: number): Promise<VectorHit[]> {\r\n    const q = normalize(query);\r\n    const hits: VectorHit[] = [];\r\n    for (const [nodeId, { unit }] of this.vectors) {\r\n      hits.push({ nodeId, score: dot(q, unit) });\r\n    }\r\n    hits.sort((a, b) => b.score - a.score);\r\n    return hits.slice(0, k);\r\n  }\r\n\r\n  async entries(): Promise<VectorIndexEntry[]> {\r\n    return [...this.vectors].map(([nodeId, { raw }]) => ({ nodeId, vector: Array.from(raw) }));\r\n  }\r\n}\r\n"],"mappings":";AAyBA,SAAS,UAAU,GAAoC;AACrD,QAAM,MAAM,IAAI,aAAa,EAAE,MAAM;AACrC,MAAI,IAAI;AACR,WAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,IAAK,MAAK,EAAE,CAAC,IAAI,EAAE,CAAC;AAClD,MAAI,MAAM,EAAG,QAAO;AACpB,QAAM,MAAM,IAAI,KAAK,KAAK,CAAC;AAC3B,WAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,IAAK,KAAI,CAAC,IAAI,EAAE,CAAC,IAAI;AACnD,SAAO;AACT;AAEA,SAAS,IAAI,GAAiB,GAAyB;AACrD,QAAM,MAAM,KAAK,IAAI,EAAE,QAAQ,EAAE,MAAM;AACvC,MAAI,IAAI;AACR,WAAS,IAAI,GAAG,IAAI,KAAK,IAAK,MAAK,EAAE,CAAC,IAAI,EAAE,CAAC;AAC7C,SAAO;AACT;AAKO,IAAM,oBAAN,MAAmD;AAAA,EACvC,UAAU,oBAAI,IAAuD;AAAA,EAEtF,MAAM,OAAO,SAA4C;AACvD,eAAW,KAAK,SAAS;AACvB,WAAK,QAAQ,IAAI,EAAE,QAAQ,EAAE,KAAK,aAAa,KAAK,EAAE,MAAM,GAAG,MAAM,UAAU,EAAE,MAAM,EAAE,CAAC;AAAA,IAC5F;AAAA,EACF;AAAA,EAEA,MAAM,OAAO,QAA+B;AAC1C,SAAK,QAAQ,OAAO,MAAM;AAAA,EAC5B;AAAA,EAEA,MAAM,IAAI,QAAkC;AAC1C,WAAO,KAAK,QAAQ,IAAI,MAAM;AAAA,EAChC;AAAA,EAEA,MAAM,OAAwB;AAC5B,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA,EAEA,MAAM,OAAO,OAAiB,GAAiC;AAC7D,UAAM,IAAI,UAAU,KAAK;AACzB,UAAM,OAAoB,CAAC;AAC3B,eAAW,CAAC,QAAQ,EAAE,KAAK,CAAC,KAAK,KAAK,SAAS;AAC7C,WAAK,KAAK,EAAE,QAAQ,OAAO,IAAI,GAAG,IAAI,EAAE,CAAC;AAAA,IAC3C;AACA,SAAK,KAAK,CAAC,GAAG,MAAM,EAAE,QAAQ,EAAE,KAAK;AACrC,WAAO,KAAK,MAAM,GAAG,CAAC;AAAA,EACxB;AAAA,EAEA,MAAM,UAAuC;AAC3C,WAAO,CAAC,GAAG,KAAK,OAAO,EAAE,IAAI,CAAC,CAAC,QAAQ,EAAE,IAAI,CAAC,OAAO,EAAE,QAAQ,QAAQ,MAAM,KAAK,GAAG,EAAE,EAAE;AAAA,EAC3F;AACF;","names":[]}

package/dist/zod-adapter.d.ts

@@ -0,0 +1,13 @@
+import { Json } from './types.js';
+
+/** Structural shape of a parser (e.g. a Zod schema). Avoids hard-coupling Arbor to a Zod version. */
+interface ParseSchema {
+    parse(value: unknown): unknown;
+}
+/**
+ * Build a `TypeDef.validate` function from any Zod-compatible schema (anything with `.parse()`).
+ * Throws `ValidationError` (wrapping the parser's error message) when the value is invalid.
+ */
+declare function zodValidate(schema: ParseSchema, typeName?: string): (value: Json) => void;
+
+export { type ParseSchema, zodValidate };

package/dist/zod-adapter.js

@@ -0,0 +1,34 @@
+// src/errors.ts
+var ArborError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = new.target.name;
+  }
+  code;
+};
+var ValidationError = class extends ArborError {
+  constructor(type, details) {
+    super("VALIDATION_ERROR", `Validation failed${type ? ` for type ${type}` : ""}: ${details}`);
+    this.type = type;
+    this.details = details;
+  }
+  type;
+  details;
+};
+
+// src/zod-adapter.ts
+function zodValidate(schema, typeName) {
+  return (value) => {
+    try {
+      schema.parse(value);
+    } catch (err) {
+      const details = err instanceof Error ? err.message : String(err);
+      throw new ValidationError(typeName, details);
+    }
+  };
+}
+export {
+  zodValidate
+};
+//# sourceMappingURL=zod-adapter.js.map

package/dist/zod-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts","../src/zod-adapter.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","import type { Json } from \"./types\";\r\nimport { ValidationError } from \"./errors\";\r\n\r\n/** Structural shape of a parser (e.g. a Zod schema). Avoids hard-coupling Arbor to a Zod version. */\r\nexport interface ParseSchema {\r\n  parse(value: unknown): unknown;\r\n}\r\n\r\n/**\r\n * Build a `TypeDef.validate` function from any Zod-compatible schema (anything with `.parse()`).\r\n * Throws `ValidationError` (wrapping the parser's error message) when the value is invalid.\r\n */\r\nexport function zodValidate(schema: ParseSchema, typeName?: string): (value: Json) => void {\r\n  return (value: Json) => {\r\n    try {\r\n      schema.parse(value);\r\n    } catch (err) {\r\n      const details = err instanceof Error ? err.message : String(err);\r\n      throw new ValidationError(typeName, details);\r\n    }\r\n  };\r\n}\r\n"],"mappings":";AAKO,IAAM,aAAN,cAAyB,MAAM;AAAA,EACpC,YACkB,MAChB,SACA;AACA,UAAM,OAAO;AAHG;AAIhB,SAAK,OAAO,WAAW;AAAA,EACzB;AAAA,EALkB;AAMpB;AAiCO,IAAM,kBAAN,cAA8B,WAAW;AAAA,EAC9C,YACkB,MACA,SAChB;AACA,UAAM,oBAAoB,oBAAoB,OAAO,aAAa,IAAI,KAAK,EAAE,KAAK,OAAO,EAAE;AAH3E;AACA;AAAA,EAGlB;AAAA,EAJkB;AAAA,EACA;AAIpB;;;ACzCO,SAAS,YAAY,QAAqB,UAA0C;AACzF,SAAO,CAAC,UAAgB;AACtB,QAAI;AACF,aAAO,MAAM,KAAK;AAAA,IACpB,SAAS,KAAK;AACZ,YAAM,UAAU,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;AAC/D,YAAM,IAAI,gBAAgB,UAAU,OAAO;AAAA,IAC7C;AAAA,EACF;AACF;","names":[]}