self-recovery.spec.ts (14037B)
1 import { expect, test, type Page } from '@playwright/test'; 2 import { build } from 'vite'; 3 import { fileURLToPath } from 'node:url'; 4 import { createHash } from 'node:crypto'; 5 import { createStaticHarness } from '../integration/harness/static.ts'; 6 import type * as Recovery from './harness/self-recovery.ts'; 7 declare global { 8 interface Window { 9 hcp081: typeof Recovery; 10 hcp081Fixture: Awaited<ReturnType<typeof Recovery.makeFixture>>; 11 } 12 } 13 let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string; 14 test.beforeAll(async () => { 15 server = await createStaticHarness(); 16 const built = await build({ 17 configFile: false, 18 logLevel: 'silent', 19 build: { 20 write: false, 21 minify: false, 22 lib: { 23 entry: fileURLToPath( 24 new URL('./harness/self-recovery.ts', import.meta.url) 25 ), 26 name: 'hcp081', 27 formats: ['iife'] 28 } 29 } 30 }); 31 const output = Array.isArray(built) ? built[0] : built; 32 if (!('output' in output)) throw Error('missing recovery bundle'); 33 const chunks = output.output.filter((entry) => entry.type === 'chunk'); 34 expect(chunks).toHaveLength(1); 35 bundle = chunks[0].code; 36 console.log( 37 JSON.stringify({ 38 fixture: 'HCP081_REAL_SELF_IDB_ACKNOWLEDGEMENT', 39 bundleSha256: createHash('sha256').update(bundle).digest('hex'), 40 moduleIds: Object.keys(chunks[0].modules), 41 qualification: 42 'Source-only genuine SDK/IDB/WebLocks; synthetic fault boundaries, no actual operator Q' 43 }) 44 ); 45 }); 46 test.afterAll(async () => server.close()); 47 async function load(page: Page) { 48 await page.goto(server.url + '/search'); 49 await page.addScriptTag({ content: bundle }); 50 await page.evaluate(async () => { 51 window.hcp081Fixture = await window.hcp081.makeFixture(); 52 }); 53 } 54 test('self ciphertext is acknowledged before workflow peer permission, with no plaintext in either store', async ({ 55 page 56 }) => { 57 await load(page); 58 const result = await page.evaluate(async () => { 59 const f = window.hcp081Fixture, 60 s = window.hcp081; 61 try { 62 const before = s.selfRecoveryPreparationSnapshot(f.preparation), 63 base = f.counts(); 64 const early = await s.selfRecoveryPeerPreparation( 65 f.preparation, 66 {} as Parameters<typeof s.selfRecoveryPeerPreparation>[1] 67 ); 68 const saved = await s.prepareSelfRecovery( 69 f.preparation, 70 'reviewed_self_recovery' 71 ); 72 const receipt = s.preparedSelfRecovery(f.preparation), 73 ack = receipt && s.selfRecoveryAcknowledgementSnapshot(receipt), 74 rows = await f.stored(), 75 publicRows = await f.publicDraftRows(); 76 const storedRows = JSON.parse(rows) as { wire: string }[]; 77 return { 78 before: before?.state, 79 early: Boolean(early), 80 status: saved.status, 81 acknowledged: Boolean(ack), 82 copy: ack?.copy, 83 peerReady: Boolean( 84 receipt && 85 (await s.selfRecoveryPeerPreparation(f.preparation, receipt)) 86 ), 87 plaintext: rows.includes(f.marker) || publicRows.includes(f.marker), 88 selfOnly: storedRows[0].wire.includes('"peerArtifact":null'), 89 encrypts: f.counts().encrypts - base.encrypts, 90 signs: f.counts().signs - base.signs 91 }; 92 } finally { 93 f.close(); 94 } 95 }); 96 expect(result).toEqual({ 97 before: 'unsaved', 98 early: false, 99 status: 'saved', 100 acknowledged: true, 101 copy: 'Saved encrypted in this browser', 102 peerReady: true, 103 plaintext: false, 104 selfOnly: true, 105 encrypts: 1, 106 signs: 1 107 }); 108 }); 109 test('same-command retry reuses the exact self ciphertext without any additional SDK work', async ({ 110 page 111 }) => { 112 await load(page); 113 const result = await page.evaluate(async () => { 114 const f = window.hcp081Fixture, 115 s = window.hcp081; 116 try { 117 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 118 const first = await f.stored(), 119 before = f.counts(), 120 receipt = s.preparedSelfRecovery(f.preparation); 121 const retry = await s.prepareSelfRecovery( 122 f.preparation, 123 'reviewed_self_recovery' 124 ); 125 return { 126 status: retry.status, 127 equal: first === (await f.stored()), 128 sameReceipt: receipt === s.preparedSelfRecovery(f.preparation), 129 counts: JSON.stringify(before) === JSON.stringify(f.counts()) 130 }; 131 } finally { 132 f.close(); 133 } 134 }); 135 expect(result).toEqual({ 136 status: 'saved', 137 equal: true, 138 sameReceipt: true, 139 counts: true 140 }); 141 }); 142 test('closed storage refuses acknowledgement and peer permission without a plaintext fallback', async ({ 143 page 144 }) => { 145 await load(page); 146 const result = await page.evaluate(async () => { 147 const f = window.hcp081Fixture, 148 s = window.hcp081; 149 try { 150 f.closeStorage(); 151 const before = f.counts(), 152 result = await s.prepareSelfRecovery( 153 f.preparation, 154 'reviewed_self_recovery' 155 ); 156 return { 157 status: result.status, 158 receipt: Boolean(s.preparedSelfRecovery(f.preparation)), 159 counts: JSON.stringify(before) === JSON.stringify(f.counts()), 160 plaintext: (await f.stored()).includes(f.marker) 161 }; 162 } finally { 163 f.close(); 164 } 165 }); 166 expect(result).toEqual({ 167 status: 'unavailable', 168 receipt: false, 169 counts: true, 170 plaintext: false 171 }); 172 }); 173 test('actual aborted self write never grants local acknowledgement or peer permission', async ({ 174 page 175 }) => { 176 await load(page); 177 const result = await page.evaluate(async () => { 178 const f = window.hcp081Fixture, 179 s = window.hcp081; 180 try { 181 const prior = await f.stored(), 182 hits = f.fault('abort'), 183 result = await s.prepareSelfRecovery( 184 f.preparation, 185 'reviewed_self_recovery' 186 ); 187 return { 188 status: result.status, 189 hits: hits(), 190 receipt: Boolean(s.preparedSelfRecovery(f.preparation)), 191 unchanged: prior === (await f.stored()) 192 }; 193 } finally { 194 f.close(); 195 } 196 }); 197 expect(result).toEqual({ 198 status: 'aborted', 199 hits: 1, 200 receipt: false, 201 unchanged: true 202 }); 203 }); 204 test('unknown write completion is reconciled by exact original ciphertext readback, never by regenerated crypto', async ({ 205 page 206 }) => { 207 await load(page); 208 const result = await page.evaluate(async () => { 209 const f = window.hcp081Fixture, 210 s = window.hcp081; 211 try { 212 const before = f.counts(), 213 hits = f.fault('unknown'), 214 result = await s.prepareSelfRecovery( 215 f.preparation, 216 'reviewed_self_recovery' 217 ); 218 const receipt = s.preparedSelfRecovery(f.preparation), 219 ack = receipt && s.selfRecoveryAcknowledgementSnapshot(receipt); 220 const rows = JSON.parse(await f.stored()) as { wire: string }[], 221 stored = JSON.parse(rows[0].wire) as { self: { wire: string } }; 222 return { 223 status: result.status, 224 hits: hits(), 225 ack: Boolean(ack), 226 exact: Boolean(ack && stored.self.wire === ack.self.wire), 227 encrypts: f.counts().encrypts - before.encrypts, 228 signs: f.counts().signs - before.signs 229 }; 230 } finally { 231 f.close(); 232 } 233 }); 234 expect(result).toEqual({ 235 status: 'reconciled', 236 hits: 1, 237 ack: true, 238 exact: true, 239 encrypts: 1, 240 signs: 1 241 }); 242 }); 243 test('late encryption after actual Disconnect grants no receipt and cannot queue peer work', async ({ 244 page 245 }) => { 246 await load(page); 247 const result = await page.evaluate(async () => { 248 const f = window.hcp081Fixture, 249 s = window.hcp081; 250 try { 251 f.mode('hold_encrypt'); 252 const pending = s.prepareSelfRecovery( 253 f.preparation, 254 'reviewed_self_recovery' 255 ); 256 for (let i = 0; i < 1800 && !f.pendingEncryption(); i++) 257 await new Promise((resolve) => setTimeout(resolve, 50)); 258 if (!f.pendingEncryption()) throw Error('encryption did not enter'); 259 const repeated = await s.prepareSelfRecovery( 260 f.preparation, 261 'reviewed_self_recovery' 262 ); 263 f.disconnect(); 264 f.settle(); 265 const late = await pending; 266 const rows = JSON.parse(await f.stored()) as { wire: string }[], 267 stored = JSON.parse(rows[0].wire) as { family: string }; 268 return { 269 repeated: repeated.status, 270 late: late.status, 271 receipt: Boolean(s.preparedSelfRecovery(f.preparation)), 272 plaintext: (await f.stored()).includes(f.marker), 273 family: stored.family 274 }; 275 } finally { 276 f.settle(); 277 f.close(); 278 } 279 }); 280 expect(result).toEqual({ 281 repeated: 'busy', 282 late: 'stopped', 283 receipt: false, 284 plaintext: false, 285 family: 'private_send_reservation' 286 }); 287 }); 288 test('a competing owner lock refuses preparation without prompts and permits only explicit later retry', async ({ 289 page 290 }) => { 291 await load(page); 292 const result = await page.evaluate(async () => { 293 const f = window.hcp081Fixture, 294 s = window.hcp081; 295 let release: (() => Promise<void>) | undefined; 296 try { 297 release = await f.holdOwner(); 298 const before = f.counts(), 299 refused = await s.prepareSelfRecovery( 300 f.preparation, 301 'reviewed_self_recovery' 302 ), 303 unchanged = JSON.stringify(before) === JSON.stringify(f.counts()); 304 await release(); 305 release = undefined; 306 const later = await s.prepareSelfRecovery( 307 f.preparation, 308 'reviewed_self_recovery' 309 ); 310 return { refused: refused.status, unchanged, later: later.status }; 311 } finally { 312 await release?.(); 313 f.close(); 314 } 315 }); 316 expect(result).toEqual({ refused: 'busy', unchanged: true, later: 'saved' }); 317 }); 318 test('a new controller with existing self evidence requires explicit recovery instead of regenerating a wrapper', async ({ 319 page 320 }) => { 321 await load(page); 322 const result = await page.evaluate(async () => { 323 const f = window.hcp081Fixture, 324 s = window.hcp081; 325 try { 326 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 327 const second = s.captureSelfRecoveryPreparation( 328 f.repository, 329 f.identity, 330 f.reserved, 331 'reviewed_self_recovery' 332 ); 333 if (!second) throw Error('missing second controller'); 334 const before = f.counts(), 335 bytes = await f.stored(), 336 result = await s.prepareSelfRecovery(second, 'reviewed_self_recovery'); 337 s.stopSelfRecoveryPreparation(second); 338 return { 339 status: result.status, 340 unchanged: JSON.stringify(before) === JSON.stringify(f.counts()), 341 bytes: bytes === (await f.stored()) 342 }; 343 } finally { 344 f.close(); 345 } 346 }); 347 expect(result).toEqual({ 348 status: 'recovery_required', 349 unchanged: true, 350 bytes: true 351 }); 352 }); 353 test('a genuine peer envelope or foreign namespace cannot acknowledge a self recovery record', async ({ 354 page 355 }) => { 356 await load(page); 357 const result = await page.evaluate(async () => { 358 const f = window.hcp081Fixture, 359 s = window.hcp081; 360 try { 361 const peer = await f.peerProof(), 362 prior = await f.stored(); 363 const denied = await s.commitSelfRecovery( 364 f.repository, 365 f.identity, 366 f.reserved, 367 peer, 368 'reviewed_self_commit' 369 ); 370 const self = await f.selfProof(); 371 const foreign = await s.commitSelfRecovery( 372 f.foreignRepository, 373 f.identity, 374 f.reserved, 375 self, 376 'reviewed_self_commit' 377 ); 378 return { 379 denied: denied.status, 380 foreignAcknowledged: 'receipt' in foreign, 381 unchanged: prior === (await f.stored()), 382 ack: Boolean(s.preparedSelfRecovery(f.preparation)) 383 }; 384 } finally { 385 f.close(); 386 } 387 }); 388 expect(result).toEqual({ 389 denied: 'invalid', 390 foreignAcknowledged: false, 391 unchanged: true, 392 ack: false 393 }); 394 }); 395 test('unrecognized stored evidence is preserved and refuses crypto, reset and local acknowledgement', async ({ 396 page 397 }) => { 398 await load(page); 399 const result = await page.evaluate(async () => { 400 const f = window.hcp081Fixture, 401 s = window.hcp081; 402 try { 403 await f.corruptReservation(); 404 const prior = await f.stored(), 405 before = f.counts(), 406 result = await s.prepareSelfRecovery( 407 f.preparation, 408 'reviewed_self_recovery' 409 ); 410 return { 411 status: result.status, 412 unchanged: prior === (await f.stored()), 413 counts: JSON.stringify(before) === JSON.stringify(f.counts()), 414 receipt: Boolean(s.preparedSelfRecovery(f.preparation)) 415 }; 416 } finally { 417 f.close(); 418 } 419 }); 420 expect(result).toEqual({ 421 status: 'corrupt_record', 422 unchanged: true, 423 counts: true, 424 receipt: false 425 }); 426 }); 427 test('ending crypto preparation preserves the acknowledged local fact and revokes workflow peer permission', async ({ 428 page 429 }) => { 430 await load(page); 431 const result = await page.evaluate(async () => { 432 const f = window.hcp081Fixture, 433 s = window.hcp081; 434 try { 435 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 436 const receipt = s.preparedSelfRecovery(f.preparation); 437 if (!receipt) throw Error('missing actual receipt'); 438 const pair = await s.selfRecoveryPeerPreparation(f.preparation, receipt); 439 if (!pair) throw Error('missing acknowledged permission'); 440 const before = await f.stored(); 441 f.closePeerPreparation(pair); 442 return { 443 savedFact: Boolean(s.selfRecoveryAcknowledgementSnapshot(receipt)), 444 workflow: Boolean(s.selfRecoveryPreparationSnapshot(f.preparation)), 445 peer: Boolean( 446 await s.selfRecoveryPeerPreparation(f.preparation, receipt) 447 ), 448 unchanged: before === (await f.stored()) 449 }; 450 } finally { 451 f.close(); 452 } 453 }); 454 expect(result).toEqual({ 455 savedFact: true, 456 workflow: false, 457 peer: false, 458 unchanged: true 459 }); 460 });