tricu

module-bundle.ts (4338B)

---

 // Explicit publication boundary: snapshots observe finite constructor trees.
 // Canonical indexing preserves DAG sharing.
 import { BUNDLE_LIMIT, decodeBundle, type Bundle } from './bundle.js';
 import { snapshotBundle } from './tree-result.js';
 import type { GraphPreview } from './graph.js';
 const encoder = new TextEncoder();
 const join = (parts: Uint8Array[]): Uint8Array => {
   const length = parts.reduce((n, p) => n + p.length, 0);
   if (length > BUNDLE_LIMIT) throw new Error('Module bundle exceeds 16 MiB');
   const out = new Uint8Array(length); let at = 0;
   for (const part of parts) { out.set(part, at); at += part.length; } return out;
 };
 function word(n: number, size = 4): Uint8Array {
   const bytes = new Uint8Array(size), view = new DataView(bytes.buffer);
   if (size === 8) view.setBigUint64(0, BigInt(n));
   else if (size === 2) view.setUint16(0, n); else view.setUint32(0, n);
   return bytes;
 }
 const string = (s: string): Uint8Array => { const bytes = encoder.encode(s); return join([word(bytes.length), bytes]); };
 export function encodeModule(bundle: Bundle): Uint8Array {
   if (!bundle.exports.length || bundle.exports.length > 4096) throw new Error('Invalid module export count');
   const mapped = new Map<number, number>(), interned = new Map<string, number>(), records: number[][] = [];
   for (const entry of bundle.exports) {
     if (!/^[A-Za-z_][A-Za-z0-9_?$%'.-]*$/u.test(entry.name) || encoder.encode(entry.name).length > 512) throw new Error('Invalid module export name');
     const stack: [number, boolean][] = [[entry.root, false]];
     while (stack.length) {
       const [id, leave] = stack.pop()!; if (mapped.has(id)) continue;
       const node = bundle.nodes[id]; if (!node) throw new Error('Missing module node');
       const children = node.kind === 'leaf' ? [] : node.kind === 'stem' ? [node.child] : [node.left, node.right];
       if (children.some(c => c < 0 || c >= id)) throw new Error('Invalid module edge');
       if (!leave) { stack.push([id, true]); for (const c of [...children].reverse()) stack.push([c, false]); }
       else {
         const row = children.map(c => mapped.get(c)!), key = row.length + ':' + row.join(',');
         let index = interned.get(key);
         if (index === undefined) { index = records.length; interned.set(key, index); records.push(row); }
         if (records.length > 100_000) throw new Error('Module node limit exceeded');
         mapped.set(id, index);
       }
     }
   }
   const manifest = join([encoder.encode('ARBMNFST'), word(1, 2), word(1, 2),
     ...['arboricx.bundle.manifest.v1', 'tree-calculus-executable-object', 'tree-calculus.v1', 'indexed',
       'arboricx.indexed.node.v1', 'arboricx.indexed.payload.v1', 'tree-calculus.v1', 'normal-order', 'arboricx.abi.tree.v1'].map(string),
     word(0), new Uint8Array([0]), word(bundle.exports.length),
     ...bundle.exports.flatMap((e, i) => [word(mapped.get(e.root)!), string(i ? 'root' : 'default')]),
     word(bundle.exports.length), ...bundle.exports.flatMap(e => [string(e.name), word(mapped.get(e.root)!), string('term'), string('arboricx.abi.tree.v1')]),
     word(0), word(0)]);
   const nodes = join([word(records.length, 8), ...records.map(row => {
     const payload = join([new Uint8Array([row.length]), ...row.map(n => word(n))]); return join([word(payload.length), payload]);
   })]);
   const section = (type: number, at: number, size: number) => join([word(type), word(1, 2), word(1, 2), word(0), word(at, 8), word(size, 8), word(0)]);
   const bytes = join([encoder.encode('ARBORICX'), word(1, 2), word(0, 2), word(2), word(0, 8), word(32, 8),
     section(1, 96, manifest.length), section(2, 96 + manifest.length, nodes.length), manifest, nodes]);
   decodeBundle(bytes); // Independent reader enforces the actual portable profile.
   return bytes;
 }
 export function moduleSnapshot(names: string[], snapshot: GraphPreview): Uint8Array {
   const bundle = snapshotBundle(snapshot); let spine = bundle.roots[0]!;
   bundle.exports = names.map(name => {
     const cell = bundle.nodes[spine]; if (cell?.kind !== 'fork') throw new Error('Invalid module snapshot spine');
     spine = cell.right; return { name, root: cell.left, kind: 'term', abi: 'arboricx.abi.tree.v1' };
   });
   if (bundle.nodes[spine]?.kind !== 'leaf') throw new Error('Invalid module snapshot tail');
   return encodeModule(bundle);
 }