tricu

tree-result.ts (2828B)

---

 import type { GraphPreview } from './graph.js';
 import type { Bundle } from './bundle.js';
 import { exportTree, type TreeFormat, type TreeFile } from './tree-export.js';
 export const RESULT_NODE_LIMIT = 100_000;
 export type TreeResultFormat = 'tricu' | 'triangle' | 'dag' | 'ternary';
 export function isTreeResult(value: string): value is TreeResultFormat {
   return ['tricu', 'triangle', 'dag', 'ternary'].includes(value);
 }
 // Backend snapshots describe physical sharing, not structural hash-consing.
 // Reject incomplete/cyclic observations instead of exporting a plausible prefix.
 export function snapshotBundle(snapshot: GraphPreview): Bundle {
   if (snapshot.truncated) throw new Error('Result snapshot exceeds 100,000 nodes; refusing a partial export');
   const aliases = new Map<number, number>(snapshot.aliases.map(a => [a.from, a.to]));
   const byId = new Map<number, GraphPreview['nodes'][number]>(snapshot.nodes.map(n => [n.id, n]));
   const resolve = (raw: number): number => {
     let id = raw; const seen = new Set<number>();
     while (aliases.has(id)) { if (seen.has(id)) throw new Error('Snapshot alias cycle'); seen.add(id); id = aliases.get(id)!; }
     return id;
   };
   const nodes: Bundle['nodes'] = [], mapped = new Map<number, number>(), active = new Set<number>();
   const root = resolve(snapshot.root), stack: Array<[number, boolean]> = [[root, false]];
   while (stack.length) {
     const [raw, leave] = stack.pop()!, id = resolve(raw);
     if (mapped.has(id)) continue;
     const node = byId.get(id); if (!node) throw new Error('Incomplete result snapshot');
     const arity = { leaf: 0, stem: 1, fork: 2 }[node.kind];
     if (arity === undefined || node.children.length !== arity) throw new Error('Invalid snapshot constructor');
     if (!leave) {
       if (active.has(id)) throw new Error('Cyclic result cannot be exported as a DAG');
       active.add(id); stack.push([id, true]);
       for (const child of [...node.children].reverse()) stack.push([child, false]);
     } else {
       active.delete(id); const cs = node.children.map(c => mapped.get(resolve(c))!);
       if (cs.some(c => c === undefined)) throw new Error('Invalid result snapshot order');
       mapped.set(id, nodes.length);
       nodes.push(node.kind === 'leaf' ? { kind: 'leaf' } : node.kind === 'stem' ? { kind: 'stem', child: cs[0]! } : { kind: 'fork', left: cs[0]!, right: cs[1]! });
     }
   }
   return { nodes, roots: [mapped.get(root)!], exports: [{ name: 'tree', root: mapped.get(root)!, kind: 'term', abi: 'arboricx.abi.tree.v1' }], metadata: {} };
 }
 export function treeResult(snapshot: GraphPreview, format: TreeResultFormat): { type: TreeResultFormat; value: string; file: TreeFile } {
   const file = exportTree(snapshotBundle(snapshot), 'tree', format as TreeFormat);
   return { type: format, value: file.text, file };
 }