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 }