tricu

module-identity.ts (3826B)

---

 // Native indexed import identity (ContentStore.Bundle / Wire.extractBundleRoot).
 // Hash stored DAG records in left-before-right physical-edge order.
 import { bundleHash, sha256, type Bundle, type BundleHash } from './bundle.js';
 export type ModuleHash = string & { readonly __moduleHash: unique symbol };
 export function moduleHash(value: unknown): ModuleHash { return bundleHash(value) as string as ModuleHash; }
 const utf8 = new TextEncoder();
 function join(parts: Uint8Array[]): Uint8Array {
   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: number, size = 4): Uint8Array {
   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: string): Uint8Array => { const b = utf8.encode(s); return join([word(b.length), b]); };
 export function indexedObject(bundle: Bundle, root: number): Uint8Array {
   const ids = new Map<number, number>(), rows: Uint8Array[] = [], stack: [number, boolean][] = [[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: number, at: number, size: number): Uint8Array => 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: Bundle): Promise<ModuleHash> {
   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<number, BundleHash>();
   let manifest = 'arboricx.module-manifest.v1\n';
   const escape = (s: string): string => 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)));
 }