tricu

browser-bridge.mjs (5639B)

---

 // Shared site's boundary validators/codecs; no JS evaluator executes programs.
 import {decodeBundle,sha256,bundleHash} from './site/bundle.js';
 import {literals,makeLiteral,outputType} from './site/codecs.js';
 import {exportTree,treeFormat} from './site/tree-export.js';
 const utf8=new TextEncoder();
 export function frame(fields){
   const values=fields.map(x=>typeof x==='string'?utf8.encode(x):x);
   const size=values.reduce((sum,x)=>sum+4+x.byteLength,0);
   if(size>16777216)throw Error('Input byte limit exceeded');
   const bytes=new Uint8Array(size),view=new DataView(bytes.buffer);let at=0;
   for(const value of values){view.setUint32(at,value.byteLength,true);at+=4;bytes.set(value,at);at+=value.byteLength;}
   return bytes;
 }
 export function dagBytes(nodes){
   if(!nodes.length||nodes.length>1000000)throw Error('DAG node limit exceeded');
   const bytes=new Uint8Array(8+nodes.length*9),view=new DataView(bytes.buffer);
   view.setUint32(0,nodes.length,true);view.setUint32(4,0,true);
   for(const [i,node] of nodes.entries()){
     const at=8+i*9;
     bytes[at]=node.kind==='leaf'?0:node.kind==='stem'?1:2;
     view.setUint32(at+1,node.kind==='stem'?node.child:node.kind==='fork'?node.left:0,true);
     view.setUint32(at+5,node.kind==='fork'?node.right:0,true);
   }
   return bytes;
 }
 export async function authenticatedBundle(buffer,hash){
   bundleHash(hash);
   if(!(buffer instanceof ArrayBuffer)||buffer.byteLength>16777216)throw Error('Bundle byte limit exceeded');
   const bytes=new Uint8Array(buffer.slice(0));
   if(await sha256(bytes)!==hash)throw Error('Bundle SHA-256 mismatch');
   return decodeBundle(bytes);
 }
 export function loadFields(bundle){return ['load',dagBytes(bundle.nodes),...bundle.exports.flatMap(e=>[e.name,String(e.root)])];}
 class DataGraph {
   constructor(){this.nodes=[{kind:'leaf'}];this.leaf=0;}
   add(node){if(this.nodes.length>=1000000)throw Error('Input DAG limit exceeded');this.nodes.push(node);return this.nodes.length-1;}
   stem(child){return this.add({kind:'stem',child});}
   fork(left,right){return this.add({kind:'fork',left,right});}
   fromTernary(text){
     const pending=[];let root;
     for(const c of text){
       if(root!==undefined)throw Error('Trailing ternary data');
       if(c==='1'||c==='2'){pending.push({arity:Number(c),children:[]});continue;}
       if(c!=='0')throw Error('Invalid ternary digit');
       let value=this.leaf;
       for(;;){
         if(!pending.length){root=value;break;}
         const frame=pending.at(-1);frame.children.push(value);
         if(frame.children.length<frame.arity)break;
         pending.pop();value=frame.arity===1?this.stem(frame.children[0]):this.fork(...frame.children);
       }
     }
     if(root===undefined||pending.length)throw Error('Truncated tree');
     return root;
   }
 }
 export function application(name,args=[]){
   if(typeof name!=='string'||!name||name.length>4096)throw Error('Invalid export name');
   const graph=new DataGraph(),roots=literals(args).map(value=>makeLiteral(graph,value));
   return [name,dagBytes(graph.nodes),...roots.map(String)];
 }
 export function evaluation(name,args,codec){const [n,...rest]=application(name,args);return ['evaluate',n,outputType(codec),...rest];}
 export function snapshotFields(name,args,limit,full=false){
   if(!Number.isInteger(limit)||limit<1||limit>(full?100000:256))throw Error('Invalid snapshot budget');
   const [n,...rest]=application(name,args);return [full?'snapshot':'preview',n,String(limit),...rest];
 }
 // Convert a COMPLETE runtime snapshot to the site's immutable DAG export input.
 // IDs are local to this snapshot; no Haskell handle or address is retained.
 export function snapshotBundle(snapshot,name){
   if(snapshot.truncated)throw Error('Snapshot limit exceeded; refusing partial export');
   const aliases=new Map(snapshot.aliases.map(a=>[a.from,a.to])),byId=new Map(snapshot.nodes.map(n=>[n.id,n]));
   const resolve=id=>{const seen=new Set();while(aliases.has(id)){if(seen.has(id))throw Error('Snapshot alias cycle');seen.add(id);id=aliases.get(id);}return id;};
   const nodes=[],mapped=new Map(),active=new Set(),root=resolve(snapshot.root),stack=[[root,false]];
   while(stack.length){
     const [raw,leave]=stack.pop(),id=resolve(raw);
     if(mapped.has(id))continue;
     const node=byId.get(id);if(!node)throw Error('Incomplete snapshot');
     if(!leave){
       if(active.has(id))throw Error('Cyclic tree cannot be exported as a DAG');
       active.add(id);stack.push([id,true]);for(const child of [...node.children].reverse())stack.push([child,false]);
     }else{
       active.delete(id);const cs=node.children.map(c=>mapped.get(resolve(c)));
       if(cs.some(c=>c===undefined))throw Error('Invalid snapshot order');
       mapped.set(id,nodes.length);nodes.push(node.kind==='leaf'?{kind:'leaf'}:node.kind==='stem'?{kind:'stem',child:cs[0]}:{kind:'fork',left:cs[0],right:cs[1]});
     }
   }
   return {nodes,roots:[mapped.get(root)],exports:[{name,root:mapped.get(root),kind:'term',abi:'arboricx.abi.tree.v1'}],metadata:{}};
 }
 export function exportedTree(bundle,name,format){return exportTree(bundle,name,treeFormat(format));}
 
 export function environmentFields(bundle,names){
   if(!Array.isArray(names)||names.length>4096||names.some(n=>typeof n!=='string'||!n||n.length>128)||new Set(names).size!==names.length)throw Error('Invalid environment bindings');
   const exports=new Map(bundle.exports.map(e=>[e.name,e.root]));
   return [dagBytes(bundle.nodes),...names.flatMap(name=>{if(!exports.has(name))throw Error('Missing environment binding '+name);return [name,String(exports.get(name))];})];
 }
 export function emptyEnvironment(){return [dagBytes([{kind:'leaf'}])];}