tricu

bundle.ts (9566B)

---

 import { Graph, type NodeId } from './graph.js';
 export type BundleHash = string & { readonly __bundleHash: unique symbol };
 export interface ExportInfo { name: string; root: number; kind: 'term'; abi: 'arboricx.abi.tree.v1'; }
 type RecordNode = { kind: 'leaf' } | { kind: 'stem'; child: number } | { kind: 'fork'; left: number; right: number };
 export interface Bundle {
   exports: ExportInfo[]; roots: number[]; nodes: RecordNode[]; metadata: Record<string, string>;
 }
 export const BUNDLE_LIMIT = 16_777_216;
 // Separate bounded profile for the explicitly selected compiler, not packages.
 export const COMPILER_BUNDLE_LIMIT = 2_097_152;
 const utf8 = new TextDecoder('utf-8', { fatal: true });
 class Reader {
   private at = 0;
   private readonly view: DataView;
   constructor(readonly bytes: Uint8Array) { this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength); }
   take(count: number): Uint8Array {
     if (!Number.isSafeInteger(count) || count < 0 || count > this.bytes.length - this.at) throw new Error('Truncated bundle field');
     const value = this.bytes.subarray(this.at, this.at + count); this.at += count; return value;
   }
   u8(): number { return this.take(1)[0]!; }
   u16(): number { const at = this.at; this.take(2); return this.view.getUint16(at); }
   u32(): number { const at = this.at; this.take(4); return this.view.getUint32(at); }
   u64(): number {
     const at = this.at; this.take(8); const n = this.view.getBigUint64(at);
     if (n > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error('Oversized u64');
     return Number(n);
   }
   string(limit = 4096): string {
     const length = this.u32(); if (length > limit) throw new Error('Bundle string limit exceeded');
     return utf8.decode(this.take(length));
   }
   count(limit = 4096): number {
     const n = this.u32(); if (n > limit) throw new Error('Bundle count limit exceeded'); return n;
   }
   end(): void { if (this.at !== this.bytes.length) throw new Error('Trailing section bytes'); }
 }
 function requireValue<T>(actual: T, expected: T, label: string): void {
   if (actual !== expected) throw new Error(`Unsupported/invalid ${label}`);
 }
 export function bundleHash(value: unknown): BundleHash {
   if (typeof value !== 'string' || !/^[0-9a-f]{64}$/u.test(value)) throw new Error('Expected 64 lowercase hexadecimal bundle hash characters');
   return value as BundleHash;
 }
 export async function sha256(bytes: Uint8Array): Promise<BundleHash> {
   // Copy into an owned ArrayBuffer: no SharedArrayBuffer boundary or mutation
   // can change the bytes being checked while validation/loading proceeds.
   const result = await crypto.subtle.digest('SHA-256', new Uint8Array(bytes));
   return bundleHash(Array.from(new Uint8Array(result), b => b.toString(16).padStart(2, '0')).join(''));
 }
 export async function fetchBytes(url: URL, limit = BUNDLE_LIMIT): Promise<Uint8Array> {
   const response = await fetch(url, { redirect: 'error', credentials: 'omit' });
   if (!response.ok) throw new Error(`Bundle fetch: HTTP ${response.status}`);
   const length = response.headers.get('content-length');
   if (length && (!/^\d+$/u.test(length) || Number(length) > limit)) {
     await response.body?.cancel(); throw new Error('Bundle download limit exceeded');
   }
   if (!response.body) throw new Error('Missing response body');
   const reader = response.body.getReader(), chunks: Uint8Array[] = []; let size = 0;
   try {
     for (;;) {
       const item = await reader.read(); if (item.done) break;
       size += item.value.length;
       if (size > limit) throw new Error('Bundle download limit exceeded');
       chunks.push(item.value);
     }
   } catch (error) { await reader.cancel().catch(() => {}); throw error; }
   finally { reader.releaseLock(); }
   const bytes = new Uint8Array(size); let offset = 0;
   for (const chunk of chunks) { bytes.set(chunk, offset); offset += chunk.length; }
   return bytes;
 }
 export async function fetchBundle(url: URL, expected: BundleHash, byteLimit = BUNDLE_LIMIT): Promise<Bundle> {
   const bytes = await fetchBytes(url, byteLimit);
   if (await sha256(bytes) !== expected) throw new Error('Bundle SHA-256 mismatch');
   return decodeBundle(bytes, byteLimit);
 }
 // Validate completely before touching the graph heap. All loops count physical
 // records/bytes, never unfolded tree occurrences. No source/JS/WASM sections run.
 export function decodeBundle(bytes: Uint8Array, byteLimit = BUNDLE_LIMIT): Bundle {
   if (bytes.length > byteLimit) throw new Error('Bundle byte limit exceeded');
   const r = new Reader(bytes);
   requireValue(utf8.decode(r.take(8)), 'ARBORICX', 'bundle magic');
   requireValue(r.u16(), 1, 'container major'); requireValue(r.u16(), 0, 'container minor');
   const count = r.count(32);
   requireValue(r.u64(), 0, 'header flags'); requireValue(r.u64(), 32, 'directory offset');
   const sections = new Map<number, Uint8Array>(), ranges: Array<[number, number]> = [];
   for (let i = 0; i < count; i++) {
     const type = r.u32(), version = r.u16(), flags = r.u16(), compression = r.u16();
     requireValue(r.u16(), 0, 'section reserved');
     const start = r.u64(), size = r.u64(); requireValue(r.u32(), 0, 'section padding');
     if (start < 32 + count * 32 || start > bytes.length || size > bytes.length - start) throw new Error('Section out of bounds');
     if (sections.has(type)) throw new Error('Duplicate section');
     if (flags & ~1) throw new Error('Unknown section flags');
     if (type === 1 || type === 2) { requireValue(version, 1, 'section version'); requireValue(compression, 0, 'compression'); }
     else if (flags & 1) throw new Error('Unknown critical section');
     ranges.push([start, start + size]); sections.set(type, bytes.subarray(start, start + size));
   }
   ranges.sort((a, b) => a[0] - b[0]); let end = 32 + count * 32;
   for (const [start, stop] of ranges) { if (start !== end) throw new Error('Overlapping/gapped sections'); end = stop; }
   if (end !== bytes.length) throw new Error('Trailing container bytes');
   const manifest = sections.get(1), nodeBytes = sections.get(2);
   if (!manifest || !nodeBytes) throw new Error('Missing required sections');
   const m = new Reader(manifest);
   requireValue(utf8.decode(m.take(8)), 'ARBMNFST', 'manifest magic');
   requireValue(m.u16(), 1, 'manifest major'); requireValue(m.u16(), 1, 'manifest minor');
   for (const expected of ['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']) requireValue(m.string(), expected, 'manifest semantics');
   requireValue(m.u32(), 0, 'runtime capabilities'); requireValue(m.u8(), 0, 'complete closure');
   const roots: number[] = [];
   for (let i = m.count(); i > 0; i--) { roots.push(m.u32()); m.string(); }
   const exports: ExportInfo[] = [], names = new Set<string>();
   for (let i = m.count(); i > 0; i--) {
     const name = m.string(512), root = m.u32();
     requireValue(m.string(), 'term', 'export kind'); requireValue(m.string(), 'arboricx.abi.tree.v1', 'export ABI');
     if (!name || names.has(name)) throw new Error('Empty/duplicate export name');
     names.add(name); exports.push({ name, root, kind: 'term', abi: 'arboricx.abi.tree.v1' });
   }
   if (!roots.length || !exports.length) throw new Error('Bundle requires roots/exports');
   const metadata: Record<string, string> = Object.create(null) as Record<string, string>;
   const tags: Record<number, string> = { 1: 'package', 2: 'version', 3: 'description', 4: 'license', 5: 'createdBy' };
   for (let i = m.count(); i > 0; i--) {
     const tag = m.u16(), length = m.u32(); if (length > 16_384) throw new Error('Metadata limit exceeded');
     const value = m.take(length), key = tags[tag];
     if (key) { if (Object.hasOwn(metadata, key)) throw new Error('Duplicate metadata'); metadata[key] = utf8.decode(value); }
   }
   for (let i = m.count(); i > 0; i--) { m.u16(); m.take(m.u32()); }
   m.end();
   const n = new Reader(nodeBytes), total = n.u64();
   if (!total || total > 100_000) throw new Error('Bundle node count limit exceeded');
   const nodes: RecordNode[] = [], keys = new Set<string>();
   for (let i = 0; i < total; i++) {
     const p = new Reader(n.take(n.u32())), tag = p.u8(); let node: RecordNode, key: string;
     const child = (): number => { const id = p.u32(); if (id >= i) throw new Error('Non-backward child reference'); return id; };
     if (tag === 0) { node = { kind: 'leaf' }; key = '0'; }
     else if (tag === 1) { const id = child(); node = { kind: 'stem', child: id }; key = `1,${id}`; }
     else if (tag === 2) { const left = child(), right = child(); node = { kind: 'fork', left, right }; key = `2,${left},${right}`; }
     else throw new Error('Unknown node tag');
     p.end(); if (keys.has(key)) throw new Error('Duplicate indexed node');
     keys.add(key); nodes.push(node);
   }
   n.end();
   for (const root of [...roots, ...exports.map(e => e.root)]) if (root >= total) throw new Error('Root index out of bounds');
   return { roots, exports, nodes, metadata };
 }
 export function loadBundle(graph: Graph, bundle: Bundle): Map<string, NodeId> {
   const handles: NodeId[] = [];
   for (const node of bundle.nodes) {
     graph.tick();
     switch (node.kind) {
       case 'leaf': handles.push(graph.leaf); break;
       case 'stem': handles.push(graph.stem(handles[node.child]!)); break;
       case 'fork': handles.push(graph.fork(handles[node.left]!, handles[node.right]!)); break;
     }
   }
   return new Map(bundle.exports.map(e => [e.name, handles[e.root]!]));
 }