stillmade-sdk 0.1.4 → 0.1.5

package/packages/block-platform/workspace-input-readset.js

@@ -42,12 +42,24 @@ export async function captureWorkspaceInputReadSet({manifest,input,project,scope
    documents.set(nativeScope,document);ports.push({key,context:port.context,scope:nativeScope,inputDigest:await digest(input[key])});}
  }
  assert(Array.isArray(consumedOutputs)&&consumedOutputs.length<=128,'CONFLICT','Too many consumed output receipts.');
- const collectionOutputs=collections.flatMap(row=>row.consumedOutputs);
+ const browserMaterials=[],collectionOutputs=collections.flatMap(row=>row.consumedOutputs);
  assert(collectionOutputs.length+consumedOutputs.length<=128,'CONFLICT','Too many consumed output receipts.');
  for(const consumed of [...consumedOutputs,...collectionOutputs]){
   const {key,record,port,placementId,value,consumedValue}=consumed;
   // Context resolution, user answers and optional branches can replace a wire.
   if((manifest.inputs?.[key]?.context&&!collectionOutputs.includes(consumed))||input[key]===undefined||stableStringify(input[key])!==stableStringify(consumedValue))continue;
+  // This is a source selector, never an execution attestation. Acceptance
+  // independently checks the completed project ledger under its transaction.
+  if(record?.applicationReceipt){
+   const node=project.canvas?.nodes?.find(node=>node.id===placementId),data=node?.data,receipt=record.applicationReceipt;
+   const matches=data?.blockPackage?.manifest?.runtime==='browser-application'&&data.blockStale!==true&&bounded(port)&&bounded(record.runId)&&
+    receipt.phase==='completed'&&receipt.packageDigest===data.blockDigest&&receipt.inputDigest===record.inputDigest&&receipt.outputDigest===await digest(data.blockOutputs??{})&&
+    (record.packageDigest??record.digest)===data.blockDigest&&stableStringify(data.blockLastRun?.applicationReceipt??null)===stableStringify(receipt)&&
+    data.blockLastRun?.runId===record.runId&&stableStringify(data.blockLastRun?.applicationCheckpoint??null)===stableStringify(record.applicationCheckpoint??null)&&
+    stableStringify(data.blockApplicationDraft??null)===stableStringify(record.applicationCheckpoint?.draft??null)&&stableStringify(data.blockOutputs?.[port]??null)===stableStringify(value);
+   if(matches){browserMaterials.push({key,value:input[key],readSet:createWorkspaceReadSet([await workspaceSourceRead('canvas',project.canvas,['nodes',{id:placementId},'data'])]),documents:{canvas:project.canvas}});continue;}
+   unprotected.push({key,context:'upstream',reason:'missing-original-output-receipt'});continue;
+  }
   const original=record?.workspaceInputReads;
   if(original?.version!==2||!original.outputDigests||hasUnprovenStateOutput(record)){unprotected.push({key,context:'upstream',reason:'missing-original-output-receipt'});continue;}
   validateWorkspaceInputReadSet(original,{runId:record.runId,packageDigest:record.packageDigest??record.digest,inputDigest:record.inputDigest});
@@ -58,15 +70,16 @@ export async function captureWorkspaceInputReadSet({manifest,input,project,scope
  const reads=[];for(const [nativeScope,document] of documents)reads.push(await workspaceSourceRead(nativeScope,document,[]));
  const directReadSet=reads.length?createWorkspaceReadSet(reads):null;
  for(const collection of collections)for(const [scope,document] of Object.entries(collection.documents)){if(documents.has(scope))assert(stableStringify(documents.get(scope))===stableStringify(document),'CONFLICT','Original collection and context documents disagree.');else documents.set(scope,structuredClone(document));}
- const materialReads=[];assert(Array.isArray(materialSources)&&materialSources.length<=128,'CONFLICT','Too many material input sources.');
- for(const material of materialSources){const {key,value,readSet,documents:originalDocuments}=material;assert(bounded(key)&&Object.hasOwn(manifest.inputs,key)&&input[key]!==undefined&&stableStringify(input[key])===stableStringify(value)&&plain(originalDocuments),'CONFLICT','The material source no longer matches its consumed input.');validateWorkspaceReadSet(readSet);await assertWorkspaceReadSet(new Map(Object.entries(originalDocuments)),readSet);
+ const materialReads=[];assert(Array.isArray(materialSources)&&materialSources.length+browserMaterials.length<=128,'CONFLICT','Too many material input sources.');
+ for(const material of [...materialSources,...browserMaterials]){const {key,value,readSet,documents:originalDocuments}=material;assert(bounded(key)&&Object.hasOwn(manifest.inputs,key)&&input[key]!==undefined&&stableStringify(input[key])===stableStringify(value)&&plain(originalDocuments),'CONFLICT','The material source no longer matches its consumed input.');validateWorkspaceReadSet(readSet);await assertWorkspaceReadSet(new Map(Object.entries(originalDocuments)),readSet);
   const usedScopes=new Set(readSet.reads.map(read=>read.scope));assert(Object.keys(originalDocuments).every(nativeScope=>usedScopes.has(nativeScope)),'CONFLICT','Material documents include an unused source.');
   for(const [nativeScope,document] of Object.entries(originalDocuments)){if(documents.has(nativeScope))assert(stableStringify(documents.get(nativeScope))===stableStringify(document),'CONFLICT','Original material and context documents disagree.');else documents.set(nativeScope,structuredClone(document));}
   materialReads.push({key,inputDigest:await digest(input[key]),readSet:structuredClone(readSet)});
  }
  const memory=await captureWorkspaceStateSource({manifest,state,source:stateSource,packageDigest});if(memory)unprotected.push(...memory.unprotected);else if(manifest.state)unprotected.push({key:'memory',context:'state',reason:'missing-original-state-receipt'});
  const collectionReads=collections.map(({documents:ignored,consumedOutputs:ignoredOutputs,...row})=>row);
- const evidence={version:2,runId,packageDigest,inputDigest,...(memory?{stateSource:memory}:{}),...(collectionReads.length?{collections:collectionReads}:{}),dispatchInputDigest:await digest(input),ports,unprotected,inherited,...(materialReads.length?{materialSources:materialReads}:{}),directReadSet,readSet:unionReads([directReadSet,memory?.readSet,...inherited.map(row=>row.readSet),...materialReads.map(row=>row.readSet),...collectionReads.map(row=>row.readSet)])};
+ const inputDigests=Object.fromEntries(await Promise.all(Object.keys(manifest.inputs??{}).filter(key=>input[key]!==undefined).map(async key=>[key,await digest(input[key])])));
+ const evidence={version:2,runId,packageDigest,inputDigest,inputDigests,...(memory?{stateSource:memory}:{}),...(collectionReads.length?{collections:collectionReads}:{}),dispatchInputDigest:await digest(input),ports,unprotected,inherited,...(materialReads.length?{materialSources:materialReads}:{}),directReadSet,readSet:unionReads([directReadSet,memory?.readSet,...inherited.map(row=>row.readSet),...materialReads.map(row=>row.readSet),...collectionReads.map(row=>row.readSet)])};
  validateWorkspaceInputReadSet(evidence,{runId,packageDigest,inputDigest});return {evidence,documents:Object.fromEntries(documents)};
 }
 function validateDerivedPorts(ports){
@@ -83,6 +96,7 @@ export function validateWorkspaceInputReadSet(evidence,{runId,packageDigest,inpu
  if(direct)validateWorkspaceReadSet(direct);
  assert(scopes.size===(direct?.reads.length||0)&&new Set((direct?.reads||[]).map(read=>read.scope)).size===scopes.size&&(direct?.reads||[]).every(read=>scopes.has(read.scope)&&read.path.length===0),'CONFLICT','The native workspace source reads are incomplete.');
  if(evidence.version===2){
+  if(evidence.inputDigests!==undefined)assert(plain(evidence.inputDigests)&&Object.keys(evidence.inputDigests).length<=128&&Object.entries(evidence.inputDigests).every(([key,value])=>bounded(key)&&hash(value)),'CONFLICT','Dispatched input digests are invalid.');
   assert(Array.isArray(evidence.inherited)&&evidence.inherited.length<=128,'CONFLICT','Inherited source receipts are invalid.');
   for(const row of evidence.inherited){const source=row?.source;assert(plain(row)&&bounded(row.key)&&hash(row.inputDigest)&&plain(source)&&['placementId','port','runId'].every(key=>bounded(source[key]))&&['packageDigest','inputDigest','outputDigest','receiptDigest'].every(key=>hash(source[key]))&&Array.isArray(row.unprotected)&&row.unprotected.length<=128,'CONFLICT','Inherited output identity is invalid.');if(source.batchInventoryDigest!==undefined)assert(hash(source.batchInventoryDigest),'CONFLICT','Invalid inherited batch inventory identity.');if(row.readSet)validateWorkspaceReadSet(row.readSet);}
   if(evidence.stateSource){validateWorkspaceStateSource(evidence.stateSource);assert(evidence.stateSource.unprotected.every(marker=>evidence.unprotected.some(row=>stableStringify(row)===stableStringify(marker))),'CONFLICT','Memory uncertainty cannot be removed from its output evidence.');}

package/packages/block-sdk/admission.js

@@ -1,3 +1,5 @@
+import {reviewResolverContract} from './resolver-admission.js';
+export {reviewResolverContract} from './resolver-admission.js';
 import {checkExportPolicy} from './export-admission.js';
 import {blockRemixPolicy} from './remix-policy.js';
 import {initialBlockState,validateBlockState} from './state.js';
@@ -12,6 +14,7 @@ import {reviewModelPortability} from './model-portability.js';
 import {sharedAgentControls} from './shared-agent-controls.js';
 import {assert,safeDocument,digest,sdkCompatibility,HOSTED_OPERATION_NAMES} from './contracts.js';
 import {validatePackage,testPackage} from './testing.js';
+import {NATIVE_APPLICATION_RUNTIME_REQUIREMENT} from './native-application-package.js';
 
 const hostOperations=HOSTED_OPERATION_NAMES;
 const credential=/\b(?:API_KEY|ACCESS_TOKEN|AUTH_TOKEN|CLIENT_SECRET|SECRET_KEY|[A-Z][A-Z0-9_]{1,}_(?:API_KEY|ACCESS_TOKEN|AUTH_TOKEN|TOKEN|SECRET|SECRET_KEY))\b/g;
@@ -70,27 +73,12 @@ function reviewAgentControlContract(pkg){
  const hosted=['capability','comfyui'].includes(manifest.runtime),desktopTools=(manifest.desktopTools||[]).map(tool=>({id:tool.id,adapterVersion:tool.adapterVersion,actions:[...tool.actions]}));
  return {...base,passed:true,manual:{schemaVersion:1,contract:'block-agent-json/1',block:{id:manifest.id,version:manifest.version,runtime:manifest.runtime,description:manifest.description},inputs:{json,media,context,fields:inputFields},outputs:{names:outputs,fields:outputFields},sharedView:{fields:sharedFields,dynamicFields:'Existing SDK-authored shared fields are discoverable at runtime and retain their current JSON shape.'},controls:{inspect:'inspect_app',setJsonInput:'set_input',setSharedControl:'set_shared_control',selectMedia:'select_media',selectMediaList:'select_media_list',execute:hosted?'review_generation':'run',receipt:'get_app_action',...(desktopTools.length?{desktopTools}: {})},execution:{reviewRequired:true,hostedIntegrationReview:hosted,desktopRequired:desktopTools.length>0}},message:`The host can derive exact chat and MCP controls from the pinned manifest: ${json.length} JSON input${json.length===1?'':'s'}, ${media.length} permission-checked media input${media.length===1?'':'s'}, ${context.length} host-supplied context input${context.length===1?'':'s'}, ${sharedFields.length} declared shared view control${sharedFields.length===1?'':'s'}, ${desktopTools.length} approved desktop tool${desktopTools.length===1?'':'s'}, and ${outputs.length} described output${outputs.length===1?'':'s'}. Runtime validation remains authoritative; package code cannot add hidden tools.`};
 }
-function reviewResolverContract(pkg){
- const base={name:'Input/output resolver contract',runtimeVerified:false,contract:'semantic-resolver/1'},manifest=pkg?.manifest||{},issues=[];
- for(const [name,port] of Object.entries(manifest.inputs||{})){
-  if(typeof port?.semantic!=='string')issues.push(`${name} input needs an exact semantic meaning`);
-  if(typeof port?.required!=='boolean')issues.push(`${name} input must declare whether it is required`);
-  if(typeof port?.description!=='string'||!port.description.trim())issues.push(`${name} input needs a purpose/format description`);
- }
- for(const [name,port] of Object.entries(manifest.outputs||{})){
-  if(typeof port?.semantic!=='string')issues.push(`${name} output needs an exact semantic meaning`);
-  if(typeof port?.description!=='string'||!port.description.trim())issues.push(`${name} output needs a result description`);
-  if(['json','object'].includes(port?.type?.replace(/\[\]$/,''))){if(port.schema==null)issues.push(`${name} output needs a declared field schema for safe resolution`);else if(JSON.stringify(port.schema).length>4000)issues.push(`${name} output schema exceeds the resolver manual limit`);}
- }
- if(issues.length)return {...base,passed:false,code:'RESOLVER_CONTRACT',issues:issues.slice(0,20),message:`Import is blocked until every input and output can participate in typed resolution: ${issues.slice(0,8).join('; ')}${issues.length>8?`; ${issues.length-8} more`:''}. Physical JSON types alone do not establish compatible meaning.`};
- const inputs=Object.entries(manifest.inputs||{}).map(([name,port])=>({name,type:port.type,semantic:port.semantic,required:port.required,sources:port.sources||[]}));
- const outputs=Object.entries(manifest.outputs||{}).map(([name,port])=>({name,type:port.type,semantic:port.semantic}));
- return {...base,passed:true,manual:{inputs,outputs},message:`All ${inputs.length} input${inputs.length===1?'':'s'} and ${outputs.length} output${outputs.length===1?'':'s'} declare physical types, semantic meanings and descriptions. Workflow composition must still validate each exact output-to-input pair, schema, adapter pin and required permission.`};
-}
+
 
 // Conservative admission checks supplement (never replace) the isolated runtime.
 // Parse source as data; no module loader, package manager, eval or shell is used.
 export function scanPackageSource(pkg) {
+ assert(pkg?.manifest?.runtime!=='native-application','NATIVE_APPLICATION_RUNTIME_UNAVAILABLE',NATIVE_APPLICATION_RUNTIME_REQUIREMENT);
  const exports=checkExportPolicy(pkg);
  if(!exports.passed)return {passed:false,results:[exports]};
  validatePackage(pkg);

package/packages/block-sdk/agent-inputs.js

@@ -21,6 +21,8 @@ export function parseAgentInput(manifest,args,{locked=[],busy=false,disabled=fal
  const port=manifest.inputs?.[args.field];
  if(busy||disabled||!port||port.context||locked.includes(args.field))throw new Error('This input is locked or the Block is busy.');
  if(!editable.has(port.type))throw new Error('Use the matching media or project-item control for this input.');
+ // A script or brief takes plain text too, stored the way its text control stores it.
+ if(['script','brief'].includes(port.type)&&typeof args.value==='string')args={...args,value:{schemaVersion:1,text:args.value}};
  safeDocument(args.value);
  if(JSON.stringify(args.value).length>20000||Array.isArray(args.value)&&args.value.length>100||!valueMatches(args.value,port))throw new Error('Use a compatible value with at most 100 list items and 20,000 characters.');
  const control=manifest.ui?.find(row=>row.port===args.field);

package/packages/block-sdk/agent-inspection.js

@@ -26,7 +26,9 @@ export function inspectAgentValue(value, port = {type:'json'}, {mediaVerified =
   return {status:text !== undefined ? (text.trim()?'filled':'empty') : keys.length?'filled':'empty', filled:text !== undefined ? !!text.trim() : keys.length>0, fields:keys.length};
 }
 
-export function inspectAgentPorts(ports = {}, values = {}, {offset=0, limit=30, locked=[],canonicalOrder=false} = {}) {
+// `verifiedMedia` names ports whose media StillMade itself recorded for the
+// current run (a media receipt), so their availability reads as verified.
+export function inspectAgentPorts(ports = {}, values = {}, {offset=0, limit=30, locked=[],canonicalOrder=false,verifiedMedia=[]} = {}) {
   const entries = canonicalOrder?agentInputEntries({inputs:plain(ports)?ports:{}}):Object.entries(plain(ports) ? ports : {});
   const start = Math.max(0,Math.trunc(offset)||0), count = Math.max(1,Math.min(50,Math.trunc(limit)||30));
   let schemaBudget=12000;
@@ -34,7 +36,7 @@ export function inspectAgentPorts(ports = {}, values = {}, {offset=0, limit=30,
     const declared = plain(port) ? port : {type:'json'};
     const hasValue = Object.hasOwn(values || {},id), hasDefault = Object.hasOwn(declared,'default');
     const value = hasValue ? values[id] : hasDefault ? declared.default : undefined;
-    const state = inspectAgentValue(value,declared);
+    const state = inspectAgentValue(value,declared,{mediaVerified:verifiedMedia.includes(id)});
     const schema=declared.schema==null?null:structuredClone(declared.schema),schemaText=schema==null?'':JSON.stringify(schema);
     const includeSchema=schemaText&&schemaText.length<=Math.min(4000,schemaBudget);if(includeSchema)schemaBudget-=schemaText.length;
     return {id,type:declared.type || 'unknown',required:declared.required!==false,...(typeof declared.description==='string'&&declared.description.trim()?{description:declared.description.slice(0,240)}:{}),...(typeof declared.semantic==='string'?{semantic:declared.semantic.slice(0,80)}:{}),...(typeof declared.role==='string'?{role:declared.role.slice(0,80)}:{}),...(Array.isArray(declared.accepts)?{accepts:declared.accepts.filter(item=>typeof item==='string').slice(0,12)}:{}),...(Number.isFinite(declared.min)?{min:declared.min}:{}),...(Number.isFinite(declared.max)?{max:declared.max}:{}),...(declared.primary===true?{primary:true}:{}),...(includeSchema?{schema}:schemaText?{schemaPartial:true}:{}),source:declared.context?'project':hasValue?'provided':hasDefault?'default':'unset',locked:!!declared.context || locked.includes(id),...state};

package/packages/block-sdk/browser-application-artifacts.js

@@ -47,7 +47,7 @@ function sourceManifest(manifest){
  check(plain(manifest)&&manifest.runtime==='browser-application','APPLICATION_SOURCE_REFERENCE','Use a browser application manifest.');
  const errors=validateManifest(manifest).errors.filter(error=>error.path!=='runtime');
  check(errors.length===0,'APPLICATION_SOURCE_REFERENCE','Invalid application manifest: '+JSON.stringify(errors));
- check(!manifest.id.startsWith('sm.')&&manifest.platforms?.desktop?.supported===true&&manifest.platforms?.browser?.supported===false&&manifest.platforms?.phone?.supported===false,'APPLICATION_SOURCE_REFERENCE','This reference profile requires a non-platform, desktop-only browser application.');
+ check(!manifest.id.startsWith('sm.')&&manifest.platforms?.desktop?.supported===true&&typeof manifest.platforms?.browser?.supported==='boolean'&&manifest.platforms?.phone?.supported===false,'APPLICATION_SOURCE_REFERENCE','This reference profile requires a non-platform browser application with explicit browser availability and no phone build.');
  check(manifest.entry===undefined||manifest.entry==='src/application.json','APPLICATION_SOURCE_REFERENCE','Use the canonical application source entry.');
  check(!manifest.desktopTools&&!manifest.permissions.desktop?.length&&!manifest.permissions.capabilities?.length&&!manifest.permissions.actions?.length,'APPLICATION_SOURCE_REFERENCE','Application references cannot add desktop, paid integration or arbitrary action access.');
 }

package/packages/block-sdk/browser-application-execution.d.ts

@@ -1,5 +1,5 @@
 import type {Manifest} from './index.js';
-import type {BrowserApplicationBundle,BrowserApplicationOperation,BrowserApplicationDeepReadonly,BROWSER_APPLICATION_PROFILE} from './browser-application.js';
+import type {BrowserApplicationBundle,BrowserApplicationOperation,BrowserApplicationDeepReadonly} from './browser-application.js';
 
 /** Deliberately separate from the installable Manifest/BlockPackage unions. */
 export type BrowserApplicationManifest=Omit<Manifest,'runtime'|'state'|'jobs'|'desktopTools'|'permissions'|'platforms'>&{
@@ -11,7 +11,7 @@ export interface BrowserApplicationSource {manifest:BrowserApplicationManifest;a
 export interface BrowserApplicationExecutionContext {operation:string;state:Record<string,unknown>;stateRevision:string;interactive?:boolean}
 export type BrowserApplicationMountContext=Pick<BrowserApplicationExecutionContext,'state'|'stateRevision'>;
 export interface BrowserApplicationRequest {
- schemaVersion:1;phase:'execute'|'mount';requestId:string;profile:typeof BROWSER_APPLICATION_PROFILE;
+ schemaVersion:1;phase:'execute'|'mount';requestId:string;profile:BrowserApplicationBundle['profile'];
  packageDigest:string;bundleDigest:string;inputDigest:string;stateDigest:string;stateRevision:string;
  operation:BrowserApplicationOperation|null;lifecycle:'interactive'|'headless';
 }

package/packages/block-sdk/browser-application-execution.js

@@ -1,5 +1,5 @@
 import {assert,plain,safeDocument,validateManifest,validateValues,validateBlockOutputs,digest,stableStringify} from './contracts.js';
-import {defineBrowserApplication,BROWSER_APPLICATION_PROFILE,BROWSER_APPLICATION_LIMITS} from './browser-application.js';
+import {defineBrowserApplication,BROWSER_APPLICATION_LIMITS} from './browser-application.js';
 
 const exact=(value,keys)=>plain(value)&&Object.keys(value).length===keys.length&&keys.every(key=>Object.hasOwn(value,key));
 const bounded=(value,label)=>{safeDocument(value);assert(new TextEncoder().encode(JSON.stringify(value)).length<=BROWSER_APPLICATION_LIMITS.messageBytes,'LIMIT',`${label} exceeds 4 MiB.`);};
@@ -8,9 +8,10 @@ const text=value=>typeof value==='string'&&value.trim()===value&&value.length>0&
 const freeze=value=>{if(value&&typeof value==='object'){Object.values(value).forEach(freeze);Object.freeze(value);}return value;};
 const verifiedSources=new WeakSet(),preparedRequests=new WeakSet(),sourceDigests=new WeakMap();
 
-/** Desktop application source contract. The ordinary local JS admission/runtime
- * still reject this profile; server import accepts exact operator-reviewed pins. */
-export async function defineBrowserApplicationSource(value){
+/** Application source contract. Platform declarations do not grant execution:
+ * hosts still require exact reviewed pins and a trusted execution transport. */
+export async function defineBrowserApplicationSource(value,{signal}={}){
+ signal?.throwIfAborted();
  if(verifiedSources.has(value))return value;
  safeDocument(value);check(plain(value)&&Object.keys(value).every(key=>['manifest','application','tests'].includes(key)),'Use manifest, application and optional source fixtures only.');
  check(value.manifest?.runtime==='browser-application','Use the explicit, not-yet-installed browser-application runtime.');
@@ -19,33 +20,48 @@ export async function defineBrowserApplicationSource(value){
  // is its deliberately unavailable runtime enum; never rewrite it to JS.
  const errors=validateManifest(manifest).errors.filter(error=>error.path!=='runtime');
  check(errors.length===0,JSON.stringify(errors));
+ check(Object.keys(manifest.outputs).length>0,'Application operations must declare at least one typed output.');
  check(!manifest.id.startsWith('sm.'),'First-party identities require the platform release registry.');
- check(manifest.platforms?.desktop?.supported===true&&manifest.platforms?.browser?.supported===false&&manifest.platforms?.phone?.supported===false,'This bundle profile requires an explicit desktop-only declaration.');
+ check(manifest.platforms?.desktop?.supported===true&&typeof manifest.platforms?.browser?.supported==='boolean'&&manifest.platforms?.phone?.supported===false,'Declare desktop and browser availability explicitly; this profile has no verified phone build.');
  check(manifest.entry===undefined||manifest.entry==='src/application.json','Use the canonical src/application.json source entry.');
  check(!manifest.desktopTools&&!manifest.permissions.desktop?.length&&!manifest.permissions.capabilities?.length&&!manifest.permissions.actions?.length,'The initial application contract grants no desktop, paid integration or arbitrary action access.');
  const fixtures=value.tests===undefined?undefined:(bounded(value.tests,'Application source fixtures'),structuredClone(value.tests));
- const source={manifest,application:await defineBrowserApplication(value.application)};
+ const source={manifest,application:await defineBrowserApplication(value.application,{signal})};
+ signal?.throwIfAborted();const mapped=source.application.operations.filter(item=>Array.isArray(item.outputs));
+ if(mapped.length){
+  check(mapped.length===source.application.operations.length,'Every operation must map its output ports when any operation does.');
+  const exposed=new Set(mapped.flatMap(item=>item.outputs));
+  check(exposed.size===Object.keys(manifest.outputs).length&&[...exposed].every(name=>Object.hasOwn(manifest.outputs,name)),'Operation outputs must cover exactly the manifest output ports.');
+  for(const [name,port] of Object.entries(manifest.outputs))if(mapped.some(item=>!item.outputs.includes(name)))check(port.required===false,`Output ${name} must be optional because some operations do not produce it.`);
+ }
  if(fixtures!==undefined){
   check(Array.isArray(fixtures)&&fixtures.length>0&&fixtures.length<=50,'Supply 1–50 source fixtures when present.');
   source.tests=fixtures;
   for(const fixture of source.tests){
    check(exact(fixture,['name','operation','input','state','stateRevision','expected'])&&text(fixture.name),'Application fixtures declare name, operation, input, state, stateRevision and expected outputs.');
-   operation(source,fixture.operation);contextState(fixture);validateValues(manifest.inputs,fixture.input);validateBlockOutputs(manifest,fixture.expected);
+   const selected=operation(source,fixture.operation);contextState(fixture);validateValues(manifest.inputs,fixture.input);validateBlockOutputs(manifest,fixture.expected);
+   if(selected.outputs)check(stableStringify(Object.keys(fixture.expected).sort())===stableStringify([...selected.outputs].sort()),'Fixture output ports differ from their operation contract.');
   }
  }
- freeze(source);verifiedSources.add(source);return source;
+ freeze(source);signal?.throwIfAborted();verifiedSources.add(source);return source;
 }
 function operation(source,id){const declared=source.application.operations.find(item=>item.id===id);check(declared,'Choose an operation declared by this exact application bundle.');return declared;}
 function contextState(options){check(plain(options)&&plain(options.state)&&text(options.stateRevision),'Supply host-owned saved state and its exact revision.');bounded(options.state,'Application state');return structuredClone(options.state);}
+export async function getBrowserApplicationSourceDigests(value,{signal}={}){
+ signal?.throwIfAborted();
+ const source=await defineBrowserApplicationSource(value,{signal});
+ // Only the SDK's detached, deeply frozen source can key this private cache.
+ if(!sourceDigests.has(source))sourceDigests.set(source,Promise.all([digest(source),digest(source.application)]).then(([packageDigest,bundleDigest])=>Object.freeze({packageDigest,bundleDigest})));
+ const result=await sourceDigests.get(source);
+ signal?.throwIfAborted();return result;
+}
 async function prepare(value,values,options,phase){
  bounded(values,'Application inputs');const inputCopy=structuredClone(values),state=contextState(options),revision=options.stateRevision,operationId=options.operation,interactive=options.interactive;
  const source=await defineBrowserApplicationSource(value),input=validateValues(source.manifest.inputs,inputCopy);
  const selected=phase==='execute'?operation(source,operationId):null;
  if(phase==='execute'&&source.application.lifecycle==='interactive')check(interactive===true,'Interactive application operations require an active interactive host.');
- // Cache only detached deeply frozen sources, never mutable caller data.
- if(!sourceDigests.has(source))sourceDigests.set(source,Promise.all([digest(source),digest(source.application)]));
- const [packageDigest,bundleDigest]=await sourceDigests.get(source);
- const request={schemaVersion:1,phase,requestId:globalThis.crypto.randomUUID(),profile:BROWSER_APPLICATION_PROFILE,packageDigest,bundleDigest,inputDigest:await digest(input),stateDigest:await digest(state),stateRevision:revision,operation:selected?structuredClone(selected):null,lifecycle:source.application.lifecycle};
+ const {packageDigest,bundleDigest}=await getBrowserApplicationSourceDigests(source);
+ const request={schemaVersion:1,phase,requestId:globalThis.crypto.randomUUID(),profile:source.application.profile,packageDigest,bundleDigest,inputDigest:await digest(input),stateDigest:await digest(state),stateRevision:revision,operation:selected?structuredClone(selected):null,lifecycle:source.application.lifecycle};
  const prepared=freeze({package:source,input,state,request});preparedRequests.add(prepared);return prepared;
 }
 export function prepareBrowserApplicationExecution(source,values,options){return prepare(source,values,options,'execute');}
@@ -68,6 +84,8 @@ export async function validateBrowserApplicationExecutionResult(prepared,result)
  const receipt=snapshot.applicationReceipt,request=validated.request;
  check(exact(receipt,['schemaVersion','phase','requestId','profile','packageDigest','bundleDigest','inputDigest','stateDigest','stateRevision','operation','lifecycle','outputDigest','executionId'])&&receipt.schemaVersion===1&&receipt.phase==='completed'&&text(receipt.executionId),'A mount or preview is not a completed application operation.');
  for(const key of Object.keys(request).filter(key=>key!=='phase'))check(stableStringify(receipt[key])===stableStringify(request[key]),'Application receipt does not match this exact execution request.');
+ check(plain(snapshot.outputs)&&Object.keys(snapshot.outputs).length>0,'A completed application operation must produce at least one declared output.');
+ if(request.operation.outputs)check(stableStringify(Object.keys(snapshot.outputs).sort())===stableStringify([...request.operation.outputs].sort()),'The operation returned different output ports than its host-declared mapping.');
  const outputs=validateBlockOutputs(validated.package.manifest,snapshot.outputs);
  check(receipt.outputDigest===await digest(outputs),'Application receipt does not match returned outputs.');
  return {outputs,applicationReceipt:receipt,independentlyVerified:false};

package/packages/block-sdk/browser-application-guest.d.ts

@@ -29,4 +29,6 @@ export function installBrowserApplicationGuest(options:{
  operations:ReadonlyArray<BrowserApplicationOperation>;
  /** May lower, never raise, the 4 MiB per-message limit. */
  messageBytes?:number;
+ /** Host-selected output-only ceiling, at most 8 MiB. Inputs and state keep messageBytes. */
+ outputBytes?:number;
 }):BrowserApplicationGuestController;

package/packages/block-sdk/browser-application-guest.js

@@ -4,7 +4,7 @@
  * Object controls and cancellation are cooperative in the guest realm. The
  * trusted transport must enforce isolation, deadlines, UI-input freezing,
  * checkpoint identity, source bindings and actual worker termination itself. */
-export function installBrowserApplicationGuest({target=globalThis,operations,messageBytes=4194304}={}){
+export function installBrowserApplicationGuest({target=globalThis,operations,messageBytes=4194304,outputBytes=messageBytes}={}){
  const fail=(code,message)=>Object.assign(new Error(message),{code});
  const check=(condition,code,message)=>{if(!condition)throw fail(code,message);};
  const plain=value=>value!==null&&typeof value==='object'&&!Array.isArray(value)&&[Object.prototype,null].includes(Object.getPrototypeOf(value));
@@ -20,23 +20,29 @@ export function installBrowserApplicationGuest({target=globalThis,operations,mes
  };
  check(target!==null&&['object','function'].includes(typeof target)&&!('stillmadeApplication' in target),'APPLICATION_GUEST_INSTALLED','Application registration is already installed or the target is invalid.');
  check(Number.isSafeInteger(messageBytes)&&messageBytes>0&&messageBytes<=4194304,'APPLICATION_GUEST_LIMIT','Application messages must be bounded by at most 4 MiB.');
+ check(Number.isSafeInteger(outputBytes)&&outputBytes>=messageBytes&&outputBytes<=8*1048576,'APPLICATION_GUEST_LIMIT','Application output candidates need a bounded host-selected limit.');
  check(Array.isArray(operations)&&operations.length>0&&operations.length<=32,'APPLICATION_GUEST_OPERATION','Declare 1–32 application operations.');
- const declared=new Set();
+ const declared=new Set(),mapped=new Map();
  for(const operation of operations){
-  check(exact(operation,['id','kind']),'APPLICATION_GUEST_OPERATION','Declare only an operation id and kind.');
+  check(exact(operation,['id','kind'])||exact(operation,['id','kind','outputs']),'APPLICATION_GUEST_OPERATION','Declare an operation id, kind and optional output-port map.');
   const id=field(operation,'id'),kind=field(operation,'kind');
   check(typeof id==='string'&&/^[a-z][a-z0-9.-]{0,79}$/.test(id)&&!declared.has(id)&&['export','execute'].includes(kind),'APPLICATION_GUEST_OPERATION','Application operations must have distinct valid ids and kinds.');
+  if(Object.hasOwn(operation,'outputs')){
+   const names=field(operation,'outputs');
+   check(Array.isArray(names)&&names.length>0&&names.length<=64&&new Set(names).size===names.length&&names.every(name=>typeof name==='string'&&/^[a-z][a-zA-Z0-9_]*$/.test(name)),'APPLICATION_GUEST_OPERATION','Map the declared operation to distinct output ports.');
+   mapped.set(id,[...names]);
+  }
   declared.add(id);
  }
  // Copy JSON using data descriptors, never JSON.stringify on an adapter object
  // with accessors/toJSON. These checks catch mistakes; hostile guest code can
  // still change realm intrinsics, so the host must revalidate every message.
- function document(value,label){
+ function document(value,label,limit=messageBytes){
   let nodes=0;const ancestors=new Set();
   function visit(item,depth){
    check(depth<=40&&++nodes<=500000,'APPLICATION_GUEST_LIMIT',`${label} exceeds the JSON complexity limit.`);
    if(item===null||typeof item==='boolean')return item;
-   if(typeof item==='string'){check(item.length<=messageBytes,'APPLICATION_GUEST_LIMIT',`${label} exceeds its message limit.`);return item;}
+   if(typeof item==='string'){check(item.length<=limit,'APPLICATION_GUEST_LIMIT',`${label} exceeds its message limit.`);return item;}
    if(typeof item==='number'){check(Number.isFinite(item),'APPLICATION_GUEST_DATA',`${label} needs finite numbers.`);return item;}
    check((Array.isArray(item)||plain(item))&&!ancestors.has(item),'APPLICATION_GUEST_DATA',`${label} needs acyclic plain JSON data.`);
    ancestors.add(item);let result;
@@ -47,7 +53,7 @@ export function installBrowserApplicationGuest({target=globalThis,operations,mes
     result={};
     for(const key of Reflect.ownKeys(item)){
      check(typeof key==='string'&&!['__proto__','prototype','constructor'].includes(key),'APPLICATION_GUEST_DATA',`${label} contains an unsupported field.`);
-     check(key.length<=messageBytes,'APPLICATION_GUEST_LIMIT',`${label} exceeds its message limit.`);
+     check(key.length<=limit,'APPLICATION_GUEST_LIMIT',`${label} exceeds its message limit.`);
      result[key]=visit(field(item,key),depth+1);
     }
    }
@@ -55,7 +61,7 @@ export function installBrowserApplicationGuest({target=globalThis,operations,mes
   }
   check(plain(value),'APPLICATION_GUEST_DATA',`${label} must be a JSON object.`);
   const copied=visit(value,0);
-  check(new TextEncoder().encode(JSON.stringify(copied)).length<=messageBytes,'APPLICATION_GUEST_LIMIT',`${label} exceeds its message limit.`);
+  check(new TextEncoder().encode(JSON.stringify(copied)).length<=limit,'APPLICATION_GUEST_LIMIT',`${label} exceeds its message limit.`);
   return copied;
  }
  const stable=value=>JSON.stringify((function sort(item){return Array.isArray(item)?item.map(sort):plain(item)?Object.fromEntries(Object.keys(item).sort().map(key=>[key,sort(item[key])])):item;})(value));
@@ -111,9 +117,10 @@ export function installBrowserApplicationGuest({target=globalThis,operations,mes
    const payload=document({operation,inputs,stateRevision},'Application operation');
    check(plain(payload.inputs)&&stable(payload.inputs)===mountedInputs,'APPLICATION_GUEST_INPUT','Operation inputs must match the mounted inputs.');
    return run('execute',signal,inner=>adapter.execute({...payload,signal:inner}),raw=>{
-    const outputs=document(raw,'Application outputs');
+    const outputs=document(raw,'Application outputs',outputBytes);
     check(!['applicationReceipt','desktopReceipt','independentlyVerified'].some(key=>Object.hasOwn(outputs,key)),'APPLICATION_GUEST_RESULT','Adapters return output values only, never host receipt or verification fields.');
-    return document({outputs},'Application result');
+    if(mapped.has(operation))check(JSON.stringify(Object.keys(outputs).sort())===JSON.stringify([...mapped.get(operation)].sort()),'APPLICATION_GUEST_RESULT','The adapter returned different output ports than this operation declares.');
+    return document({outputs},'Application result',outputBytes);
    });
   },
   dispose(){

package/packages/block-sdk/browser-application.d.ts

@@ -1,13 +1,21 @@
 /** Source format only; this constant does not advertise an installed runtime. */
 export const BROWSER_APPLICATION_PROFILE:'desktop-browser-application/1';
-export const BROWSER_APPLICATION_LIMITS:Readonly<{assets:number;assetBytes:number;totalBytes:number;pathBytes:number;operations:number;messageBytes:number;timeoutMs:number}>;
-export type BrowserApplicationMime='text/html'|'text/javascript'|'text/css'|'application/json'|'application/manifest+json'|'application/xml'|'text/xml'|'application/wasm'|'application/octet-stream'|'text/plain'|'image/png'|'image/jpeg'|'image/gif'|'image/webp'|'image/avif'|'image/svg+xml'|'image/x-icon'|'font/woff2'|'font/woff'|'font/ttf'|'font/otf'|'audio/mpeg'|'audio/ogg'|'audio/wav'|'video/mp4'|'video/webm';
+export const BROWSER_APPLICATION_EMBEDDED_PROFILE:'desktop-browser-application/2';
+export const BROWSER_APPLICATION_LOCAL_WORKER_PROFILE:'desktop-browser-application/3';
+export const BROWSER_APPLICATION_LIMITS:Readonly<{assets:number;assetBytes:number;totalBytes:number;pathBytes:number;operations:number;messageBytes:number;outputCandidateBytes:number;timeoutMs:number}>;
+export type BrowserApplicationMime='text/html'|'text/javascript'|'text/css'|'application/json'|'application/manifest+json'|'application/xml'|'text/xml'|'application/wasm'|'application/octet-stream'|'text/plain'|'image/png'|'image/jpeg'|'image/gif'|'image/webp'|'image/avif'|'image/svg+xml'|'image/x-icon'|'font/woff2'|'font/woff'|'font/ttf'|'font/otf'|'application/vnd.ms-fontobject'|'audio/mpeg'|'audio/ogg'|'audio/wav'|'video/mp4'|'video/webm';
 export interface BrowserApplicationAsset {path:string;mime:BrowserApplicationMime;sha256:string;encoding:'base64';bytes:number;data:string}
 export interface BrowserApplicationOperation {id:string;kind:'export'|'execute'}
-export interface BrowserApplicationBundle {
+export type BrowserApplicationBundle={
  schemaVersion:1;profile:typeof BROWSER_APPLICATION_PROFILE;appearance:'original';entry:string;adapter:string;
  lifecycle:'interactive'|'headless';operations:BrowserApplicationOperation[];assets:BrowserApplicationAsset[];features:{wasm:boolean};
-}
+}|{
+ schemaVersion:1;profile:typeof BROWSER_APPLICATION_EMBEDDED_PROFILE;appearance:'original';entry:string;adapter:string;
+ lifecycle:'interactive'|'headless';operations:BrowserApplicationOperation[];assets:BrowserApplicationAsset[];features:{wasm:boolean;srcdocFrames:boolean};
+}|{
+ schemaVersion:1;profile:typeof BROWSER_APPLICATION_LOCAL_WORKER_PROFILE;appearance:'original';entry:string;adapter:string;
+ lifecycle:'interactive'|'headless';operations:BrowserApplicationOperation[];assets:BrowserApplicationAsset[];features:{wasm:boolean;srcdocFrames:boolean;localWorkers:true};
+};
 export type BrowserApplicationDeepReadonly<T>=T extends object?{readonly [P in keyof T]:BrowserApplicationDeepReadonly<T[P]>}:T;
 /** Strict canonical relative regular-file path. No URL, traversal or decoding. */
 export function browserApplicationPath(path:string):string;

package/packages/block-sdk/browser-application.js

@@ -3,15 +3,17 @@ import {assert,plain,safeDocument,digest} from './contracts.js';
 // A bundle/evidence format, not an installed runtime or an admission decision.
 // The existing restricted view and portable archive formats are unchanged.
 export const BROWSER_APPLICATION_PROFILE='desktop-browser-application/1';
+export const BROWSER_APPLICATION_EMBEDDED_PROFILE='desktop-browser-application/2';
+export const BROWSER_APPLICATION_LOCAL_WORKER_PROFILE='desktop-browser-application/3';
 // One large WASM engine plus fonts, icons and editor resources, with explicit
 // aggregate bounds. These are not the existing portable archive's 4 MB limit.
-export const BROWSER_APPLICATION_LIMITS=Object.freeze({assets:2048,assetBytes:64*1024*1024,totalBytes:128*1024*1024,pathBytes:256,operations:32,messageBytes:4*1024*1024,timeoutMs:120000});
+export const BROWSER_APPLICATION_LIMITS=Object.freeze({assets:2048,assetBytes:64*1024*1024,totalBytes:128*1024*1024,pathBytes:256,operations:32,messageBytes:4*1024*1024,outputCandidateBytes:8*1024*1024,timeoutMs:120000});
 const mimeExtensions=Object.freeze({
  'text/html':['html'],'text/javascript':['js','mjs'],'text/css':['css'],'application/json':['json','map'],
  'application/manifest+json':['webmanifest'],'application/xml':['xml'],'text/xml':['xml'],
  'application/wasm':['wasm'],'application/octet-stream':['bin','data','dat'],'text/plain':['txt'],
  'image/png':['png'],'image/jpeg':['jpg','jpeg'],'image/gif':['gif'],'image/webp':['webp'],'image/avif':['avif'],'image/svg+xml':['svg'],'image/x-icon':['ico'],
- 'font/woff2':['woff2'],'font/woff':['woff'],'font/ttf':['ttf'],'font/otf':['otf'],
+ 'font/woff2':['woff2'],'font/woff':['woff'],'font/ttf':['ttf'],'font/otf':['otf'],'application/vnd.ms-fontobject':['eot'],
  'audio/mpeg':['mp3'],'audio/ogg':['ogg'],'audio/wav':['wav'],'video/mp4':['mp4'],'video/webm':['webm'],
 });
 const verifiedBundles=new WeakSet();
@@ -20,20 +22,23 @@ const hash=value=>typeof value==='string'&&/^[a-f0-9]{64}$/.test(value);
 const freeze=value=>{if(value&&typeof value==='object'){Object.values(value).forEach(freeze);Object.freeze(value);}return value;};
 const check=(condition,message)=>assert(condition,'BROWSER_APPLICATION',message);
 export function browserApplicationPath(path){
- check(typeof path==='string'&&path.length>0&&path.length<=BROWSER_APPLICATION_LIMITS.pathBytes&&/^[A-Za-z0-9_@$-][A-Za-z0-9_@$./-]*$/.test(path),'Use a bounded relative application asset path, never a URL.');
+ check(typeof path==='string'&&path.length>0&&path.length<=BROWSER_APPLICATION_LIMITS.pathBytes&&/^[A-Za-z0-9_@$+-][A-Za-z0-9_@$./&+-]*$/.test(path),'Use a bounded relative application asset path, never a URL.');
  check(path.split('/').every(part=>part&&part!=='.'&&part!=='..'&&!part.endsWith('.')&&!/^(?:con|prn|aux|nul|com[0-9]|lpt[0-9])(?:\.|$)/i.test(part)),'Application paths must be canonical regular-file paths.');
  return path;
 }
 function metadata(value){
  safeDocument(value);
- check(exact(value,['schemaVersion','profile','appearance','entry','adapter','lifecycle','operations','assets','features'])&&value.schemaVersion===1&&value.profile===BROWSER_APPLICATION_PROFILE,'Use desktop browser application bundle schema 1.');
+ check(exact(value,['schemaVersion','profile','appearance','entry','adapter','lifecycle','operations','assets','features'])&&value.schemaVersion===1&&[BROWSER_APPLICATION_PROFILE,BROWSER_APPLICATION_EMBEDDED_PROFILE,BROWSER_APPLICATION_LOCAL_WORKER_PROFILE].includes(value.profile),'Use a supported desktop browser application bundle profile.');
  check(value.appearance==='original','This profile preserves original styling; host theming requires a separately declared future adapter.');
  check(['interactive','headless'].includes(value.lifecycle),'Declare an interactive or headless application lifecycle.');
- check(exact(value.features,['wasm'])&&typeof value.features.wasm==='boolean','Declare whether this bundle needs single-thread WebAssembly; workers and ambient networking are unavailable.');
+ const embedded=value.profile===BROWSER_APPLICATION_EMBEDDED_PROFILE;
+ const localWorkers=value.profile===BROWSER_APPLICATION_LOCAL_WORKER_PROFILE;
+ check(exact(value.features,localWorkers?['wasm','srcdocFrames','localWorkers']:embedded?['wasm','srcdocFrames']:['wasm'])&&typeof value.features.wasm==='boolean'&&(!embedded&&!localWorkers||typeof value.features.srcdocFrames==='boolean')&&(!localWorkers||value.features.localWorkers===true),'Declare browser features for the exact profile; ambient networking is unavailable.');
  check(Array.isArray(value.operations)&&value.operations.length>0&&value.operations.length<=BROWSER_APPLICATION_LIMITS.operations,'Declare 1–32 output-producing adapter operations.');
  const operations=new Set();for(const operation of value.operations){
-  check(exact(operation,['id','kind'])&&typeof operation.id==='string'&&/^[a-z][a-z0-9.-]{0,79}$/.test(operation.id)&&!operations.has(operation.id),'Use distinct named application operations.');
+  check((exact(operation,['id','kind'])||exact(operation,['id','kind','outputs']))&&typeof operation.id==='string'&&/^[a-z][a-z0-9.-]{0,79}$/.test(operation.id)&&!operations.has(operation.id),'Use distinct named application operations.');
   check(['export','execute'].includes(operation.kind)&&(value.lifecycle!=='headless'||operation.kind==='execute'),'A headless application must execute without an interactive export.');operations.add(operation.id);
+  if(Object.hasOwn(operation,'outputs'))check(Array.isArray(operation.outputs)&&operation.outputs.length>0&&operation.outputs.length<=64&&new Set(operation.outputs).size===operation.outputs.length&&operation.outputs.every(name=>typeof name==='string'&&/^[a-z][a-zA-Z0-9_]*$/.test(name)),'Map each operation to distinct bounded output ports.');
  }
  check(Array.isArray(value.assets)&&value.assets.length>=2&&value.assets.length<=BROWSER_APPLICATION_LIMITS.assets,'Declare 2–2048 bundled regular-file assets.');
  const paths=new Set();let total=0,wasm=false;
@@ -64,16 +69,25 @@ function decode(asset){
 async function bytesDigest(bytes){return Array.from(new Uint8Array(await globalThis.crypto.subtle.digest('SHA-256',bytes)),byte=>byte.toString(16).padStart(2,'0')).join('');}
 /** Checks hashes and returns immutable detached data. This never inspects code
  * for safety, performs a build, starts a browser, or grants any capability. */
-export async function defineBrowserApplication(value){
+export async function defineBrowserApplication(value,{signal}={}){
+ signal?.throwIfAborted();
  if(verifiedBundles.has(value))return value;
  metadata(value);const bundle=structuredClone(value);
- for(const asset of bundle.assets){
-  const bytes=decode(asset);check(await bytesDigest(bytes)===asset.sha256,`Application asset integrity failed: ${asset.path}`);
-  if(['text/html','text/javascript','text/css','application/json','application/manifest+json','application/xml','text/xml','text/plain','image/svg+xml'].includes(asset.mime)){
-   try{new TextDecoder('utf-8',{fatal:true}).decode(bytes);}catch{check(false,`Application text asset is not UTF-8: ${asset.path}`);}
+ let nextAsset=0,failed=false,firstFailure;
+ const verifyAssets=async()=>{
+  while(!failed&&nextAsset<bundle.assets.length){
+   try{
+    signal?.throwIfAborted();const asset=bundle.assets[nextAsset++],bytes=decode(asset);signal?.throwIfAborted();check(await bytesDigest(bytes)===asset.sha256,`Application asset integrity failed: ${asset.path}`);signal?.throwIfAborted();
+    if(['text/html','text/javascript','text/css','application/json','application/manifest+json','application/xml','text/xml','text/plain','image/svg+xml'].includes(asset.mime)){
+     try{new TextDecoder('utf-8',{fatal:true}).decode(bytes);}catch{check(false,`Application text asset is not UTF-8: ${asset.path}`);}
+    }
+   }catch(error){if(!failed){failed=true;firstFailure=error;}}
   }
- }
- freeze(bundle);verifiedBundles.add(bundle);return bundle;
+ };
+ // Drain every started verification before rejection or immutable publication.
+ await Promise.all(Array.from({length:Math.min(4,bundle.assets.length)},verifyAssets));
+ if(failed)throw firstFailure;
+ signal?.throwIfAborted();freeze(bundle);verifiedBundles.add(bundle);return bundle;
 }
 /** Exact bundle lookup only: no URL resolution, filesystem access or fetch.
  * Hosts must independently deny navigation, network and unlisted resources. */