tricu

site-session.mjs (11732B)

---

 // 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,ioV2Private,ioV2Profile,ioV2Session,ioV2Driver}=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 nextRun=0n;const lifetime=new AbortController();
   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);
   }
   async function io(handle,host,reader=x=>x) {
     const tree=ioV2Private.constructors({leaf:g.leaf,observe:g.observe.bind(g),stem:g.stem.bind(g),fork:g.fork.bind(g),app:g.app.bind(g)});
     const selected=ioV2Profile.envelope(tree,handle);
       if(!host.v2)throw Error('IO version 2 requires a structured terminal host');
       host.selected?.(2);
       if(nextRun===0xffffffffffffffffn)throw Error('Run identity exhausted');
       const run=String(++nextRun), interpreter=new ioV2Session.Session(tree,selected.action,run,roots=>g.sweepScope(roots),
         {summarize:false,steps:host.v2.stepping===true?1:128,backend:'zig-wasm'});
       return ioV2Driver.drive({run,signal:lifetime.signal,discard:()=>session.dispose(),turn:command=>{alive();return interpreter.turn(command);},view:async()=>{alive();return reader(interpreter.core.result.value);}},host);
   }
   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 mode==='io'?await io(applied,host,reader):reader(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();}
     });},
     runDefinitionIO(name,output,host){return exclusive(async()=>{
       const root=(expressionScope??definitions).get(name);if(root===undefined)throw Error('Missing definition');
       output=codec.outputType(output);
       try{return await g.scopeAsync(async()=>io(root,host,h=>view(h,output)));}finally{if(!g.poisoned)g.collect();}
     });},
     probeIO(name){return exclusive(async()=>{
       const root=(expressionScope??definitions).get(name);if(root===undefined)throw Error('Missing definition');
       try{return g.scope(()=>{
         try{ioV2Profile.envelope({observe:g.observe.bind(g)},root);return true;
         }catch(error){if(g.poisoned||error instanceof WebAssembly.RuntimeError)throw error;return false;}
       });}finally{if(!g.poisoned)g.collect();}
     });},
     inspectDefinition(name,output){return exclusive(async()=>{
       const root=(expressionScope??definitions).get(name);if(root===undefined)throw Error('Missing definition');
       output=codec.outputType(output);
       try{return g.scope(()=>view(root,output));}finally{if(!g.poisoned)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 mode==='io'?await io(result,host,h=>view(h,output)):view(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;lifetime.abort(Error('Disposed Zig session'));if(!busy)cleanup();},
   };
   try {
     if(compiler)await ensureCompiler();
     return session;
   }catch(error){session.dispose();throw error;}
 }