lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

run.mjs (90929B)


      1 import assert from 'node:assert/strict';
      2 import { createRequire } from 'node:module';
      3 import { createServer } from 'node:http';
      4 import { readFile } from 'node:fs/promises';
      5 import { resolve, sep } from 'node:path';
      6 import { runDelivery } from './delivery.mjs';
      7 import { runObservations } from './observations.mjs';
      8 import { runJournal } from './journal.mjs';
      9 
     10 // Caller supplies its installed Playwright package and an external generated
     11 // WASM directory. No dependency installation or generated bytes live here.
     12 const [moduleRoot, packageDir, engine = 'chromium', legacyPackageDir, profile = 'base'] = process.argv.slice(2);
     13 assert(moduleRoot && packageDir && legacyPackageDir, 'usage: node run.mjs PLAYWRIGHT_PACKAGE WASM_DIRECTORY ENGINE V1_WASM_DIRECTORY');
     14 const playwright = createRequire(resolve(moduleRoot, 'package.json'))('playwright');
     15 assert(['chromium','firefox','webkit'].includes(engine));
     16 assert(['base','delivery','delivery_limits','delivery_faults','delivery_corruption','observations','observation_faults','observation_corruption','journal','journal_observations','journal_reopen'].includes(profile));
     17 const root = resolve(packageDir);
     18 const legacyRoot = resolve(legacyPackageDir);
     19 const server = createServer(async (req,res) => {
     20   try {
     21     const url = new URL(req.url, 'http://localhost').pathname;
     22     const selectedRoot=url.startsWith('/v1/')?legacyRoot:root;
     23     const path = resolve(selectedRoot, '.' + (url.startsWith('/v1/')?url.slice(3):url));
     24     assert(path.startsWith(selectedRoot + sep));
     25     if (path.endsWith('/index.html')) {
     26       res.setHeader('content-type','text/html'); res.end('<!doctype html><title>IndexedDB fixture</title>'); return;
     27     }
     28     if (path.endsWith('/worker.js')) {
     29       res.setHeader('content-type','text/javascript');
     30       res.end(`import init, {Fixture,Persistent,WorkspaceFixture,protected_round_trip} from './fixture.js';
     31         await init();
     32         let retainedWorkspace;
     33         self.onmessage=async(event)=>{try{
     34           if(event.data?.kind==='workspace_open'||event.data?.kind==='workspace_hold'){const m=event.data;const owner=await WorkspaceFixture.open(m.n,new Uint8Array(m.fingerprint),new Uint8Array(m.selection),new Uint8Array(m.proof));const revision=await owner.authenticate();if(m.kind==='workspace_hold')retainedWorkspace=owner;else await owner.close();self.postMessage({revision});return;}
     35           if(event.data?.kind==='journal_query'){const m=event.data;const owner=await WorkspaceFixture.open(m.n,new Uint8Array(m.fingerprint),new Uint8Array(m.selection),new Uint8Array(m.proof));const preparation=Array.from(await owner.query(65));await owner.close();self.postMessage({preparation});return;}
     36           if(event.data?.kind==='plan_query'){const m=event.data;const owner=await WorkspaceFixture.open(m.n,new Uint8Array(m.fingerprint),new Uint8Array(m.selection),new Uint8Array(m.proof));const plan=Array.from(await owner.plan_query(180));await owner.close();self.postMessage({plan});return;}
     37           if(event.data?.kind==='issuance_query'){const m=event.data;const owner=await WorkspaceFixture.open(m.n,new Uint8Array(m.fingerprint),new Uint8Array(m.selection),new Uint8Array(m.proof));const claim=Array.from(await owner.attempt(190,0)),seal=Array.from(await owner.captured(190,0));await owner.close();self.postMessage({claim,seal});return;}
     38           if(event.data?.kind==='installation_query'){const m=event.data;const owner=await WorkspaceFixture.open(m.n,new Uint8Array(m.fingerprint),new Uint8Array(m.selection),new Uint8Array(m.proof));const state=JSON.parse(await owner.snapshot(200));await owner.close();self.postMessage({state});return;}
     39           if(event.data?.kind==='delivery_query'){const m=event.data;const owner=await WorkspaceFixture.open(m.n,new Uint8Array(m.fingerprint),new Uint8Array(m.selection),new Uint8Array(m.proof));const report=JSON.parse(await owner.query_envelope(m.operation,m.index,m.id));await owner.close();self.postMessage({report});return;}
     40           if(event.data?.kind==='observation_query'){const m=event.data;const owner=await WorkspaceFixture.open(m.n,new Uint8Array(m.fingerprint),new Uint8Array(m.selection),new Uint8Array(m.proof));const reports=JSON.parse(await owner.query_observations(m.operation,m.index,m.id));await owner.close();self.postMessage({reports});return;}
     41           if(event.data?.kind==='recovered_query'){const m=event.data;const owner=await WorkspaceFixture.open(m.n,new Uint8Array(m.fingerprint),new Uint8Array(m.selection),new Uint8Array(m.proof));const captured=Array.from(await owner.captured(m.operation,0));await owner.close();self.postMessage({captured});return;}
     42           if(event.data?.kind==='persistent_create'){const provider=await Persistent.create(90);const fingerprint=provider.fingerprint();const encoded=await provider.protect(new Uint8Array([90,91,92]));await provider.close();self.postMessage({fingerprint:Array.from(fingerprint),encoded:Array.from(encoded)});return;}
     43           if(event.data?.kind==='persistent_open'){const provider=await Persistent.open(90,new Uint8Array(event.data.fingerprint));const plain=await provider.reveal(new Uint8Array(event.data.encoded));await provider.close();self.postMessage({plain:Array.from(plain)});return;}
     44           await protected_round_trip(79);const db=await Fixture.open(77,true);await db.write(1,undefined,new Uint8Array([77]));await db.close();const again=await Fixture.open(77,false);const value=await again.read(1);await again.close();self.postMessage({value:Array.from(value)});}catch(error){self.postMessage({error:String(error)});}};
     45         self.postMessage({ready:true});`); return;
     46     }
     47     res.setHeader('content-type',path.endsWith('.wasm') ? 'application/wasm' : 'text/javascript');
     48     res.end(await readFile(path));
     49   } catch {res.statusCode=404;res.end();}
     50 });
     51 await new Promise(resolve => server.listen(0,'127.0.0.1',resolve));
     52 let browser;
     53 const deadline=setTimeout(()=>{void browser?.close();},180000);
     54 deadline.unref();
     55 try {
     56   browser = await playwright[engine].launch({headless:true});
     57   const page = await browser.newPage();
     58   page.on('pageerror',error=>console.error('PAGE_ERROR',error.message));
     59   page.on('console',message=>{if(message.type()==='log')console.log(message.text());});
     60   await page.goto(`http://127.0.0.1:${server.address().port}/index.html`);
     61   if(profile==='base') {
     62   const result=await page.evaluate(async()=>{
     63     const {default:init,Fixture,Persistent,WorkspaceFixture,protected_round_trip}=await import('./fixture.js'); await init();
     64     console.log('STEP wasm_initialized');
     65     const events=[];
     66     const nativeTransaction=IDBDatabase.prototype.transaction;
     67     IDBDatabase.prototype.transaction=function(...args) {
     68       const tx=nativeTransaction.apply(this,args);
     69       tx.addEventListener('complete',()=>events.push('complete'));
     70       tx.addEventListener('abort',()=>events.push('abort'));
     71       return tx;
     72     };
     73     const same=(a,b)=>{if(JSON.stringify(a)!==JSON.stringify(b))throw Error('assertion mismatch');};
     74     const rejects=async(fn,code)=>{try{await fn();}catch(error){if(String(error)!==code)throw Error('expected '+code+', received '+String(error));return;}throw Error('expected refusal: '+code);};
     75     const value=async(db,k)=>{const raw=await db.read(k);return raw===undefined ? undefined : Array.from(raw);};
     76     const tests=[];
     77     const passed=name=>{tests.push(name);console.log('PASS '+name);};
     78     try {
     79       await protected_round_trip(78);passed('local provider and migration validator across real protected IndexedDB reopen');
     80       const persistent=await Persistent.create(80);
     81       same(persistent.truthful_capabilities(),true);
     82       same(await persistent.context_and_reference_refusal(),true);
     83       const fingerprint=Array.from(persistent.fingerprint());
     84       const encoded=Array.from(await persistent.protect(new Uint8Array([80,81,82])));
     85       same(Array.from(await persistent.reveal(new Uint8Array(encoded))),[80,81,82]);
     86       const changedEnvelope=new Uint8Array(encoded);changedEnvelope[changedEnvelope.length-1]^=1;
     87       await rejects(()=>persistent.reveal(changedEnvelope),'persistent_crypto_refused');
     88       await persistent.close();
     89       const reopenedProvider=await Persistent.open(80,new Uint8Array(fingerprint));
     90       same(Array.from(await reopenedProvider.reveal(new Uint8Array(encoded))),[80,81,82]);
     91       await rejects(()=>Persistent.open(80,new Uint8Array(32)),'provider_key_mismatch');
     92       await rejects(()=>Persistent.create(80),'namespace_exists');
     93       await reopenedProvider.close();
     94       const different=await Persistent.create(81);
     95       if(JSON.stringify(Array.from(different.fingerprint()))===JSON.stringify(fingerprint))throw Error('independent master keys aliased');
     96       await different.close();
     97       passed('persistent key creation, exact reopen, context, reference, capabilities and key independence');
     98       const dataStore=await Fixture.open(80,true);
     99       await dataStore.write(4,undefined,new Uint8Array(encoded));await dataStore.close();
    100       await rejects(()=>Fixture.open(12,false),'missing_namespace');
    101       console.log('STEP missing_existing_refused');
    102       const db=await Fixture.open(12,true);
    103       await rejects(()=>Fixture.open(12,true),'namespace_exists');
    104       same(await value(db,1),undefined);
    105       const before=events.length;
    106       same(await db.write(1,undefined,new Uint8Array([1])),1);
    107       if(!events.slice(before).includes('complete'))throw Error('no actual completion before return');
    108       await db.write(2,undefined,new Uint8Array([2]));
    109       const failedBefore=events.length;
    110       await rejects(()=>db.atomic_pair(99),'record_conflict');
    111       if(!events.slice(failedBefore).includes('abort'))throw Error('no actual atomic abort');
    112       same(await value(db,1),[1]);same(await value(db,2),[2]);
    113       const refusedAt=events.length;
    114       await rejects(()=>db.refused_pair(),'transaction_precondition_refused');
    115       same(await value(db,1),[1]);same(await value(db,2),[2]);
    116       if(!events.slice(refusedAt).includes('abort'))throw Error('no actual precondition abort');
    117       passed('synchronous eligibility refusal aborts the whole real compare/exchange batch');
    118       const nativePut=IDBObjectStore.prototype.put;
    119       let firstWriteSucceeded=false;
    120       IDBObjectStore.prototype.put=function(...args) {
    121         const request=nativePut.apply(this,args);
    122         if(args[1] instanceof Uint8Array && args[1][0]===1) {
    123           request.addEventListener('success',()=>{firstWriteSucceeded=true;this.transaction.abort();},{once:true});
    124         }
    125         return request;
    126       };
    127       try {await rejects(()=>db.atomic_pair(2),'transaction_aborted');}
    128       finally {IDBObjectStore.prototype.put=nativePut;}
    129       same(firstWriteSucceeded,true);same(await value(db,1),[1]);same(await value(db,2),[2]);
    130       passed('actual abort after write-request success never acknowledges commit');
    131       same(await db.atomic_pair(2),2);same(await value(db,1),[3]);same(await value(db,2),[4]);
    132       passed('actual completion and all-or-nothing conflict rollback');
    133       await db.write(3,undefined,new Uint8Array()); same(await value(db,3),[]);
    134       await db.write(3,new Uint8Array(),undefined);same(await value(db,3),undefined);
    135       passed('missing versus empty and exact deletion');
    136       const second=await Fixture.open(12,false);
    137       const race=await Promise.allSettled([db.write(1,new Uint8Array([3]),new Uint8Array([5])),second.write(1,new Uint8Array([3]),new Uint8Array([6]))]);
    138       same(race.filter(r=>r.status==='fulfilled').length,1);
    139       same(race.filter(r=>r.status==='rejected').map(r=>String(r.reason)),['record_conflict']);
    140       await second.close();passed('independent connections serialize compare/exchange');
    141       db.abandon_write(9);
    142       for(let n=0;n<64;n++) db.abandon_close();
    143       await db.close();
    144       await rejects(()=>db.read(9),'closed');
    145       const reopened=await Fixture.open(12,false);same(await value(reopened,9),[9]);
    146       same(reopened.abandon_reads(33),32);await reopened.close();passed('observer loss, bounded admission and actual close/reopen');
    147       const isolated=await Fixture.open(13,true);same(await value(isolated,9),undefined);await isolated.close();passed('exact per-namespace isolation');
    148       const name=n=>'radroots.indexeddb.v1.'+n.toString(16).padStart(2,'0').repeat(32);
    149       const rawOpen=(n,version,upgrade)=>new Promise((resolve,reject)=>{
    150         const request=indexedDB.open(name(n),version);
    151         request.onupgradeneeded=()=>upgrade?.(request.result);
    152         request.onsuccess=()=>resolve(request.result);request.onerror=()=>reject(Error('raw fixture open failed'));
    153       });
    154       const providerName=n=>'radroots.secrets.browser.v1.persistent_fixture_'+n;
    155       const providerRaw=n=>new Promise((resolve,reject)=>{
    156         const request=indexedDB.open(providerName(n),1);
    157         request.onupgradeneeded=()=>request.transaction.abort();
    158         request.onsuccess=()=>resolve(request.result);request.onerror=()=>reject(Error('missing provider fixture'));
    159       });
    160       const providerRead=async n=>{
    161         const raw=await providerRaw(n);
    162         try{return await new Promise((resolve,reject)=>{
    163           const tx=raw.transaction('provider','readonly');const store=tx.objectStore('provider');let key,binding;
    164           store.get('key').onsuccess=e=>key=e.target.result;store.get('binding').onsuccess=e=>binding=e.target.result;
    165           tx.oncomplete=()=>resolve({key,binding});tx.onabort=reject;
    166         });}finally{raw.close();}
    167       };
    168       const providerMutate=async(n,change)=>{
    169         const raw=await providerRaw(n);
    170         try{await new Promise((resolve,reject)=>{const tx=raw.transaction('provider','readwrite');change(tx.objectStore('provider'));tx.oncomplete=resolve;tx.onabort=reject;});}
    171         finally{raw.close();}
    172       };
    173       const storedProvider=await providerRead(80);
    174       same(storedProvider.key.type,'secret');same(storedProvider.key.algorithm.name,'HKDF');same(storedProvider.key.extractable,false);same(storedProvider.key.usages,['deriveKey']);
    175       let exportRefused=false;try{await crypto.subtle.exportKey('raw',storedProvider.key);}catch{exportRefused=true;}same(exportRefused,true);
    176       passed('actual persisted master CryptoKey is nonextractable and raw export is refused');
    177       const copied=await Persistent.create(82);await copied.close();
    178       await providerMutate(82,store=>{store.put(storedProvider.key,'key');store.put(storedProvider.binding,'binding');});
    179       await rejects(()=>Persistent.open(82,new Uint8Array(fingerprint)),'provider_key_mismatch');
    180       passed('copied key and metadata cannot cross namespace binding');
    181       const lostKey=await Persistent.create(86);const lostFingerprint=lostKey.fingerprint();
    182       const lostNamespace=await Persistent.create(87);const lostNamespaceFingerprint=lostNamespace.fingerprint();
    183       const originalImport=SubtleCrypto.prototype.importKey;let masterImports=0;
    184       SubtleCrypto.prototype.importKey=function(format,data,algorithm,...args){if((typeof algorithm==='string'?algorithm:algorithm.name)==='HKDF')masterImports++;return originalImport.call(this,format,data,algorithm,...args);};
    185       try{
    186         await providerMutate(86,store=>store.delete('key'));
    187         await rejects(()=>lostKey.protect(new Uint8Array([1])),'persistent_crypto_refused');
    188         await rejects(()=>Persistent.open(86,lostFingerprint),'missing_key');
    189         await rejects(()=>Persistent.create(86),'namespace_exists');await lostKey.close();
    190         await new Promise((resolve,reject)=>{const request=indexedDB.deleteDatabase(providerName(87));request.onsuccess=resolve;request.onerror=reject;});
    191         await rejects(()=>lostNamespace.protect(new Uint8Array([1])),'persistent_crypto_refused');
    192         await rejects(()=>Persistent.open(87,lostNamespaceFingerprint),'missing_namespace');await lostNamespace.close();
    193         same(masterImports,0);
    194       }finally{SubtleCrypto.prototype.importKey=originalImport;}
    195       passed('actual key and namespace loss refuse without master-key regeneration');
    196       const wrongKey=await Persistent.create(91);const wrongFingerprint=wrongKey.fingerprint();
    197       await providerMutate(91,store=>store.put({algorithm:'HKDF'},'key'));
    198       await rejects(()=>wrongKey.protect(new Uint8Array([1])),'persistent_crypto_refused');
    199       await rejects(()=>Persistent.open(91,wrongFingerprint),'provider_key_mismatch');await wrongKey.close();
    200       const foreignProvider=n=>new Promise((resolve,reject)=>{const request=indexedDB.open(providerName(n),n===89?2:1);request.onupgradeneeded=()=>request.result.createObjectStore('provider',{autoIncrement:true});request.onsuccess=()=>{request.result.close();resolve();};request.onerror=reject;});
    201       for(const n of [88,89]){await foreignProvider(n);await rejects(()=>Persistent.open(n,new Uint8Array(32)),'incompatible_schema');}
    202       passed('foreign key representation and provider schema/version are refused');
    203       const originalAdd=IDBObjectStore.prototype.add;let keyWriteSucceeded=false;
    204       IDBObjectStore.prototype.add=function(...args){const request=originalAdd.apply(this,args);if(this.name==='provider'){request.addEventListener('success',()=>{if(args[1]==='key')keyWriteSucceeded=true;if(args[1]==='binding')this.transaction.abort();},{once:true});}return request;};
    205       try{await rejects(()=>Persistent.create(92),'transaction_aborted');}finally{IDBObjectStore.prototype.add=originalAdd;}
    206       same(keyWriteSucceeded,true);await rejects(()=>Persistent.open(92,new Uint8Array(32)),'missing_namespace');
    207       passed('actual creation abort after key-write success returns no provider and retains no empty namespace');
    208       const originalOpen=IDBFactory.prototype.open;let createdResolve;
    209       const createdUnobserved=new Promise(resolve=>createdResolve=resolve);
    210       IDBFactory.prototype.open=function(...args){const request=originalOpen.apply(this,args);if(args[0]===providerName(93))request.addEventListener('success',()=>createdResolve(),{once:true});return request;};
    211       try{Persistent.abandon_create(93);await createdUnobserved;}finally{IDBFactory.prototype.open=originalOpen;}
    212       const unobserved=await providerRead(93);const unobservedFingerprint=unobserved.binding.slice(unobserved.binding.length-32);
    213       const retained=await Persistent.open(93,unobservedFingerprint);const retainedBytes=await retained.protect(new Uint8Array([93]));same(Array.from(await retained.reveal(retainedBytes)),[93]);await retained.close();
    214       passed('accepted creation remains Rust-owned after its observer is dropped');
    215       const completedSetups=new Set();let setupsResolve;
    216       const allSetups=new Promise(resolve=>setupsResolve=resolve);
    217       IDBFactory.prototype.open=function(...args){const request=originalOpen.apply(this,args);for(let n=100;n<132;n++)if(args[0]===providerName(n))request.addEventListener('success',()=>{completedSetups.add(n);if(completedSetups.size===32)setupsResolve();},{once:true});return request;};
    218       try{Persistent.abandon_setup_batch(100);await allSetups;}finally{IDBFactory.prototype.open=originalOpen;}
    219       const setupBinding=(await providerRead(100)).binding;
    220       const setupReopened=await Persistent.open(100,setupBinding.slice(-32));
    221       await setupReopened.close();setupReopened.free();
    222       passed('create and open share bounded setup admission and release it after unobserved completion');
    223       const busy=await Persistent.create(94);const busyFingerprint=busy.fingerprint();
    224       same(busy.abandon_wraps(33),32);for(let n=0;n<64;n++)busy.abandon_close();await busy.close();
    225       await rejects(()=>busy.protect(new Uint8Array([1])),'persistent_crypto_refused');
    226       const busyReopened=await Persistent.open(94,busyFingerprint);await busyReopened.close();
    227       passed('bounded wrapping survives dropped observers and cancelled close, then reopens');
    228       const foreign=await rawOpen(14,1,db=>db.createObjectStore('records',{autoIncrement:true}));foreign.close();
    229       await rejects(()=>Fixture.open(14,false),'incompatible_schema');
    230       const future=await rawOpen(15,2,db=>db.createObjectStore('records'));future.close();
    231       await rejects(()=>Fixture.open(15,false),'incompatible_schema');passed('foreign key schema and future version refusal');
    232       const changed=await Fixture.open(16,true);
    233       const upgraded=await rawOpen(16,2);await rejects(()=>changed.read(1),'closed');upgraded.close();await changed.close();
    234       passed('version change closes owned connection');
    235       const corrupt=await Fixture.open(17,true);
    236       const raw=await rawOpen(17,1);
    237       await new Promise((resolve,reject)=>{const tx=raw.transaction('records','readwrite');tx.objectStore('records').put('foreign record',new Uint8Array(32).fill(1));tx.oncomplete=resolve;tx.onabort=reject;});
    238       raw.close();await rejects(()=>corrupt.read(1),'corrupt_record');await corrupt.close();passed('foreign record representation refusal');
    239       const oversized=await Fixture.open(19,true);
    240       const largeRaw=await rawOpen(19,1);
    241       await new Promise((resolve,reject)=>{const tx=largeRaw.transaction('records','readwrite');tx.objectStore('records').put(new Uint8Array(65537),new Uint8Array(32).fill(1));tx.oncomplete=resolve;tx.onabort=reject;});
    242       largeRaw.close();await rejects(()=>oversized.read(1),'corrupt_record');await oversized.close();passed('stored record bound before Rust byte copying');
    243       const evicted=await Fixture.open(18,true);
    244       await new Promise((resolve,reject)=>{const request=indexedDB.deleteDatabase(name(18));request.onsuccess=resolve;request.onerror=reject;});
    245       await rejects(()=>evicted.read(1),'closed');await evicted.close();
    246       await rejects(()=>Fixture.open(18,false),'missing_namespace');passed('actual namespace deletion cannot silently recreate');
    247       const workerResult=await new Promise((resolve,reject)=>{const worker=new Worker('./worker.js',{type:'module'});worker.onmessage=e=>{if(e.data.ready){worker.postMessage('run');return;}worker.terminate();resolve(e.data);};worker.onerror=e=>{worker.terminate();reject(Error(e.message));};});
    248       same(workerResult,{value:[77]});passed('dedicated worker actual WASM and IndexedDB reopen');
    249       const outbox=await WorkspaceFixture.create(160);
    250       const workspaceReceipt={n:160,fingerprint:Array.from(outbox.fingerprint()),selection:Array.from(outbox.selection()),proof:Array.from(outbox.proof()),namespace:outbox.data_namespace()};
    251       same(await outbox.authenticate(),1);
    252       await rejects(()=>outbox.wrong_proof(),'unauthorized');await rejects(()=>outbox.wrong_selection(),'unauthorized');
    253       await rejects(()=>outbox.contended_open(),'writer_active');same(await outbox.authenticate(),1);
    254       passed('actual protected browser buyer enrollment, authentication and exclusive writer contention');
    255       const rawWorkspace=receipt=>new Promise((resolve,reject)=>{const r=indexedDB.open(receipt.namespace,1);r.onupgradeneeded=()=>r.transaction.abort();r.onsuccess=()=>resolve(r.result);r.onerror=reject;});
    256       const workspaceBytes=async receipt=>{const raw=await rawWorkspace(receipt);try{return await new Promise((resolve,reject)=>{const tx=raw.transaction('records','readonly');const store=tx.objectStore('records');let keys,values;store.getAllKeys().onsuccess=e=>keys=e.target.result;store.getAll().onsuccess=e=>values=e.target.result;tx.oncomplete=()=>resolve({keys,values});tx.onabort=reject;});}finally{raw.close();}};
    257       const changeWorkspace=async(receipt,change)=>{const raw=await rawWorkspace(receipt);try{await new Promise((resolve,reject)=>{const tx=raw.transaction('records','readwrite');change(tx.objectStore('records'));tx.oncomplete=resolve;tx.onabort=reject;});}finally{raw.close();}};
    258       const originalGrant=await workspaceBytes(workspaceReceipt);same(originalGrant.values.length,1);
    259       outbox.expire_after_next_read();await rejects(()=>outbox.revoke(),'grant_expired');outbox.set_time(1000);
    260       const afterRefusal=await workspaceBytes(workspaceReceipt);same(Array.from(afterRefusal.values[0]),Array.from(originalGrant.values[0]));same(await outbox.authenticate(),1);
    261       outbox.set_time(2000);await rejects(()=>outbox.authenticate(),'grant_expired');outbox.set_time(1000);
    262       passed('actual active write callback refuses expiry after asynchronous wrapping and retains the original grant');
    263       const keyBytes=v=>Array.from(v instanceof ArrayBuffer?new Uint8Array(v):v);
    264       const journal=await WorkspaceFixture.create(171);
    265       const journalReceipt={n:171,fingerprint:Array.from(journal.fingerprint()),selection:Array.from(journal.selection()),proof:Array.from(journal.proof()),namespace:journal.data_namespace()};
    266       const originalPreparation=Array.from(await journal.admit(65,false));same(originalPreparation.length,80);
    267       same(Array.from(await journal.query(65)),originalPreparation);same(Array.from(await journal.query(66)),[]);
    268       const journalBytes=await workspaceBytes(journalReceipt);same(journalBytes.values.length,4);
    269       for(const bytes of journalBytes.values)if(bytes.length>32768)throw Error('oversized protected private record');
    270       journal.set_time(1600);
    271       const originalRandom=Crypto.prototype.getRandomValues;
    272       try{Crypto.prototype.getRandomValues=()=>{throw Error('replay acquired new entropy');};same(Array.from(await journal.admit(65,false)),originalPreparation);}
    273       finally{Crypto.prototype.getRandomValues=originalRandom;}
    274       await rejects(()=>journal.admit(65,true),'idempotency_conflict');
    275       same(Array.from(await journal.query(65)),originalPreparation);
    276       passed('actual atomic protected multipart T0 and exact late replay without new entropy');
    277       journal.set_time(1000);await rejects(()=>journal.admit_expiring(66),'deadline_exceeded');
    278       same(Array.from(await journal.query(66)),[]);
    279       const afterLate=await workspaceBytes(journalReceipt);
    280       same(afterLate.values.map(v=>Array.from(v)),journalBytes.values.map(v=>Array.from(v)));
    281       same(afterLate.keys.map(keyBytes),journalBytes.keys.map(keyBytes));
    282       passed('late command expiry after actual encryption aborts every operation part');
    283       journal.set_time(1000);
    284       const originalPut=IDBObjectStore.prototype.put;let puts=0;
    285       try{IDBObjectStore.prototype.put=function(...args){const request=originalPut.apply(this,args);if(this.transaction.db.name===journalReceipt.namespace&&++puts===2)this.transaction.abort();return request;};await rejects(()=>journal.admit(69,false),'storage_failure');}
    286       finally{IDBObjectStore.prototype.put=originalPut;}
    287       same(puts,2);same(Array.from(await journal.query(69)),[]);
    288       const afterAbort=await workspaceBytes(journalReceipt);same(afterAbort.values.map(v=>Array.from(v)),journalBytes.values.map(v=>Array.from(v)));
    289       passed('actual aborted multipart admission leaves no acknowledged or partial preparation');
    290       journal.set_time(1000);await journal.abandon_admission(67);journal.abandon_close();await journal.close();
    291       let retainedJournal=await WorkspaceFixture.open(journalReceipt.n,new Uint8Array(journalReceipt.fingerprint),new Uint8Array(journalReceipt.selection),new Uint8Array(journalReceipt.proof));
    292       const abandonedPreparation=Array.from(await retainedJournal.query(67));same(abandonedPreparation.length,80);
    293       same(Array.from(await retainedJournal.query(65)),originalPreparation);await retainedJournal.close();
    294       passed('unobserved accepted T0 survives cancelled close and exact protected reopen');
    295       const recordKey=async(n,kind,recipient=0,part=0)=>{const prefix=new Uint8Array(await crypto.subtle.digest('SHA-256',new Uint8Array([...new TextEncoder().encode('radroots.browser.local_outbox.operation.prefix.v2\0'),...new Uint8Array(32).fill(n)])));const key=new Uint8Array(32);key.set(prefix.subarray(0,16));key[16]=kind;key[17]=recipient;key[20]=part;return key;};
    296       const operationKey=(n,slot)=>recordKey(n,1,0,slot);
    297       const actualCursor=IDBObjectStore.prototype.openCursor;
    298       const exactCursorKey=range=>{if(!range||range.lower===undefined||range.upper===undefined||range.lowerOpen||range.upperOpen)return;const lower=keyBytes(range.lower),upper=keyBytes(range.upper);if(lower.length===32&&JSON.stringify(lower)===JSON.stringify(upper))return lower;};
    299       const manifestKey=await operationKey(65,0),part1=await operationKey(65,1),part2=await operationKey(65,2);
    300       const retainedJournalBytes=await workspaceBytes(journalReceipt);
    301       const findBytes=k=>retainedJournalBytes.values[retainedJournalBytes.keys.findIndex(x=>JSON.stringify(keyBytes(x))===JSON.stringify(keyBytes(k)))];
    302       for(const mode of ['orphan','missing_part','tampered','swapped_parts','wrong_operation']){
    303         await changeWorkspace(journalReceipt,store=>{
    304           if(mode==='orphan')store.delete(manifestKey);
    305           if(mode==='missing_part')store.delete(part1);
    306           if(mode==='tampered'){const bytes=new Uint8Array(findBytes(part1));bytes[bytes.length-1]^=1;store.put(bytes,part1);}
    307           if(mode==='swapped_parts'){store.put(findBytes(part1),part2);store.put(findBytes(part2),part1);}
    308         });
    309         retainedJournal=await WorkspaceFixture.open(journalReceipt.n,new Uint8Array(journalReceipt.fingerprint),new Uint8Array(journalReceipt.selection),new Uint8Array(journalReceipt.proof));
    310         if(mode==='wrong_operation'){const foreignKey=await operationKey(68,0);await changeWorkspace(journalReceipt,store=>store.put(findBytes(manifestKey),foreignKey));}
    311         const beforeFailure=await workspaceBytes(journalReceipt);
    312         if(mode==='wrong_operation'){
    313           await rejects(()=>retainedJournal.query(68),'recovery_required');
    314         }else await rejects(()=>retainedJournal.query(65),'recovery_required');
    315         await retainedJournal.close();
    316         const damaged=await workspaceBytes(journalReceipt);same(damaged.keys.map(keyBytes),beforeFailure.keys.map(keyBytes));same(damaged.values.map(v=>Array.from(v)),beforeFailure.values.map(v=>Array.from(v)));
    317         // Failed lookup does not repair or replace any retained bytes.
    318         await changeWorkspace(journalReceipt,store=>{store.clear();retainedJournalBytes.keys.forEach((k,i)=>store.put(retainedJournalBytes.values[i],k));});
    319         if(!damaged.values.length)throw Error('failed lookup discarded the namespace');
    320       }
    321       retainedJournal=await WorkspaceFixture.open(journalReceipt.n,new Uint8Array(journalReceipt.fingerprint),new Uint8Array(journalReceipt.selection),new Uint8Array(journalReceipt.proof));
    322       same(Array.from(await retainedJournal.query(65)),originalPreparation);await retainedJournal.close();
    323       passed('orphan, missing, tampered, swapped and foreign-context preparation parts refuse without replacement');
    324       const uncertain=await WorkspaceFixture.create(174);
    325       const uncertainReceipt={n:174,fingerprint:Array.from(uncertain.fingerprint()),selection:Array.from(uncertain.selection()),proof:Array.from(uncertain.proof()),namespace:uncertain.data_namespace()};
    326       const actualAbort=IDBTransaction.prototype.abort;let refusedAbort=0;
    327       let uncertainAnchor;
    328       const uncertainPart=keyBytes(await operationKey(70,1));let actualLatePart=false;
    329       try{IDBObjectStore.prototype.openCursor=function(...args){const request=actualCursor.apply(this,args);if(this.transaction.db.name===uncertainReceipt.namespace&&this.transaction.mode==='readwrite'&&JSON.stringify(exactCursorKey(args[0]))===JSON.stringify(uncertainPart))request.addEventListener('success',()=>{actualLatePart=true;uncertain.set_time(1500);},{once:true});return request;};IDBTransaction.prototype.abort=function(){if(this.db.name===uncertainReceipt.namespace){refusedAbort++;return;}return actualAbort.call(this);};uncertainAnchor=Array.from(await uncertain.admit_uncertain(70));}
    330       finally{IDBObjectStore.prototype.openCursor=actualCursor;IDBTransaction.prototype.abort=actualAbort;}
    331       same(actualLatePart,true);
    332       same(uncertainAnchor.length,96);same(uncertainAnchor.slice(0,32),new Array(32).fill(70));same(refusedAbort,1);
    333       await uncertain.close();await rejects(()=>uncertain.authenticate(),'closed');
    334       const partial=await workspaceBytes(uncertainReceipt);same(partial.values.length,2);
    335       const uncertainReopen=await WorkspaceFixture.open(uncertainReceipt.n,new Uint8Array(uncertainReceipt.fingerprint),new Uint8Array(uncertainReceipt.selection),new Uint8Array(uncertainReceipt.proof));
    336       await rejects(()=>uncertainReopen.query(70),'recovery_required');await uncertainReopen.close();
    337       const preservedPartial=await workspaceBytes(uncertainReceipt);same(preservedPartial.values.map(v=>Array.from(v)),partial.values.map(v=>Array.from(v)));
    338       passed('actual completion despite suppressed abort retains original unknown attempt and refuses partial-state reopen');
    339       const uncertainGrant=await WorkspaceFixture.create(175);
    340       const uncertainGrantReceipt={n:175,fingerprint:Array.from(uncertainGrant.fingerprint()),selection:Array.from(uncertainGrant.selection()),proof:Array.from(uncertainGrant.proof()),namespace:uncertainGrant.data_namespace()};
    341       const originalUncertainGrant=await workspaceBytes(uncertainGrantReceipt);uncertainGrant.expire_after_next_read();
    342       try{IDBTransaction.prototype.abort=function(){if(this.db.name===uncertainGrantReceipt.namespace)return;return actualAbort.call(this);};await rejects(()=>uncertainGrant.revoke(),'commit_unknown');}
    343       finally{IDBTransaction.prototype.abort=actualAbort;}
    344       await uncertainGrant.close();const afterUncertainGrant=await workspaceBytes(uncertainGrantReceipt);
    345       same(afterUncertainGrant.values.map(v=>Array.from(v)),originalUncertainGrant.values.map(v=>Array.from(v)));
    346       const grantReopen=await WorkspaceFixture.open(uncertainGrantReceipt.n,new Uint8Array(uncertainGrantReceipt.fingerprint),new Uint8Array(uncertainGrantReceipt.selection),new Uint8Array(uncertainGrantReceipt.proof));same(await grantReopen.authenticate(),1);await grantReopen.close();
    347       passed('grant refusal cannot conceal actual uncertain completion or replace original protected state');
    348 
    349       const unknownRead=await WorkspaceFixture.create(176);
    350       const unknownReadReceipt={n:176,fingerprint:Array.from(unknownRead.fingerprint()),selection:Array.from(unknownRead.selection()),proof:Array.from(unknownRead.proof()),namespace:unknownRead.data_namespace()};
    351       let originalFallback;
    352       try{originalFallback=Array.from(await unknownRead.admit_read_unknown(72,()=>{
    353         IDBObjectStore.prototype.openCursor=function(...args){if(this.transaction.db.name===unknownReadReceipt.namespace&&exactCursorKey(args[0]))throw new DOMException('synthetic host read failure','InvalidStateError');return actualCursor.apply(this,args);};
    354         IDBTransaction.prototype.abort=function(){if(this.db.name===unknownReadReceipt.namespace)return;return actualAbort.call(this);};
    355       }));}finally{IDBObjectStore.prototype.openCursor=actualCursor;IDBTransaction.prototype.abort=actualAbort;}
    356       same(originalFallback.length,64);same(originalFallback.slice(0,32),new Array(32).fill(72));await unknownRead.close();
    357       const readReopen=await WorkspaceFixture.open(unknownReadReceipt.n,new Uint8Array(unknownReadReceipt.fingerprint),new Uint8Array(unknownReadReceipt.selection),new Uint8Array(unknownReadReceipt.proof));same(Array.from(await readReopen.query(72)),[]);await readReopen.close();
    358       passed('uncertain original admission read retains the captured operation anchor without inventing a transaction');
    359       const receiptOf=(owner,n)=>({n,fingerprint:Array.from(owner.fingerprint()),selection:Array.from(owner.selection()),proof:Array.from(owner.proof()),namespace:owner.data_namespace()});
    360       const openPlanReceipt=r=>WorkspaceFixture.open(r.n,new Uint8Array(r.fingerprint),new Uint8Array(r.selection),new Uint8Array(r.proof));
    361       const sameRows=(a,b)=>{same(a.keys.map(keyBytes),b.keys.map(keyBytes));same(a.values.map(v=>Array.from(v)),b.values.map(v=>Array.from(v)));};
    362       const planBox=await WorkspaceFixture.create(180),planReceipt=receiptOf(planBox,180);
    363       await planBox.admit(180,false);same(Array.from(await planBox.plan_query(180)),[]);
    364       const planWire=await planBox.new_plan(180);if(planWire.length<=16384)throw Error('plan did not exercise multipart storage');
    365       const originalPlan=Array.from(await planBox.bind_plan(180,planWire));same(originalPlan.length,108);
    366       same(new DataView(new Uint8Array(originalPlan).buffer).getUint32(72,false),planWire.length);
    367       same(Array.from(await planBox.plan_query(180)),originalPlan);
    368       const planStored=await workspaceBytes(planReceipt);if(planStored.values.length<8)throw Error('missing actual protected plan parts');
    369       for(const v of planStored.values)if(v.length>32768)throw Error('oversized protected private plan record');
    370       passed('actual peer/self NIP44, verified signed routes and atomic complete multipart T1 bind/query');
    371       await rejects(()=>planBox.bind_plan_foreign(180,planWire),'unauthorized');
    372       sameRows(await workspaceBytes(planReceipt),planStored);
    373       passed('a valid foreign workspace binding cannot authorize T1 in the original owner');
    374       planBox.set_time(1600);const oldPlanRandom=Crypto.prototype.getRandomValues;
    375       try{Crypto.prototype.getRandomValues=()=>{throw Error('retained T1 acquired new entropy');};same(Array.from(await planBox.bind_plan(180,planWire)),originalPlan);}
    376       finally{Crypto.prototype.getRandomValues=oldPlanRandom;}
    377       const conflictingPlan=await planBox.new_plan(180);await rejects(()=>planBox.bind_plan(180,conflictingPlan),'idempotency_conflict');
    378       same(Array.from(await planBox.plan_query(180)),originalPlan);
    379       passed('exact late T1 replay retains original transaction/window without new entropy and refuses conflicting plans');
    380       planBox.set_time(1000);await planBox.admit(181,false);const expiringPlan=await planBox.new_plan(181);
    381       const beforePlanExpiry=await workspaceBytes(planReceipt);await rejects(()=>planBox.bind_plan_expiring(181,expiringPlan),'deadline_exceeded');
    382       same(Array.from(await planBox.plan_query(181)),[]);sameRows(await workspaceBytes(planReceipt),beforePlanExpiry);
    383       passed('fresh T1 expiry after actual wrapping rolls back the entire grant/T0/plan comparison batch');
    384       planBox.set_time(1000);await planBox.admit(182,false);const abortedPlan=await planBox.new_plan(182);
    385       const planKey=(n,slot)=>recordKey(n,2,0,slot);
    386       const abortPlanKey=await planKey(182,1),beforePlanAbort=await workspaceBytes(planReceipt);let planWriteAborted=false;
    387       const actualPlanPut=IDBObjectStore.prototype.put;
    388       try{IDBObjectStore.prototype.put=function(...args){const request=actualPlanPut.apply(this,args);if(this.transaction.db.name===planReceipt.namespace&&JSON.stringify(keyBytes(args[1]))===JSON.stringify(keyBytes(abortPlanKey))){request.addEventListener('success',()=>{planWriteAborted=true;this.transaction.abort();});}return request;};await rejects(()=>planBox.bind_plan(182,abortedPlan),'storage_failure');}
    389       finally{IDBObjectStore.prototype.put=actualPlanPut;}
    390       same(planWriteAborted,true);sameRows(await workspaceBytes(planReceipt),beforePlanAbort);same(Array.from(await planBox.plan_query(182)),[]);
    391       passed('actual T1 part-write success followed by transaction abort never acknowledges or retains partial binding');
    392       await planBox.abandon_plan(182,abortedPlan);same(planBox.abandon_auths(1),0);planBox.abandon_close();await planBox.close();
    393       let currentPlanBox=await openPlanReceipt(planReceipt);same((await currentPlanBox.plan_query(182)).length,108);same(Array.from(await currentPlanBox.plan_query(180)),originalPlan);
    394       await currentPlanBox.admit(184,false);await currentPlanBox.close();
    395       passed('unobserved accepted T1 retains its job reservation and survives cancelled close with original stored result');
    396       const stablePlans=await workspaceBytes(planReceipt),planKeys=await Promise.all(Array.from({length:25},(_,i)=>planKey(180,i))),foreignPlanKeys=await Promise.all(Array.from({length:25},(_,i)=>planKey(184,i)));
    397       const findPlanBytes=k=>stablePlans.values[stablePlans.keys.findIndex(x=>JSON.stringify(keyBytes(x))===JSON.stringify(keyBytes(k)))];
    398       for(const mode of ['orphan_manifest','missing_part','tampered','swapped','foreign_operation','missing_t0_query','missing_t0_admit']){
    399         await changeWorkspace(planReceipt,store=>{
    400           if(mode==='orphan_manifest')store.delete(planKeys[0]);
    401           if(mode==='missing_part')store.delete(planKeys[1]);
    402           if(mode==='tampered'){const bytes=new Uint8Array(findPlanBytes(planKeys[1]));bytes[bytes.length-1]^=1;store.put(bytes,planKeys[1]);}
    403           if(mode==='swapped'){store.put(findPlanBytes(planKeys[1]),planKeys[2]);store.put(findPlanBytes(planKeys[2]),planKeys[1]);}
    404           if(mode==='foreign_operation')planKeys.forEach((k,i)=>{const v=findPlanBytes(k);if(v)store.put(v,foreignPlanKeys[i]);});
    405         });
    406         if(mode.startsWith('missing_t0')){const t0=await Promise.all(Array.from({length:5},(_,i)=>operationKey(180,i)));await changeWorkspace(planReceipt,store=>t0.forEach(k=>store.delete(k)));}
    407         const beforeFailure=await workspaceBytes(planReceipt);currentPlanBox=await openPlanReceipt(planReceipt);
    408         if(mode==='missing_t0_query')await rejects(()=>currentPlanBox.query(180),'recovery_required');
    409         else if(mode==='missing_t0_admit')await rejects(()=>currentPlanBox.admit(180,false),'recovery_required');
    410         else await rejects(()=>currentPlanBox.plan_query(mode==='foreign_operation'?184:180),'recovery_required');
    411         await currentPlanBox.close();sameRows(await workspaceBytes(planReceipt),beforeFailure);
    412         await changeWorkspace(planReceipt,store=>{store.clear();stablePlans.keys.forEach((k,i)=>store.put(stablePlans.values[i],k));});
    413       }
    414       passed('T1 orphan/missing/tampered/swapped/foreign parts and removed T0 refuse without absence, replacement or repair');
    415       const unknownPlan=await WorkspaceFixture.create(183),unknownPlanReceipt=receiptOf(unknownPlan,183);
    416       await unknownPlan.admit(183,false);const unknownPlanWire=await unknownPlan.new_plan(183);let planUnknown;
    417       const latePlanPart=keyBytes(await planKey(183,1));let actualLatePlanPart=false;
    418       try{IDBObjectStore.prototype.openCursor=function(...args){const request=actualCursor.apply(this,args);if(this.transaction.db.name===unknownPlanReceipt.namespace&&this.transaction.mode==='readwrite'&&JSON.stringify(exactCursorKey(args[0]))===JSON.stringify(latePlanPart))request.addEventListener('success',()=>{actualLatePlanPart=true;unknownPlan.set_time(1500);},{once:true});return request;};IDBTransaction.prototype.abort=function(){if(this.db.name===unknownPlanReceipt.namespace)return;return actualAbort.call(this);};planUnknown=Array.from(await unknownPlan.bind_plan_unknown(183,unknownPlanWire));}
    419       finally{IDBObjectStore.prototype.openCursor=actualCursor;IDBTransaction.prototype.abort=actualAbort;}
    420       same(actualLatePlanPart,true);
    421       same(planUnknown.length,64);same(planUnknown.slice(0,32),new Array(32).fill(183));await unknownPlan.close();
    422       const unknownPlanState=await workspaceBytes(unknownPlanReceipt);const unknownPlanOpen=await openPlanReceipt(unknownPlanReceipt);await rejects(()=>unknownPlanOpen.plan_query(183),'recovery_required');await unknownPlanOpen.close();sameRows(await workspaceBytes(unknownPlanReceipt),unknownPlanState);
    423       passed('actual T1 completion despite suppressed abort retains original unknown transaction and preserves partial state');
    424       const unknownPlanRead=await WorkspaceFixture.create(188),unknownPlanReadReceipt=receiptOf(unknownPlanRead,188);
    425       const originalReadT0=Array.from(await unknownPlanRead.admit(188,false)),readPlanWire=await unknownPlanRead.new_plan(188),beforePlanRead=await workspaceBytes(unknownPlanReadReceipt);let planReadGets=0,planReadFallback;
    426       try{planReadFallback=Array.from(await unknownPlanRead.bind_plan_read_unknown(188,readPlanWire,()=>{
    427         IDBObjectStore.prototype.openCursor=function(...args){if(this.transaction.db.name===unknownPlanReadReceipt.namespace&&exactCursorKey(args[0])&&++planReadGets===2)throw new DOMException('synthetic retained-record read failure','InvalidStateError');return actualCursor.apply(this,args);};
    428         IDBTransaction.prototype.abort=function(){if(this.db.name===unknownPlanReadReceipt.namespace)return;return actualAbort.call(this);};
    429       }));}finally{IDBObjectStore.prototype.openCursor=actualCursor;IDBTransaction.prototype.abort=actualAbort;}
    430       same(planReadFallback.length,64);same(planReadFallback.slice(0,32),new Array(32).fill(188));await unknownPlanRead.close();
    431       const restoredRead=await openPlanReceipt(unknownPlanReadReceipt);same(Array.from(await restoredRead.query(188)),originalReadT0);same(Array.from(await restoredRead.plan_query(188)),[]);await restoredRead.close();sameRows(await workspaceBytes(unknownPlanReadReceipt),beforePlanRead);
    432       passed('uncertain retained T1 input read preserves the original ID/digest without inventing a transaction or changing T0');
    433       for(const mode of ['bad_clock','expired_grant']){
    434         const n=mode==='bad_clock'?185:186,owner=await WorkspaceFixture.create(n),r=receiptOf(owner,n);await owner.admit(n,false);const wire=await owner.new_plan(n),before=await workspaceBytes(r);
    435         await rejects(()=>mode==='bad_clock'?owner.bind_plan_bad_clock(n,wire):owner.bind_plan_expired_grant(n,wire),mode==='bad_clock'?'workspace_unavailable':'grant_expired');await owner.close();sameRows(await workspaceBytes(r),before);
    436         const restored=await openPlanReceipt(r);same(Array.from(await restored.plan_query(n)),[]);await restored.close();
    437       }
    438       passed('backwards clock and grant expiry after T1 crypto refuse with unchanged original state');
    439       const setupIssuance=async n=>{const owner=await WorkspaceFixture.create(n),receipt=receiptOf(owner,n);await owner.admit(n,false);await owner.bind_plan(n,await owner.new_plan(n));return {owner,receipt};};
    440       const {owner:signing,receipt:signingReceipt}=await setupIssuance(190);
    441       same(Array.from(await signing.attempt(190,0)),[]);same(Array.from(await signing.captured(190,0)),[]);
    442       const selfSeal=await signing.obtain(190,0,false),peerSeal=await signing.obtain(190,1,true);
    443       same(selfSeal.malformed_output_refused(),true);same(peerSeal.malformed_output_refused(),true);
    444       const originalClaim=Array.from(selfSeal.original_claim()),peerClaim=Array.from(peerSeal.original_claim());
    445       same(originalClaim.length,144);same(Array.from(await signing.attempt(190,0)),originalClaim);same(Array.from(await signing.attempt(190,1)),peerClaim);
    446       const originalSeal=Array.from(await signing.capture(selfSeal)),peerCapture=Array.from(await signing.capture(peerSeal));
    447       same(originalSeal.length,136);same(originalSeal.slice(32,64),Array.from(selfSeal.digest()));same(originalSeal.slice(64,96),originalClaim.slice(0,32));same(originalSeal.slice(104),originalClaim.slice(112));
    448       same(Number(new DataView(new Uint8Array(originalSeal).buffer).getBigUint64(96,false)),0);same(Number(new DataView(new Uint8Array(peerCapture).buffer).getBigUint64(96,false)),1000000);
    449       same(Array.from(await signing.captured(190,0)),originalSeal);same(Array.from(await signing.captured(190,1)),peerCapture);
    450       const signedRows=await workspaceBytes(signingReceipt);const evidenceRows=signedRows.keys.filter(k=>keyBytes(k)[16]===4);if(evidenceRows.length<6)throw Error('obtained seals did not exercise multipart evidence');
    451       passed('actual self/peer signatures match original claims and persist verified multipart output with exact observation uncertainty');
    452       signing.set_time(1600);
    453       try{Crypto.prototype.getRandomValues=()=>{throw Error('retained S acquired new entropy');};same(Array.from(await signing.claim(190,0)),[0,...originalClaim]);same(Array.from(await signing.capture(selfSeal)),originalSeal);await rejects(()=>signing.obtain(190,0,false),'retained_no_dispatch');}
    454       finally{Crypto.prototype.getRandomValues=originalRandom;}
    455       signing.set_time(0);same(Array.from(await signing.capture(selfSeal)),originalSeal);same(Array.from(await signing.capture_reobserved(selfSeal)),originalSeal);signing.set_time(1000);
    456       await rejects(()=>signing.capture_alternate(selfSeal),'idempotency_conflict');same(Array.from(await signing.captured(190,0)),originalSeal);
    457       await signing.close();let reopenedSigning=await openPlanReceipt(signingReceipt);same(Array.from(await reopenedSigning.attempt(190,0)),originalClaim);same(Array.from(await reopenedSigning.captured(190,1)),peerCapture);await reopenedSigning.close();
    458       passed('late S replay and unavailable-clock capture retain original identities without fresh entropy or redispatch');
    459       const stableSigning=await workspaceBytes(signingReceipt),evidenceKey=await recordKey(190,4,0,1),claimKey=await recordKey(190,3,0,0),evidenceManifest=await recordKey(190,4,0,0),otherEvidence=await recordKey(190,4,1,1);
    460       const signingValue=k=>stableSigning.values[stableSigning.keys.findIndex(x=>JSON.stringify(keyBytes(x))===JSON.stringify(keyBytes(k)))];
    461       for(const mode of ['missing_part','missing_evidence_manifest','tampered','tampered_claim','swapped_recipient','swapped_claim_recipient','missing_claim','missing_t0','missing_t1','unsupported_address']){
    462         console.log('STEP issuance_damage '+mode);
    463         const removeT0=await operationKey(190,0),removeT1=await planKey(190,0),unsupported=await recordKey(190,9);
    464         await changeWorkspace(signingReceipt,store=>{
    465           if(mode==='missing_part')store.delete(evidenceKey);
    466           if(mode==='missing_evidence_manifest')store.delete(evidenceManifest);
    467           if(mode==='tampered'){const v=new Uint8Array(signingValue(evidenceKey));v[v.length-1]^=1;store.put(v,evidenceKey);}
    468           if(mode==='tampered_claim'){const v=new Uint8Array(signingValue(claimKey));v[v.length-1]^=1;store.put(v,claimKey);}
    469           if(mode==='swapped_recipient')store.put(signingValue(otherEvidence),evidenceKey);
    470           if(mode==='swapped_claim_recipient'){const other=stableSigning.keys.find(k=>keyBytes(k)[16]===3&&keyBytes(k)[17]===1);store.put(signingValue(other),claimKey);}
    471           if(mode==='missing_claim')store.delete(claimKey);
    472           if(mode==='missing_t0')store.delete(removeT0);
    473           if(mode==='missing_t1')store.delete(removeT1);
    474           if(mode==='unsupported_address')store.put(new Uint8Array(),unsupported);
    475         });
    476         const broken=await workspaceBytes(signingReceipt);reopenedSigning=await openPlanReceipt(signingReceipt);
    477         await rejects(()=>reopenedSigning.captured_original(selfSeal),'recovery_required');await reopenedSigning.close();reopenedSigning=await openPlanReceipt(signingReceipt);
    478         await rejects(()=>reopenedSigning.capture(selfSeal),'recovery_required');
    479         if(mode==='missing_claim'){await reopenedSigning.close();reopenedSigning=await openPlanReceipt(signingReceipt);await rejects(()=>reopenedSigning.claim(190,0),'recovery_required');}
    480         await reopenedSigning.close();sameRows(await workspaceBytes(signingReceipt),broken);
    481         await changeWorkspace(signingReceipt,store=>{store.clear();stableSigning.keys.forEach((k,i)=>store.put(stableSigning.values[i],k));});
    482       }
    483       passed('missing, damaged, foreign-recipient and orphan issuance state refuses without replacing any retained bytes');
    484       const {owner:revokedSigning,receipt:revokedSigningReceipt}=await setupIssuance(191),revokedSeal=await revokedSigning.obtain(191,0,false),revokedPeer=await revokedSigning.obtain(191,1,true);
    485       await revokedSigning.revoke();revokedSigning.set_time(0);const revokedCapture=Array.from(await revokedSigning.capture(revokedSeal));await revokedSigning.close();
    486       await rejects(()=>openPlanReceipt(revokedSigningReceipt),'grant_revoked');
    487       const captureOnly=await WorkspaceFixture.open_capture(191,new Uint8Array(revokedSigningReceipt.fingerprint),new Uint8Array(revokedSigningReceipt.selection),new Uint8Array(revokedSigningReceipt.proof));
    488       await rejects(()=>captureOnly.authenticate(),'unauthorized');await rejects(()=>captureOnly.claim(191,0),'unauthorized');
    489       captureOnly.set_time(0);const revokedPeerCapture=Array.from(await captureOnly.capture(revokedPeer));same(Array.from(await captureOnly.capture(revokedSeal)),revokedCapture);same(revokedPeerCapture.slice(64,96),Array.from(revokedPeer.original_claim()).slice(0,32));await captureOnly.close();
    490       passed('revoked grant and unavailable clock preserve obtained output through capture-only reopen without restoring fresh authority');
    491       const {owner:expiredSigning,receipt:expiredSigningReceipt}=await setupIssuance(199),expiredSeal=await expiredSigning.obtain(199,0,true);expiredSigning.set_time(2000);await rejects(()=>expiredSigning.authenticate(),'grant_expired');const expiredReceipt=Array.from(await expiredSigning.capture(expiredSeal));same(expiredReceipt.slice(32,64),Array.from(expiredSeal.digest()));await expiredSigning.close();
    492       const afterExpiredCapture=await openPlanReceipt(expiredSigningReceipt);same(Array.from(await afterExpiredCapture.captured(199,0)),expiredReceipt);await afterExpiredCapture.close();passed('already obtained output appends after actual grant expiry and retains its original receipt after reopen');
    493       const {owner:unobservedSealOwner,receipt:unobservedSealReceipt}=await setupIssuance(192),unobservedSeal=await unobservedSealOwner.obtain(192,0,true);
    494       unobservedSealOwner.abandon_capture(unobservedSeal);same(unobservedSealOwner.abandon_auths(1),0);unobservedSealOwner.abandon_close();await unobservedSealOwner.close();
    495       const afterUnobservedSeal=await openPlanReceipt(unobservedSealReceipt);same(Array.from(await afterUnobservedSeal.captured(192,0)).slice(32,64),Array.from(unobservedSeal.digest()));await afterUnobservedSeal.close();
    496       passed('unobserved obtained-output capture keeps its reservation and survives cancelled close and exact reopen');
    497       const {owner:freshClaimOwner,receipt:freshClaimReceipt}=await setupIssuance(197),beforeFreshClaim=await workspaceBytes(freshClaimReceipt),actualWrapKey=SubtleCrypto.prototype.wrapKey;let changedClaimClock=false;
    498       try{SubtleCrypto.prototype.wrapKey=async function(...args){const wrapped=await actualWrapKey.apply(this,args);changedClaimClock=true;freshClaimOwner.set_time(1500);return wrapped;};await rejects(()=>freshClaimOwner.claim(197,0),'deadline_exceeded');}
    499       finally{SubtleCrypto.prototype.wrapKey=actualWrapKey;}
    500       same(changedClaimClock,true);freshClaimOwner.set_time(1000);same(Array.from(await freshClaimOwner.attempt(197,0)),[]);sameRows(await workspaceBytes(freshClaimReceipt),beforeFreshClaim);await freshClaimOwner.close();
    501       passed('fresh claim deadline crossed after actual key wrapping aborts without retaining an issuance claim');
    502       const {owner:abortSigning,receipt:abortSigningReceipt}=await setupIssuance(198);await rejects(()=>abortSigning.capture(selfSeal),'invalid_evidence');
    503       const abortClaimKey=await recordKey(198,3),beforeAbortClaim=await workspaceBytes(abortSigningReceipt);let claimWriteSucceeded=false;
    504       try{IDBObjectStore.prototype.put=function(...args){const r=actualPlanPut.apply(this,args);if(this.transaction.db.name===abortSigningReceipt.namespace&&JSON.stringify(keyBytes(args[1]))===JSON.stringify(keyBytes(abortClaimKey)))r.addEventListener('success',()=>{claimWriteSucceeded=true;this.transaction.abort();},{once:true});return r;};await rejects(()=>abortSigning.claim(198,0),'storage_failure');}
    505       finally{IDBObjectStore.prototype.put=actualPlanPut;}
    506       same(claimWriteSucceeded,true);same(Array.from(await abortSigning.attempt(198,0)),[]);sameRows(await workspaceBytes(abortSigningReceipt),beforeAbortClaim);
    507       const abortSeal=await abortSigning.obtain(198,0,false),abortEvidenceKey=await recordKey(198,4,0,1),beforeAbortCapture=await workspaceBytes(abortSigningReceipt);let sealWriteSucceeded=false;
    508       try{IDBObjectStore.prototype.put=function(...args){const r=actualPlanPut.apply(this,args);if(this.transaction.db.name===abortSigningReceipt.namespace&&JSON.stringify(keyBytes(args[1]))===JSON.stringify(keyBytes(abortEvidenceKey)))r.addEventListener('success',()=>{sealWriteSucceeded=true;this.transaction.abort();},{once:true});return r;};await rejects(()=>abortSigning.capture(abortSeal),'storage_failure');}
    509       finally{IDBObjectStore.prototype.put=actualPlanPut;}
    510       same(sealWriteSucceeded,true);same(Array.from(await abortSigning.captured(198,0)),[]);sameRows(await workspaceBytes(abortSigningReceipt),beforeAbortCapture);same((await abortSigning.capture(abortSeal)).length,136);await abortSigning.close();
    511       passed('foreign-workspace output refuses and actual claim/capture aborts after write success acknowledge no retained fact');
    512 
    513       const rawChange=async(n,change)=>{const raw=await rawOpen(n);try{await new Promise((resolve,reject)=>{const tx=raw.transaction('records','readwrite');change(tx.objectStore('records'));tx.oncomplete=resolve;tx.onabort=reject;});}finally{raw.close();}};
    514       const opaqueKey=n=>new Uint8Array(32).fill(n);
    515       const snapshots=await Fixture.open(30,true);await snapshots.write(1,undefined,new Uint8Array([1]));
    516       const originalSnapshot=await snapshots.snapshot(1);same(originalSnapshot.len(),1);same(originalSnapshot.redacted(),true);originalSnapshot.verify(1,new Uint8Array([1]));await rejects(()=>originalSnapshot.verify(1,new Uint8Array([2])),'record_conflict');await rejects(()=>originalSnapshot.verify(2,undefined),'invalid_input');
    517       const foreignConnection=await Fixture.open(30,false);await rejects(()=>foreignConnection.guarded_write(originalSnapshot,2,undefined,new Uint8Array([2])),'invalid_input');await foreignConnection.close();same(await value(snapshots,2),undefined);
    518       const changedSnapshot=await snapshots.snapshot(1);await snapshots.write(1,new Uint8Array([1]),new Uint8Array([2]));await rejects(()=>snapshots.guarded_write(changedSnapshot,2,undefined,new Uint8Array([2])),'record_conflict');same(await value(snapshots,2),undefined);
    519       const removedSnapshot=await snapshots.snapshot(1);await snapshots.write(1,new Uint8Array([2]),undefined);await rejects(()=>snapshots.guarded_write(removedSnapshot,2,undefined,new Uint8Array([2])),'record_conflict');
    520       const insertedSnapshot=await snapshots.snapshot(1);same(insertedSnapshot.len(),0);await snapshots.write(1,undefined,new Uint8Array([1]));await rejects(()=>snapshots.guarded_write(insertedSnapshot,2,undefined,new Uint8Array([2])),'record_conflict');
    521       same(await snapshots.guarded_write(await snapshots.snapshot(1),2,undefined,new Uint8Array([2])),1);
    522       await rejects(async()=>snapshots.guarded_refusal(await snapshots.snapshot(1),3,undefined,new Uint8Array([3])),'transaction_precondition_refused');same(await value(snapshots,3),undefined);
    523       try{IDBTransaction.prototype.abort=function(){if(this.db.name===name(30))return;return actualAbort.call(this);};await rejects(async()=>snapshots.guarded_refusal(await snapshots.snapshot(1),3,undefined,new Uint8Array([3])),'commit_unknown');}
    524       finally{IDBTransaction.prototype.abort=actualAbort;}
    525       same(await value(snapshots,3),undefined);passed('owner-bound read snapshots detect changed, removed and inserted records in the actual mutation transaction');
    526       await rawChange(30,store=>store.put(undefined,opaqueKey(4)));await rejects(()=>snapshots.read(4),'corrupt_record');await rejects(()=>snapshots.write(4,undefined,new Uint8Array([4])),'corrupt_record');
    527       const stillUndefined=await rawOpen(30);try{same(await new Promise((resolve,reject)=>{const tx=stillUndefined.transaction('records','readonly'),store=tx.objectStore('records');let count,stored;store.count(opaqueKey(4)).onsuccess=e=>count=e.target.result;store.get(opaqueKey(4)).onsuccess=e=>stored=e.target.result;tx.oncomplete=()=>resolve({count,stored});tx.onabort=reject;}),{count:1,stored:undefined});}finally{stillUndefined.close();}
    528       await rejects(()=>snapshots.snapshot(4),'corrupt_record');await rawChange(30,store=>{store.delete(opaqueKey(4));store.put(new Uint8Array(65537),opaqueKey(5));});await rejects(()=>snapshots.snapshot(5),'corrupt_record');
    529       passed('stored undefined and oversized cursor values refuse before replacement or unbounded Rust copying');
    530       const bulkKey=n=>{const k=opaqueKey(17);new DataView(k.buffer).setUint32(28,n,false);return k;};
    531       await rawChange(30,store=>{store.delete(opaqueKey(5));for(let n=0;n<16384;n++)store.put(new Uint8Array(),bulkKey(n));});
    532       const fullSnapshot=await snapshots.snapshot(17);same(fullSnapshot.len(),16384);same(await snapshots.guarded_write(fullSnapshot,6,undefined,new Uint8Array([6])),1);
    533       await rawChange(30,store=>store.put(new Uint8Array(),bulkKey(16384)));await rejects(()=>snapshots.snapshot(17),'capacity_exhausted');
    534       same(snapshots.abandon_snapshots(1,3),2);snapshots.abandon_close();await snapshots.close();const afterSnapshots=await Fixture.open(30,false);same(await value(afterSnapshots,6),[6]);await afterSnapshots.close();
    535       passed('actual 16384-record snapshot bound, excess refusal, bounded abandoned scans and cancelled close');
    536       const durabilityDb=await Fixture.open(32,true),tracedTransaction=IDBDatabase.prototype.transaction;let requestedDurability,observedDurability;
    537       try{IDBDatabase.prototype.transaction=function(...args){if(this.name===name(32)&&args[1]==='readwrite'){requestedDurability=args[2]?.durability;const tx=nativeTransaction.call(this,args[0],args[1]);observedDurability=tx.durability;return tx;}return tracedTransaction.apply(this,args);};await rejects(()=>durabilityDb.write(1,undefined,new Uint8Array([1])),'indexeddb_unavailable');}
    538       finally{IDBDatabase.prototype.transaction=tracedTransaction;}
    539       same(requestedDurability,'strict');if(observedDurability==='strict')throw Error('durability refusal did not exercise ignored strict request');same(await value(durabilityDb,1),undefined);
    540       try{IDBDatabase.prototype.transaction=function(...args){const tx=tracedTransaction.apply(this,args);if(this.name===name(32)&&args[1]==='readwrite'){requestedDurability=args[2]?.durability;observedDurability=tx.durability;}return tx;};same(await durabilityDb.write(1,undefined,new Uint8Array([1])),1);}
    541       finally{IDBDatabase.prototype.transaction=tracedTransaction;}
    542       same(requestedDurability,'strict');same(observedDurability,'strict');await durabilityDb.close();passed('owned writes request and observe strict durability and refuse an actually ignored hint');
    543 
    544       const requestErrorDb=await Fixture.open(31,true);await requestErrorDb.write(1,undefined,new Uint8Array([1]));await requestErrorDb.write(2,undefined,new Uint8Array([2]));let constraintErrors=0;
    545       const injectAsyncError=(namespace,key,redirect)=>{
    546         IDBObjectStore.prototype.put=function(bytes,at){if(this.transaction.db.name===namespace&&JSON.stringify(keyBytes(at))===JSON.stringify(keyBytes(key))){const request=originalAdd.call(this,bytes,redirect??at);request.addEventListener('error',event=>{constraintErrors++;event.preventDefault();});return request;}return actualPlanPut.call(this,bytes,at);};
    547         IDBTransaction.prototype.abort=function(){if(this.db.name===namespace)return;return actualAbort.call(this);};
    548       };
    549       try{injectAsyncError(name(31),opaqueKey(1));await rejects(()=>requestErrorDb.atomic_pair(2),'commit_unknown');}
    550       finally{IDBObjectStore.prototype.put=actualPlanPut;IDBTransaction.prototype.abort=actualAbort;}
    551       same(constraintErrors,1);same(await value(requestErrorDb,1),[1]);same(await value(requestErrorDb,2),[4]);await requestErrorDb.close();
    552       passed('real asynchronous ConstraintError with prevented abort cannot acknowledge a partial completed batch');
    553       const {owner:unknownClaimOwner,receipt:unknownClaimReceipt}=await setupIssuance(193),unknownClaimComparison=await operationKey(193,1);let unknownClaim;
    554       try{unknownClaim=Array.from(await unknownClaimOwner.claim_unknown(193,0,()=>injectAsyncError(unknownClaimReceipt.namespace,unknownClaimComparison)));}
    555       finally{IDBObjectStore.prototype.put=actualPlanPut;IDBTransaction.prototype.abort=actualAbort;}
    556       same(unknownClaim.length,96);same(unknownClaim.slice(0,32),new Array(32).fill(193));await unknownClaimOwner.close();
    557       const retainedUnknownClaim=await openPlanReceipt(unknownClaimReceipt),actualUnknownClaim=Array.from(await retainedUnknownClaim.attempt(193,0));same(actualUnknownClaim.slice(32,64),unknownClaim.slice(64));same(Array.from(await retainedUnknownClaim.claim(193,0)),[0,...actualUnknownClaim]);await rejects(()=>retainedUnknownClaim.obtain(193,0,false),'retained_no_dispatch');await retainedUnknownClaim.close();
    558       passed('uncertain claim completion keeps the actual original transaction and prevents redispatch after reopen');
    559       const {owner:unknownSealOwner,receipt:unknownSealReceipt}=await setupIssuance(194),unknownSeal=await unknownSealOwner.obtain(194,0,false);let unknownSealAnchor;
    560       try{injectAsyncError(unknownSealReceipt.namespace,await recordKey(194,4,0,1),await operationKey(194,1));unknownSealAnchor=Array.from(await unknownSealOwner.capture_unknown(unknownSeal));}
    561       finally{IDBObjectStore.prototype.put=actualPlanPut;IDBTransaction.prototype.abort=actualAbort;}
    562       same(unknownSealAnchor.length,96);same(unknownSealAnchor.slice(0,32),new Array(32).fill(194));await unknownSealOwner.close();
    563       const partialSealRows=await workspaceBytes(unknownSealReceipt);let partialSealOwner=await openPlanReceipt(unknownSealReceipt);await rejects(()=>partialSealOwner.captured_original(unknownSeal),'recovery_required');await partialSealOwner.close();partialSealOwner=await openPlanReceipt(unknownSealReceipt);await rejects(()=>partialSealOwner.capture(unknownSeal),'recovery_required');await partialSealOwner.close();sameRows(await workspaceBytes(unknownSealReceipt),partialSealRows);
    564       passed('uncertain multipart capture retains its original attempt and preserves damaged output without replacement');
    565       const legacy=await import('./v1/fixture.js');await legacy.default();
    566       const legacyOwner=await legacy.WorkspaceFixture.create(195),legacyReceipt=receiptOf(legacyOwner,195);await legacyOwner.admit(195,false);await legacyOwner.close();
    567       const legacyRows=await workspaceBytes(legacyReceipt);await rejects(()=>openPlanReceipt(legacyReceipt),'namespace_unavailable');sameRows(await workspaceBytes(legacyReceipt),legacyRows);
    568       const modernOwner=await WorkspaceFixture.create(196),modernReceipt=receiptOf(modernOwner,196);await modernOwner.close();
    569       await rejects(()=>legacy.WorkspaceFixture.open(196,new Uint8Array(modernReceipt.fingerprint),new Uint8Array(modernReceipt.selection),new Uint8Array(modernReceipt.proof)),'namespace_unavailable');
    570       const oldSelection=JSON.parse(new TextDecoder().decode(new Uint8Array(legacyReceipt.selection))),workspaceHex=oldSelection.workspace_id;
    571       if(typeof workspaceHex!=='string'||!/^[0-9a-f]{64}$/.test(workspaceHex))throw Error('unexpected exact workspace identifier encoding');
    572       const id=Uint8Array.from(workspaceHex.match(/../g),h=>parseInt(h,16));const hash=new Uint8Array(await crypto.subtle.digest('SHA-256',new Uint8Array([...new TextEncoder().encode('radroots.browser.local_outbox.namespace.v2\0'),...id])));
    573       const copiedNamespace='radroots.indexeddb.v1.'+Array.from(hash,b=>b.toString(16).padStart(2,'0')).join('');
    574       const copiedV1=await new Promise((resolve,reject)=>{const r=indexedDB.open(copiedNamespace,1);r.onupgradeneeded=()=>r.result.createObjectStore('records');r.onsuccess=()=>resolve(r.result);r.onerror=reject;});copiedV1.close();
    575       await changeWorkspace({namespace:copiedNamespace},store=>legacyRows.keys.forEach((key,i)=>store.put(legacyRows.values[i],key)));
    576       const copiedV1Rows=await workspaceBytes({namespace:copiedNamespace});await rejects(()=>openPlanReceipt(legacyReceipt),'recovery_required');sameRows(await workspaceBytes({namespace:copiedNamespace}),copiedV1Rows);sameRows(await workspaceBytes(legacyReceipt),legacyRows);
    577       passed('actual immutable v1 runtime and v2 refuse cross-version opening and copied-grant reinterpretation while preserving prior bytes');
    578       const hex=bytes=>Array.from(bytes,b=>b.toString(16).padStart(2,'0')).join('');
    579       const snapshotOf=async(owner,n)=>JSON.parse(await owner.snapshot(n));
    580       const {owner:installOwner,receipt:installReceipt}=await setupIssuance(200);
    581       const beforeInstallation=await workspaceBytes(installReceipt),plannedState=await snapshotOf(installOwner,200);
    582       same(plannedState.installation,null);same(plannedState.publications,[]);same(plannedState.message,null);
    583       await rejects(()=>installOwner.install(200),'invalid_evidence');sameRows(await workspaceBytes(installReceipt),beforeInstallation);
    584       const peerInstallSeal=await installOwner.obtain(200,1,true),peerInstallCapture=Array.from(await installOwner.capture(peerInstallSeal));
    585       const originalInstallation=JSON.parse(await installOwner.install(200)),partialInstallation=await snapshotOf(installOwner,200);
    586       same(originalInstallation.basis_capture,hex(peerInstallCapture.slice(0,32)));same(partialInstallation.installation,originalInstallation);same(partialInstallation.publications.length,1);
    587       same(partialInstallation.claims[0].claim,null);same(partialInstallation.message.id,originalInstallation.message);same(partialInstallation.message.text,'\u0001'.repeat(3000));same(partialInstallation.message.created_at,1000);same(partialInstallation.deliveries,0);same(partialInstallation.observations,0);
    588       if(partialInstallation.checkpoint===plannedState.checkpoint)throw Error('T2 did not advance the actual original progress digest');
    589       passed('actual T2 requires obtained output and installs one original message plus independent peer publication work');
    590       installOwner.set_time(1100);const selfInstallSeal=await installOwner.obtain(200,0,false),selfInstallCapture=Array.from(await installOwner.capture(selfInstallSeal));
    591       const obtainedBeforeAppend=await snapshotOf(installOwner,200);same(obtainedBeforeAppend.publications.length,1);same(obtainedBeforeAppend.installation,originalInstallation);
    592       installOwner.set_time(1600);same(JSON.parse(await installOwner.install(200)),originalInstallation);
    593       const installedState=await snapshotOf(installOwner,200);same(installedState.publications.length,2);same(installedState.message,partialInstallation.message);same(installedState.installation,originalInstallation);
    594       const oldPeerWork=installedState.publications.find(work=>work.capture===hex(peerInstallCapture.slice(0,32))),newSelfWork=installedState.publications.find(work=>work.capture===hex(selfInstallCapture.slice(0,32)));
    595       same(oldPeerWork.transaction,originalInstallation.transaction);same(newSelfWork.installation,originalInstallation.transaction);same(newSelfWork.at,1600);if(newSelfWork.transaction===originalInstallation.transaction)throw Error('later recipient append invented the original installation transaction');
    596       try{Crypto.prototype.getRandomValues=()=>{throw Error('exact T2 replay acquired new entropy');};same(JSON.parse(await installOwner.install(200)),originalInstallation);same(await snapshotOf(installOwner,200),installedState);}
    597       finally{Crypto.prototype.getRandomValues=originalRandom;}
    598       await installOwner.close();
    599       passed('first self claim remains legal after peer installation and late recipient append preserves original message, basis and transaction');
    600       const {owner:lateInstallOwner,receipt:lateInstallReceipt}=await setupIssuance(201),lateInstallSeal=await lateInstallOwner.obtain(201,0,false);await lateInstallOwner.capture(lateInstallSeal);lateInstallOwner.set_time(1600);
    601       const lateInstallation=JSON.parse(await lateInstallOwner.install(201));same(lateInstallation.at,1600);same((await snapshotOf(lateInstallOwner,201)).message.created_at,1000);await lateInstallOwner.close();
    602       const lateInstallReopen=await openPlanReceipt(lateInstallReceipt);same((await snapshotOf(lateInstallReopen,201)).installation,lateInstallation);await lateInstallReopen.close();
    603       passed('first installation of retained obtained evidence succeeds after original issuance expiry and reopens unchanged');
    604       const {owner:cancelInstallOwner,receipt:cancelInstallReceipt}=await setupIssuance(202),cancelInstallSeal=await cancelInstallOwner.obtain(202,0,true);await cancelInstallOwner.capture(cancelInstallSeal);
    605       const message202=await recordKey(202,5),beforeInstallAbort=await workspaceBytes(cancelInstallReceipt);let actualMessageWrite=false;
    606       try{IDBObjectStore.prototype.put=function(...args){const r=actualPlanPut.apply(this,args);if(this.transaction.db.name===cancelInstallReceipt.namespace&&JSON.stringify(keyBytes(args[1]))===JSON.stringify(keyBytes(message202)))r.addEventListener('success',()=>{actualMessageWrite=true;this.transaction.abort();},{once:true});return r;};await rejects(()=>cancelInstallOwner.install(202),'storage_failure');}
    607       finally{IDBObjectStore.prototype.put=actualPlanPut;}
    608       same(actualMessageWrite,true);sameRows(await workspaceBytes(cancelInstallReceipt),beforeInstallAbort);same((await snapshotOf(cancelInstallOwner,202)).installation,null);
    609       await cancelInstallOwner.abandon_install(202);same(cancelInstallOwner.abandon_auths(1),0);cancelInstallOwner.abandon_close();await cancelInstallOwner.close();
    610       const installAfterCancel=await openPlanReceipt(cancelInstallReceipt);same((await snapshotOf(installAfterCancel,202)).publications.length,1);await installAfterCancel.close();
    611       passed('actual message-write abort acknowledges no installation; an unobserved retry remains owned through cancelled close');
    612       for(const mode of ['bad_clock','expired_grant']){
    613         const n=mode==='bad_clock'?205:206,{owner,receipt}=await setupIssuance(n),seal=await owner.obtain(n,0,false);await owner.capture(seal);const before=await workspaceBytes(receipt);
    614         await rejects(()=>mode==='bad_clock'?owner.install_bad_clock(n):owner.install_expired_grant(n),mode==='bad_clock'?'workspace_unavailable':'grant_expired');await owner.close();sameRows(await workspaceBytes(receipt),before);
    615         const current=await openPlanReceipt(receipt);same((await snapshotOf(current,n)).installation,null);await current.close();
    616       }
    617       passed('T2 active callbacks refuse clock rollback and grant expiry after wrapping without changing obtained facts');
    618       const stableInstallation=await workspaceBytes(installReceipt),message200=await recordKey(200,5),work200Self=await recordKey(200,6,0),work200Peer=await recordKey(200,6,1);
    619       const installationValue=key=>stableInstallation.values[stableInstallation.keys.findIndex(k=>JSON.stringify(keyBytes(k))===JSON.stringify(keyBytes(key)))];
    620       for(const mode of ['missing_message','missing_basis_work','tampered_message','swapped_work','complete_s_loss','obtained_s_loss']){
    621         await changeWorkspace(installReceipt,store=>{
    622           if(mode==='missing_message')store.delete(message200);
    623           if(mode==='missing_basis_work')store.delete(work200Peer);
    624           if(mode==='tampered_message'){const raw=new Uint8Array(installationValue(message200));raw[raw.length-1]^=1;store.put(raw,message200);}
    625           if(mode==='swapped_work')store.put(installationValue(work200Self),work200Peer);
    626           if(mode==='complete_s_loss')stableInstallation.keys.filter(k=>[3,4].includes(keyBytes(k)[16])).forEach(key=>store.delete(key));
    627           if(mode==='obtained_s_loss')stableInstallation.keys.filter(k=>keyBytes(k)[16]===4).forEach(key=>store.delete(key));
    628         });
    629         const damaged=await workspaceBytes(installReceipt);let current=await openPlanReceipt(installReceipt);await rejects(()=>current.snapshot(200),'recovery_required');await current.close();
    630         current=await openPlanReceipt(installReceipt);await rejects(()=>current.install(200),'recovery_required');await current.close();
    631         if(mode==='complete_s_loss'){
    632           current=await openPlanReceipt(installReceipt);await rejects(()=>current.claim(200,0),'recovery_required');await current.close();
    633           current=await openPlanReceipt(installReceipt);await rejects(()=>current.attempt(200,0),'recovery_required');await current.close();
    634           current=await openPlanReceipt(installReceipt);await rejects(()=>current.captured(200,0),'recovery_required');await current.close();
    635         }
    636         if(mode==='obtained_s_loss'){
    637           current=await openPlanReceipt(installReceipt);await rejects(()=>current.captured(200,0),'recovery_required');await current.close();
    638         }
    639         sameRows(await workspaceBytes(installReceipt),damaged);await changeWorkspace(installReceipt,store=>{store.clear();stableInstallation.keys.forEach((key,i)=>store.put(stableInstallation.values[i],key));});
    640       }
    641       passed('missing, damaged, foreign-recipient and orphan T2 state refuses query, replacement and reissuance with exact bytes preserved');
    642       const {owner:unknownInstallOwner,receipt:unknownInstallReceipt}=await setupIssuance(203),unknownInstallSeal=await unknownInstallOwner.obtain(203,0,false);await unknownInstallOwner.capture(unknownInstallSeal);
    643       const unchangedT0Part=await operationKey(203,1);let unknownInstallation;
    644       try{unknownInstallation=Array.from(await unknownInstallOwner.install_unknown(203,()=>injectAsyncError(unknownInstallReceipt.namespace,unchangedT0Part)));}
    645       finally{IDBObjectStore.prototype.put=actualPlanPut;IDBTransaction.prototype.abort=actualAbort;}
    646       same(unknownInstallation.length,96);same(unknownInstallation.slice(0,32),new Array(32).fill(203));await unknownInstallOwner.close();
    647       const afterUnknownInstall=await openPlanReceipt(unknownInstallReceipt),unknownInstalledState=await snapshotOf(afterUnknownInstall,203);same(unknownInstalledState.installation.transaction,hex(unknownInstallation.slice(64)));same(unknownInstalledState.publications.length,1);await afterUnknownInstall.close();
    648       passed('actual uncertain T2 completion retains its original transaction and reconciles the installed message after reopen');
    649       const {owner:partialInstallOwner,receipt:partialInstallReceipt}=await setupIssuance(204),partialInstallSeal=await partialInstallOwner.obtain(204,0,false);await partialInstallOwner.capture(partialInstallSeal);
    650       const failedPublication=await recordKey(204,6,0),partialT0Part=await operationKey(204,1);let partialInstallAnchor;
    651       try{partialInstallAnchor=Array.from(await partialInstallOwner.install_unknown(204,()=>injectAsyncError(partialInstallReceipt.namespace,failedPublication,partialT0Part)));}
    652       finally{IDBObjectStore.prototype.put=actualPlanPut;IDBTransaction.prototype.abort=actualAbort;}
    653       same(partialInstallAnchor.length,96);await partialInstallOwner.close();const partialInstallRows=await workspaceBytes(partialInstallReceipt);let partialInstallReopen=await openPlanReceipt(partialInstallReceipt);
    654       await rejects(()=>partialInstallReopen.snapshot(204),'recovery_required');await partialInstallReopen.close();partialInstallReopen=await openPlanReceipt(partialInstallReceipt);await rejects(()=>partialInstallReopen.install(204),'recovery_required');await partialInstallReopen.close();sameRows(await workspaceBytes(partialInstallReceipt),partialInstallRows);
    655       passed('partial actual T2 completion preserves original uncertainty and refuses orphan message repair or replacement');
    656       const workCall=message=>new Promise((resolve,reject)=>{const worker=new Worker('./worker.js',{type:'module'});worker.onmessage=e=>{if(e.data.ready){worker.postMessage(message);return;}worker.terminate();resolve(e.data);};worker.onerror=e=>{worker.terminate();reject(Error(e.message));};});
    657       same(await workCall({kind:'installation_query',...installReceipt}),{state:installedState});passed('actual worker and fresh WASM reopen the original installation and both publication links');
    658       same(await workCall({kind:'issuance_query',...signingReceipt}),{claim:originalClaim,seal:originalSeal});passed('actual worker and fresh WASM reopen the original protected claim and captured signature');
    659       same(await workCall({kind:'plan_query',...planReceipt}),{plan:originalPlan});passed('actual worker reopens and confirms the original protected complete T1');
    660       same(await workCall({kind:'journal_query',...journalReceipt}),{preparation:originalPreparation});passed('actual worker reopens and queries the original protected preparation');
    661       same(await workCall({kind:'workspace_open',...workspaceReceipt}),{error:'writer_active'});
    662       same(outbox.abandon_auths(2),1);for(let n=0;n<64;n++)outbox.abandon_close();await outbox.close();
    663       await rejects(()=>outbox.authenticate(),'closed');
    664       same(await workCall({kind:'workspace_open',...workspaceReceipt}),{revision:1});
    665       passed('bounded owned authentication and cancelled close drain before actual cross-worker writer acquisition');
    666       let heldWorker;
    667       const held=await new Promise((resolve,reject)=>{heldWorker=new Worker('./worker.js',{type:'module'});heldWorker.onmessage=e=>{if(e.data.ready){heldWorker.postMessage({kind:'workspace_hold',...workspaceReceipt});return;}resolve(e.data);};heldWorker.onerror=e=>reject(Error(e.message));});
    668       same(held,{revision:1});
    669       const openReceipt=r=>WorkspaceFixture.open(r.n,new Uint8Array(r.fingerprint),new Uint8Array(r.selection),new Uint8Array(r.proof));
    670       await rejects(()=>openReceipt(workspaceReceipt),'writer_active');heldWorker.terminate();
    671       await navigator.locks.request(workspaceReceipt.namespace,()=>{});
    672       const recoveredWorkspace=await openReceipt(workspaceReceipt);same(await recoveredWorkspace.authenticate(),1);await recoveredWorkspace.close();
    673       passed('actual worker termination releases writer ownership and the same protected outbox reopens');
    674       const scopeOwner=await WorkspaceFixture.create_seller(247);
    675       const scopeReceipt={n:247,fingerprint:Array.from(scopeOwner.fingerprint()),selection:Array.from(scopeOwner.selection()),proof:Array.from(scopeOwner.proof()),namespace:scopeOwner.data_namespace()};
    676       const scopeRows=await workspaceBytes(scopeReceipt);same(scopeRows.keys.length,1);
    677       const stockClaim=await scopeOwner.stock_scope_bytes(crypto.getRandomValues(new Uint8Array(56)));
    678       await changeWorkspace(scopeReceipt,store=>store.put(stockClaim,scopeRows.keys[0]));
    679       const retainedStockClaim=await workspaceBytes(scopeReceipt);
    680       await rejects(()=>scopeOwner.authenticate(),'recovery_required');await scopeOwner.close();
    681       await rejects(()=>openReceipt(scopeReceipt),'recovery_required');
    682       sameRows(await workspaceBytes(scopeReceipt),retainedStockClaim);
    683       passed('ordinary browser outbox refuses a valid protected stock-owner claim without repair');
    684       const source=await WorkspaceFixture.create(164);const target=await source.sibling();
    685       const sourceReceipt={namespace:source.data_namespace()},targetReceipt={namespace:target.data_namespace()};
    686       const sourceBytes=await workspaceBytes(sourceReceipt),targetBytes=await workspaceBytes(targetReceipt);
    687       await changeWorkspace(targetReceipt,store=>store.put(sourceBytes.values[0],targetBytes.keys[0]));
    688       await rejects(()=>target.authenticate(),'recovery_required');await target.close();await source.close();
    689       passed('copied protected grants under the same provider cannot cross workspace context');
    690       const revocable=await WorkspaceFixture.create(166);const revokedReceipt={n:166,fingerprint:Array.from(revocable.fingerprint()),selection:Array.from(revocable.selection()),proof:Array.from(revocable.proof()),namespace:revocable.data_namespace()};
    691       await revocable.revoke();await rejects(()=>revocable.authenticate(),'grant_revoked');await revocable.close();await rejects(()=>openReceipt(revokedReceipt),'grant_revoked');
    692       const removed=await WorkspaceFixture.create(167);const removedReceipt={n:167,fingerprint:Array.from(removed.fingerprint()),selection:Array.from(removed.selection()),proof:Array.from(removed.proof()),namespace:removed.data_namespace()};await removed.close();
    693       await changeWorkspace(removedReceipt,store=>store.clear());await rejects(()=>openReceipt(removedReceipt),'recovery_required');
    694       await new Promise((resolve,reject)=>{const r=indexedDB.deleteDatabase(removedReceipt.namespace);r.onsuccess=resolve;r.onerror=reject;});await rejects(()=>openReceipt(removedReceipt),'namespace_unavailable');
    695       passed('revoked, empty and evicted browser workspaces refuse exact reopen without fresh enrollment');
    696       const displaced=await WorkspaceFixture.create(169);const displacedReceipt={n:169,fingerprint:Array.from(displaced.fingerprint()),selection:Array.from(displaced.selection()),proof:Array.from(displaced.proof()),namespace:displaced.data_namespace()};
    697       let releaseForeign,foreignAcquired;const foreignHold=new Promise(resolve=>releaseForeign=resolve);const acquiredForeign=new Promise(resolve=>foreignAcquired=resolve);
    698       const foreignLock=navigator.locks.request(displacedReceipt.namespace,{steal:true},()=>{foreignAcquired();return foreignHold;});
    699       try{await acquiredForeign;await rejects(()=>displaced.authenticate(),'closed');await rejects(()=>displaced.close(),'workspace_unavailable');}
    700       finally{releaseForeign();await foreignLock;}
    701       const afterDisplacement=await openReceipt(displacedReceipt);same(await afterDisplacement.authenticate(),1);await afterDisplacement.close();
    702       passed('actual unexpected Web Lock loss stops admission and remains visible through owned close');
    703       await rejects(()=>WorkspaceFixture.create_expiring(168),'grant_expired');
    704       passed('expired creation exposes no workspace or protected proof');
    705       const workerCall=message=>new Promise((resolve,reject)=>{const worker=new Worker('./worker.js',{type:'module'});worker.onmessage=e=>{if(e.data.ready){worker.postMessage(message);return;}worker.terminate();if(e.data.error)reject(Error(e.data.error));else resolve(e.data);};worker.onerror=e=>{worker.terminate();reject(Error(e.message));};});
    706       const workerCreated=await workerCall({kind:'persistent_create'});
    707       same(await workerCall({kind:'persistent_open',...workerCreated}),{plain:[90,91,92]});
    708       passed('persistent provider survives actual worker termination and new worker instance');
    709       return {tests,events:events.reduce((all,event)=>(all[event]=(all[event]??0)+1,all),{}),persistent:{fingerprint,encoded},workspace:workspaceReceipt,journal:{...journalReceipt,preparation:originalPreparation},plan:{...planReceipt,originalPlan},issuance:{...signingReceipt,originalClaim,originalSeal},installation:{...installReceipt,installedState}};
    710     } finally {IDBDatabase.prototype.transaction=nativeTransaction;}
    711   });
    712   await page.reload();
    713   const restarted=await page.evaluate(async receipt=>{
    714     const {default:init,Persistent,Fixture}=await import('./fixture.js');await init();
    715     const provider=await Persistent.open(80,new Uint8Array(receipt.fingerprint));
    716     const store=await Fixture.open(80,false);const encoded=await store.read(4);
    717     const plain=await provider.reveal(encoded);await provider.close();await store.close();return Array.from(plain);
    718   },result.persistent);
    719   assert.deepEqual(restarted,[80,81,82]);
    720   result.tests.push('persistent provider and encrypted data survive actual page and WASM restart');
    721   const workspaceRestart=await page.evaluate(async receipt=>{const {default:init,WorkspaceFixture}=await import('./fixture.js');await init();const owner=await WorkspaceFixture.open(receipt.n,new Uint8Array(receipt.fingerprint),new Uint8Array(receipt.selection),new Uint8Array(receipt.proof));const revision=await owner.authenticate();await owner.close();return revision;},result.workspace);
    722   assert.equal(workspaceRestart,1);result.tests.push('authenticated browser workspace survives actual page and WASM restart');delete result.workspace;
    723   const preparationRestart=await page.evaluate(async receipt=>{const {default:init,WorkspaceFixture}=await import('./fixture.js');await init();const owner=await WorkspaceFixture.open(receipt.n,new Uint8Array(receipt.fingerprint),new Uint8Array(receipt.selection),new Uint8Array(receipt.proof));const prepared=Array.from(await owner.query(65));await owner.close();return prepared;},result.journal);
    724   assert.deepEqual(preparationRestart,result.journal.preparation);result.tests.push('original protected operation survives actual page and WASM restart');delete result.journal;
    725   const planRestart=await page.evaluate(async r=>{const {default:init,WorkspaceFixture}=await import('./fixture.js');await init();const owner=await WorkspaceFixture.open(r.n,new Uint8Array(r.fingerprint),new Uint8Array(r.selection),new Uint8Array(r.proof));const plan=Array.from(await owner.plan_query(180));await owner.close();return plan;},result.plan);assert.deepEqual(planRestart,result.plan.originalPlan);result.tests.push('complete original protected T1 survives actual page and WASM restart');delete result.plan;
    726   delete result.persistent;
    727   const installationRestart=await page.evaluate(async r=>{const {default:init,WorkspaceFixture}=await import('./fixture.js');await init();const owner=await WorkspaceFixture.open(r.n,new Uint8Array(r.fingerprint),new Uint8Array(r.selection),new Uint8Array(r.proof));const state=JSON.parse(await owner.snapshot(200));await owner.close();return state;},result.installation);assert.deepEqual(installationRestart,result.installation.installedState);result.tests.push('original installation and per-recipient work survive actual page and WASM restart');delete result.installation;
    728   const issuanceRestart=await page.evaluate(async r=>{const {default:init,WorkspaceFixture}=await import('./fixture.js');await init();const owner=await WorkspaceFixture.open(r.n,new Uint8Array(r.fingerprint),new Uint8Array(r.selection),new Uint8Array(r.proof));const claim=Array.from(await owner.attempt(190,0)),seal=Array.from(await owner.captured(190,0));await owner.close();return {claim,seal};},result.issuance);assert.deepEqual(issuanceRestart,{claim:result.issuance.originalClaim,seal:result.issuance.originalSeal});result.tests.push('original claim and captured signature survive actual page and WASM restart');delete result.issuance;
    729   console.log(JSON.stringify({engine,version:browser.version(),...result}));
    730   } else {
    731     const result=await(profile.startsWith('journal')?runJournal(page,profile):profile.startsWith('observation')?runObservations(page,profile):runDelivery(page,profile));
    732     console.log(JSON.stringify({engine,version:browser.version(),profile,...result}));
    733   }
    734 } finally {
    735   clearTimeout(deadline);
    736   await browser?.close();await new Promise(resolve=>server.close(resolve));
    737 }