tricu

site-session.mjs (11411B)

---

 // Zig's private site adapter. Only cloneable values cross the session boundary;
 // native owned handles stay here. Shared helpers validate/authenticate inputs.
 import {WasmRuntime} from './runtime.mjs';
 export async function create({base,compiler}) {
   const {bundle,codec,comp,contracts,packages,expressions,treeResults,modules,moduleBundle}=await import(new URL('dist/zig-helpers.js',base).href);
   const bytes=await bundle.fetchBytes(new URL('runtime/zig/arboricx.wasm',base));
   const g=await WasmRuntime.create(bytes,{unbounded:true});
   // The shared DAG reader's tick is JS accounting, not a native work ceiling.
   g.tick=()=>{};
   let closed=false,busy=false,definitions=new Map(),library=new Map(),expressionScope=null,compilerHash;
   let cancel;const cancelled=new Promise((_,reject)=>{cancel=reject;});cancelled.catch(()=>{});
   const alive=()=>{if(closed)throw Error('Disposed Zig session');};
   const cleanup=()=>{try{g.dispose();}catch{/* A poisoned instance is discarded, never reused. */}};
   async function exclusive(fn) {
     alive();if(busy)throw Error('Session already busy');busy=true;
     try{return await fn();}
     catch(error){if(g.poisoned||error instanceof WebAssembly.RuntimeError)closed=true;throw error;}
     finally{busy=false;if(closed)cleanup();}
   }
   function importBundle(value) {
     return g.scope(({keep})=>new Map([...bundle.loadBundle(g,value)].map(([name,h])=>[name,keep(g.retain(h))])));
   }
   const release=values=>{for(const h of values.values())g.release(h);};
   function clearDefinitions(){
     release(definitions);definitions=new Map();
     if(expressionScope)release(expressionScope);expressionScope=null;
   }
   const fetchJSON=async(name,limit)=>JSON.parse(new TextDecoder('utf-8',{fatal:true}).decode(await bundle.fetchBytes(new URL(name,base),limit)));
   function literal(value) {
     if(value.type==='string')return g.ofText(value.value);
     if(value.type==='list')return codec.list(g,value.value.map(literal));
     return codec.makeLiteral(g,value);
   }
   function view(h,type) {
     if(treeResults.isTreeResult(type))return treeResults.treeResult({...g.snapshot(h),aliases:[]},type);
     if(type==='string')return {type,value:g.toText(h)};
     if(type==='tree')return {type,value:{...g.preview(h),aliases:[]}};
     if(type==='list')return {type,value:codec.readList(g,h,32).map(x=>({...g.preview(x,8),aliases:[]}))};
     return codec.view(g,h,type);
   }
   const wait=promise=>Promise.race([promise,cancelled]);
   async function io(handle,host) {
     const [sentinel,body]=g.pair(handle);
     if(g.toText(sentinel,7)!=='tricuIO')throw Error('Missing tricuIO sentinel');
     const [version,initial]=g.pair(body);
     if(codec.readNatural(g,version)!==1n)throw Error('Unsupported tricuIO version');
     const frames=[];let action=initial,output=0;
     const names=new Map([[0n,'pure'],[1n,'bind'],[2n,'abortIO'],[10n,'putStr'],[11n,'getLine']]);
     for(let step=1;step<=128;step++) {
       alive();g.collect();
       const [tag,payload]=g.pair(action),code=codec.readNatural(g,tag),name=names.get(code);
       if(!name)throw Error(`Unsupported browser IO action ${code}`);
       const detail=code===10n?g.toText(payload):'retained value';
       await wait(host.before({step,name,detail,depth:frames.length}));alive();
       if(code===1n){const [left,continuation]=g.pair(payload);frames.push(continuation);action=left;host.after({step,name,value:'retained value'});continue;}
       if(code===2n)throw Error('Execution aborted (retained diagnostic; no payload forcing).');
       let value;
       if(code===0n)value=payload;
       else if(code===10n){output+=Array.from(detail).length;if(output>16384)throw Error('Terminal output limit exceeded');host.write(detail);value=g.leaf;}
       else {const line=await wait(host.read());alive();if(/[\r\n]/u.test(line))throw Error('Input must be one line');value=g.ofText(line,256);}
       host.after({step,name,value:'retained value'});
       if(!frames.length)return value;
       host.running();action=g.app(frames.pop(),value);
     }
     throw Error('IO action limit exceeded');
   }
   const execute=(name,args,mode,host,reader)=>exclusive(async()=>{
     const root=definitions.get(name);if(root===undefined)throw Error('Missing definition');
     args=codec.literals(args);
     if(!['pure','io'].includes(mode))throw Error('Unsupported execution mode');
     try{return await g.scopeAsync(async()=>{
       const applied=g.apply(root,args.map(literal));
       return reader(mode==='io'?await io(applied,host):applied);
     });}finally{if(!g.poisoned)g.collect();}
   });
   async function ensureCompiler(){
     if(compilerHash)return;
     const hash=comp.compilerDescriptor(await fetchJSON('compiler.json',4096)).hash;
     const next=importBundle(await bundle.fetchBundle(new URL(`/_arboricx/bundle/hash/${hash}`,base),hash,bundle.COMPILER_BUNDLE_LIMIT));
     if(!next.has(comp.COMPILER_EXPORT)){release(next);throw Error('Missing stable compiler entrypoint');}
     library=next;compilerHash=hash;
   }
   const session={
     get disposed(){return closed;},
     load(bytes,hash){return exclusive(async()=>{
       bundle.bundleHash(hash);
       if(!(bytes instanceof Uint8Array)||bytes.byteLength>bundle.BUNDLE_LIMIT)throw Error('Bundle byte limit/type');
       bytes=bytes.slice(); // Authenticate the same immutable snapshot we decode.
       if(await bundle.sha256(bytes)!==hash)throw Error('Bundle SHA-256 mismatch');
       const next=importBundle(bundle.decodeBundle(bytes));clearDefinitions();definitions=next;g.collect();
     });},
     inspectModule(source){return exclusive(async()=>{
       if(!compilerHash)throw Error('Compiler not initialized');
       return g.scope(()=>modules.stageModule(g,library,comp.sourceText(source)));
     });},
     exportModule(){return exclusive(async()=>{
       if(!definitions.size)throw Error('No compiled module');
       return g.scope(()=>moduleBundle.moduleSnapshot([...definitions.keys()],{...g.snapshot(codec.list(g,[...definitions.values()])),aliases:[]}));
     });},
     compile(source,profileName,localModules=[]){return exclusive(async()=>{
       clearDefinitions();
       if(!compilerHash)throw Error('Compiler not initialized');
       try {
         source=comp.sourceText(source);
         const staged=g.scope(()=>modules.stageModule(g,library,source));
         if(staged.native){
           const dependencies=await modules.moduleDependencies(base,staged,localModules);alive();
           const next=g.scope(({keep})=>{
             const loaded=new Map([...dependencies].map(([ref,value])=>[ref,importBundle(value)]));
             const imported=new Map();
             const qualify=library.get('source_module.sourceModuleQualified');
             if(qualify===undefined)throw Error('Missing native module compiler helper');
             for(const [ref,alias] of staged.imports){
               const values=loaded.get(ref);if(!values)throw Error('Missing module dependency');
               for(const [name,h] of values){
                 const qualified=g.scope(()=>g.toText(g.apply(qualify,[g.ofText(alias),g.ofText(name)]),4096));
                 if(imported.has(qualified))throw Error('duplicate imported name');
                 if(imported.size>=4096)throw Error('Module binding limit exceeded');
                 imported.set(qualified,h);
               }
             }
             const environment=codec.list(g,[...imported].map(([name,h])=>g.fork(g.ofText(name),h)));
             const result=g.apply(library.get(comp.COMPILER_EXPORT),[environment,g.ofText(staged.body,16384)]);
             const locals=comp.compiledDefinitions(g,result,true);
             const publicValues=modules.selectModuleExports(staged,locals,loaded);
             const own=values=>new Map([...values].map(([name,h])=>[name,keep(g.retain(h))]));
             return {public:own(publicValues),scope:own(new Map([...imported,...locals]))};
           });
           definitions=next.public;expressionScope=next.scope;
         }else{
           let support,selected;
           if(profileName!==undefined){
             selected=packages.environmentProfile(await fetchJSON('environments.json',32768),profileName);
             if(selected.compiler!==compilerHash)throw Error('Demo environment/compiler pin mismatch');
             if(selected.profile)support=await bundle.fetchBundle(new URL(`/_arboricx/bundle/hash/${selected.profile.hash}`,base),selected.profile.hash);
           }
           alive();
           definitions=g.scope(({keep})=>{
             let environment;
             if(profileName===undefined)environment=contracts.contractEnvironment(g,library);
             else {
               const values=support?importBundle(support):new Map();
               environment=codec.list(g,(selected.profile?.names??[]).map(name=>{
                 const h=values.get(name);if(h===undefined)throw Error(`Missing demo environment binding ${name}`);
                 return g.fork(g.ofText(name),h);
               }));
             }
             const result=g.apply(library.get(comp.COMPILER_EXPORT),[environment,g.ofText(source,16384)]);
             const values=comp.compiledDefinitions(g,result);
             for(const h of values.values())keep(h);
             return values;
           });
         }
         return [...definitions.keys()];
       }finally{if(!g.poisoned&&!closed)g.collect();}
     });},
     run(name,args,output,mode,host){
       output=codec.outputType(output);
       return execute(name,args,mode,host,h=>view(h,output));
     },
     runExpression(source,output,mode,host){return exclusive(async()=>{
       const unit=expressions.expressionUnit(source,(expressionScope??definitions).keys());
       output=codec.outputType(output);
       if(!['pure','io'].includes(mode))throw Error('Unsupported execution mode');
       await ensureCompiler();
       try{return await g.scopeAsync(async()=>{
         const environment=codec.list(g,[...(expressionScope??definitions)].map(([name,h])=>g.fork(g.ofText(name),h)));
         const values=comp.compiledDefinitions(g,g.apply(library.get(comp.COMPILER_EXPORT),[environment,g.ofText(unit.source,16384)]));
         if(values.size!==1||!values.has(unit.name))throw Error('Enter one expression, not a source unit');
         const result=values.get(unit.name);
         return view(mode==='io'?await io(result,host):result,output);
       });}catch(error){throw expressions.expressionDiagnostic(error);}finally{if(!g.poisoned)g.collect();}
     });},
     // Explicit, bounded full observation for independent embedding conformance;
     // never used to preserve definitions or to implement the site's Run button.
     inspect(name,args,mode,host){return execute(name,args,mode,host,h=>g.toTernary(h,1000000));},
     preview(name,limit=64){return exclusive(()=>g.scope(()=>{
       const root=definitions.get(name);if(root===undefined)throw Error('Missing definition');
       return {...g.preview(root,limit),aliases:[]};
     }));},
     collect(){alive();try{g.collect();}catch(error){if(g.poisoned)session.dispose();throw error;}},
     diagnostics(){alive();return {...g.stats(),linearMemoryBytes:g.e.memory.buffer.byteLength};},
     stats(){alive();return {backend:'zig-wasm',linearMemoryBytes:g.e.memory.buffer.byteLength};},
     dispose(){if(closed)return;closed=true;cancel(Error('Disposed Zig session'));if(!busy)cleanup();},
   };
   try {
     if(compiler)await ensureCompiler();
     return session;
   }catch(error){session.dispose();throw error;}
 }