tricu

module-identity.js (3760B)

---

 // Native indexed import identity (ContentStore.Bundle / Wire.extractBundleRoot).
 // Hash stored DAG records in left-before-right physical-edge order.
 import { bundleHash, sha256 } from './bundle.js';
 export function moduleHash(value) { return bundleHash(value); }
 const utf8 = new TextEncoder();
 function join(parts) {
     const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
     let at = 0;
     for (const p of parts) {
         out.set(p, at);
         at += p.length;
     }
     return out;
 }
 function word(n, size = 4) {
     const out = new Uint8Array(size), view = new DataView(out.buffer);
     if (size === 8)
         view.setBigUint64(0, BigInt(n));
     else if (size === 2)
         view.setUint16(0, n);
     else
         view.setUint32(0, n);
     return out;
 }
 const string = (s) => { const b = utf8.encode(s); return join([word(b.length), b]); };
 export function indexedObject(bundle, root) {
     const ids = new Map(), rows = [], stack = [[root, false]];
     while (stack.length) {
         const [id, leave] = stack.pop();
         if (ids.has(id))
             continue;
         const node = bundle.nodes[id];
         if (!node)
             throw new Error('Missing indexed node');
         const children = node.kind === 'leaf' ? [] : node.kind === 'stem' ? [node.child] : [node.left, node.right];
         if (children.some(c => c >= id || c < 0))
             throw new Error('Invalid indexed edge');
         if (!leave) {
             stack.push([id, true]);
             for (const c of children.reverse())
                 stack.push([c, false]);
         }
         else {
             const payload = join([new Uint8Array([children.length]), ...children.map(c => word(ids.get(c)))]);
             ids.set(id, rows.length);
             rows.push(join([word(payload.length), payload]));
         }
     }
     const index = ids.get(root);
     const manifest = join([
         utf8.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(1), word(index), string('default'),
         word(1), string('root'), word(index), string('term'), string('arboricx.abi.tree.v1'),
         word(1), word(5, 2), string('arboricx'), word(0),
     ]);
     const nodes = join([word(rows.length, 8), ...rows]);
     const section = (type, at, size) => join([
         word(type), word(1, 2), word(1, 2), word(0, 2), word(0, 2), word(at, 8), word(size, 8), word(0),
     ]);
     return join([utf8.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]);
 }
 export async function moduleIdentity(bundle) {
     if (!bundle.exports.length || bundle.exports.some(e => !/^[A-Za-z_][A-Za-z0-9_?$%'.-]*$/u.test(e.name))) {
         throw new Error('Package requires a nonempty native module interface');
     }
     const hashes = new Map();
     let manifest = 'arboricx.module-manifest.v1\n';
     const escape = (s) => s.replace(/%/g, '%25').replace(/\t/g, '%09').replace(/\n/g, '%0A').replace(/\r/g, '%0D');
     for (const e of bundle.exports) {
         let hash = hashes.get(e.root);
         if (!hash) {
             hash = await sha256(join([utf8.encode('arboricx.indexed-tree.v1\0'), indexedObject(bundle, e.root)]));
             hashes.set(e.root, hash);
         }
         manifest += `export\t${escape(e.name)}\tarboricx.indexed-tree.v1\t${hash}\t${e.abi}\n`;
     }
     return moduleHash(await sha256(utf8.encode('arboricx.module-manifest.v1\0' + manifest)));
 }