tricu

module-bundle.js (4625B)

---

 // Explicit publication boundary: snapshots observe finite constructor trees.
 // Canonical indexing preserves DAG sharing.
 import { BUNDLE_LIMIT, decodeBundle } from './bundle.js';
 import { snapshotBundle } from './tree-result.js';
 const encoder = new TextEncoder();
 const join = (parts) => {
     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, size = 4) {
     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) => { const bytes = encoder.encode(s); return join([word(bytes.length), bytes]); };
 export function encodeModule(bundle) {
     if (!bundle.exports.length || bundle.exports.length > 4096)
         throw new Error('Invalid module export count');
     const mapped = new Map(), interned = new Map(), records = [];
     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 = [[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, at, size) => 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, snapshot) {
     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);
 }