paired-delivery.spec.ts (18117B)
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 Pair from './harness/paired-delivery.ts'; 7 declare global { 8 interface Window { 9 hcp082: typeof Pair; 10 hcp082Fixture: Awaited<ReturnType<typeof Pair.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/paired-delivery.ts', import.meta.url) 25 ), 26 name: 'hcp082', 27 formats: ['iife'] 28 } 29 } 30 }); 31 const output = Array.isArray(built) ? built[0] : built; 32 if (!('output' in output)) throw Error('missing pair 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: 'HCP082_REAL_PAIRED_IDB_PLAN', 39 bundleSha256: createHash('sha256').update(bundle).digest('hex'), 40 moduleIds: Object.keys(chunks[0].modules), 41 qualification: 42 'Source-only actual SDK/IDB/WebLocks; controlled public preference observations, no 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.hcp082Fixture = await window.hcp082.makeFixture(); 52 }); 53 } 54 55 test('no paired permission before self acknowledgement; complete artifacts and frozen routes commit before local readiness', async ({ 56 page 57 }) => { 58 await load(page); 59 const result = await page.evaluate(async () => { 60 const f = window.hcp082Fixture, 61 s = window.hcp082; 62 try { 63 const before = f.counts(), 64 refused = await s.preparePairedDelivery( 65 f.preparation, 66 f.context, 67 'reviewed_pair_preparation' 68 ), 69 inert = JSON.stringify(before) === JSON.stringify(f.counts()); 70 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 71 const self = await f.stored(), 72 prepared = await s.preparePairedDelivery( 73 f.preparation, 74 f.context, 75 'reviewed_pair_preparation' 76 ), 77 token = s.preparedPairedDelivery(f.preparation), 78 row = token && s.pairedDeliveryAcknowledgementSnapshot(token), 79 raw = await f.stored(); 80 return { 81 refused: refused.status, 82 inert, 83 prepared: prepared.status, 84 ack: !!row, 85 state: row?.deliveryPlan.state, 86 roles: row && [ 87 row.deliveryPlan.routes.peer.role, 88 row.deliveryPlan.routes.archive.role 89 ], 90 sameRumor: 91 row?.rumorHash === 92 s.selfRecoveryAcknowledgementSnapshot( 93 s.preparedSelfRecovery(f.preparation)! 94 )?.rumorHash, 95 twoArtifacts: !!row?.self.wire && !!row.peerArtifact.wire, 96 changed: raw !== self, 97 plaintext: 98 raw.includes(f.marker) || 99 (await f.publicDraftRows()).includes(f.marker) 100 }; 101 } finally { 102 f.close(); 103 } 104 }); 105 expect(result).toEqual({ 106 refused: 'self_required', 107 inert: true, 108 prepared: 'prepared', 109 ack: true, 110 state: 'prepared', 111 roles: ['peer', 'self_archive'], 112 sameRumor: true, 113 twoArtifacts: true, 114 changed: true, 115 plaintext: false 116 }); 117 }); 118 test('same paired command retry keeps both exact wires and routes without more SDK work', async ({ 119 page 120 }) => { 121 await load(page); 122 const result = await page.evaluate(async () => { 123 const f = window.hcp082Fixture, 124 s = window.hcp082; 125 try { 126 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 127 await s.preparePairedDelivery( 128 f.preparation, 129 f.context, 130 'reviewed_pair_preparation' 131 ); 132 const token = s.preparedPairedDelivery(f.preparation), 133 before = f.counts(), 134 bytes = await f.stored(), 135 again = await s.preparePairedDelivery( 136 f.preparation, 137 f.context, 138 'reviewed_pair_preparation' 139 ); 140 return { 141 status: again.status, 142 same: token === s.preparedPairedDelivery(f.preparation), 143 bytes: bytes === (await f.stored()), 144 counts: JSON.stringify(before) === JSON.stringify(f.counts()) 145 }; 146 } finally { 147 f.close(); 148 } 149 }); 150 expect(result).toEqual({ 151 status: 'prepared', 152 same: true, 153 bytes: true, 154 counts: true 155 }); 156 }); 157 test('genuine paired acknowledgement cannot reconcile arbitrary structurally valid stored advancement', async ({ 158 page 159 }) => { 160 await load(page); 161 const result = await page.evaluate(async () => { 162 const f = window.hcp082Fixture, 163 s = window.hcp082; 164 try { 165 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 166 await s.preparePairedDelivery( 167 f.preparation, 168 f.context, 169 'reviewed_pair_preparation' 170 ); 171 await f.changePairRevision(); 172 const changed = await f.stored(), 173 before = f.counts(), 174 self = await s.prepareSelfRecovery( 175 f.preparation, 176 'reviewed_self_recovery' 177 ), 178 pair = await s.preparePairedDelivery( 179 f.preparation, 180 f.context, 181 'reviewed_pair_preparation' 182 ); 183 return { 184 self: self.status, 185 pair: pair.status, 186 selfAck: !!s.preparedSelfRecovery(f.preparation), 187 pairAck: !!s.preparedPairedDelivery(f.preparation), 188 preserved: changed === (await f.stored()), 189 counts: JSON.stringify(before) === JSON.stringify(f.counts()) 190 }; 191 } finally { 192 f.close(); 193 } 194 }); 195 expect(result).toEqual({ 196 self: 'conflict', 197 pair: 'self_required', 198 selfAck: false, 199 pairAck: false, 200 preserved: true, 201 counts: true 202 }); 203 }); 204 for (const fault of ['abort', 'unknown'] as const) 205 test( 206 'actual ' + fault + ' pair write preserves truthful atomic acknowledgement', 207 async ({ page }) => { 208 await load(page); 209 const result = await page.evaluate(async (mode) => { 210 const f = window.hcp082Fixture, 211 s = window.hcp082; 212 try { 213 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 214 const old = await f.stored(), 215 hits = f.fault(mode), 216 result = await s.preparePairedDelivery( 217 f.preparation, 218 f.context, 219 'reviewed_pair_preparation' 220 ), 221 receipt = s.preparedPairedDelivery(f.preparation), 222 stored = await f.stored(); 223 return { 224 status: result.status, 225 hits: hits(), 226 ack: !!receipt, 227 unchanged: old === stored, 228 plaintext: stored.includes(f.marker) 229 }; 230 } finally { 231 f.close(); 232 } 233 }, fault); 234 expect(result).toEqual( 235 fault === 'abort' 236 ? { 237 status: 'aborted', 238 hits: 1, 239 ack: false, 240 unchanged: true, 241 plaintext: false 242 } 243 : { 244 status: 'reconciled', 245 hits: 1, 246 ack: true, 247 unchanged: false, 248 plaintext: false 249 } 250 ); 251 } 252 ); 253 test('peer interruption after actual encryption entry leaves only acknowledged self recovery ciphertext', async ({ 254 page 255 }) => { 256 await load(page); 257 const result = await page.evaluate(async () => { 258 const f = window.hcp082Fixture, 259 s = window.hcp082; 260 try { 261 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 262 const bytes = await f.stored(); 263 f.mode('hold_encrypt'); 264 const pending = s.preparePairedDelivery( 265 f.preparation, 266 f.context, 267 'reviewed_pair_preparation' 268 ); 269 let entered = false; 270 for (let i = 0; i < 1800; i++) { 271 if (f.pendingEncryption()) { 272 entered = true; 273 break; 274 } 275 await new Promise((resolve) => setTimeout(resolve, 50)); 276 } 277 if (!entered) throw Error('peer encryption did not enter'); 278 f.disconnect(); 279 f.settle(); 280 const result = await pending; 281 return { 282 status: result.status, 283 ack: !!s.preparedPairedDelivery(f.preparation), 284 unchanged: bytes === (await f.stored()) 285 }; 286 } finally { 287 f.close(); 288 } 289 }); 290 expect(result).toEqual({ status: 'stopped', ack: false, unchanged: true }); 291 }); 292 test('changed route ownership after actual peer crypto blocks pair commit and preserves self', async ({ 293 page 294 }) => { 295 await load(page); 296 const result = await page.evaluate(async () => { 297 const f = window.hcp082Fixture, 298 s = window.hcp082; 299 try { 300 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 301 const bytes = await f.stored(); 302 f.mode('hold_encrypt'); 303 const pending = s.preparePairedDelivery( 304 f.preparation, 305 f.context, 306 'reviewed_pair_preparation' 307 ); 308 let entered = false; 309 for (let i = 0; i < 1800; i++) { 310 if (f.pendingEncryption()) { 311 entered = true; 312 break; 313 } 314 await new Promise((resolve) => setTimeout(resolve, 50)); 315 } 316 if (!entered) throw Error('peer encryption did not enter'); 317 f.staleRoutes(); 318 f.settle(); 319 const result = await pending; 320 return { 321 status: result.status, 322 ack: !!s.preparedPairedDelivery(f.preparation), 323 unchanged: bytes === (await f.stored()) 324 }; 325 } finally { 326 f.close(); 327 } 328 }); 329 expect(result).toEqual({ 330 status: 'review_required', 331 ack: false, 332 unchanged: true 333 }); 334 }); 335 test('different genuine peer ciphertext for the same committed command conflicts without overwriting either artifact', async ({ 336 page 337 }) => { 338 await load(page); 339 const result = await page.evaluate(async () => { 340 const f = window.hcp082Fixture, 341 s = window.hcp082; 342 try { 343 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 344 const self = s.preparedSelfRecovery(f.preparation)!; 345 await s.preparePairedDelivery( 346 f.preparation, 347 f.context, 348 'reviewed_pair_preparation' 349 ); 350 const old = await f.stored(), 351 peer = await f.peerProof(); 352 if (!peer) throw Error('missing competing genuine peer proof'); 353 const changed = await s.commitPairedDelivery( 354 f.repository, 355 f.identity, 356 f.reserved, 357 self, 358 peer, 359 f.context.plan, 360 'reviewed_pair_commit' 361 ); 362 return { status: changed.status, unchanged: old === (await f.stored()) }; 363 } finally { 364 f.close(); 365 } 366 }); 367 expect(result).toEqual({ status: 'conflict', unchanged: true }); 368 }); 369 test('stored route metadata rejects unknown plaintext and missing paired artifacts instead of fabricating readiness', async ({ 370 page 371 }) => { 372 await load(page); 373 const result = await page.evaluate(async () => { 374 const f = window.hcp082Fixture, 375 s = window.hcp082; 376 try { 377 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 378 await s.preparePairedDelivery( 379 f.preparation, 380 f.context, 381 'reviewed_pair_preparation' 382 ); 383 const token = s.preparedPairedDelivery(f.preparation)!, 384 row = s.pairedDeliveryAcknowledgementSnapshot(token)!; 385 const raw = { 386 schema: 1, 387 family: 'private_send_operation', 388 owner: row.owner, 389 id: row.id, 390 revision: row.revision, 391 peer: row.peer, 392 rumorHash: row.rumorHash, 393 createdAt: row.createdAt, 394 self: row.self, 395 peerArtifact: row.peerArtifact, 396 deliveryPlan: row.deliveryPlan 397 }; 398 return { 399 valid: s.decodePrivateRecord(JSON.stringify(raw), row.owner, row.id).ok, 400 unknown: s.decodePrivateRecord( 401 JSON.stringify({ 402 ...raw, 403 deliveryPlan: { ...raw.deliveryPlan, body: f.marker } 404 }), 405 row.owner, 406 row.id 407 ).ok, 408 missing: s.decodePrivateRecord( 409 JSON.stringify({ ...raw, peerArtifact: null }), 410 row.owner, 411 row.id 412 ).ok 413 }; 414 } finally { 415 f.close(); 416 } 417 }); 418 expect(result).toEqual({ valid: true, unknown: false, missing: false }); 419 }); 420 test('distinct intentional identical text is not collapsed into the prior paired command', async ({ 421 page 422 }) => { 423 await load(page); 424 const result = await page.evaluate(async () => { 425 const f = window.hcp082Fixture, 426 s = window.hcp082; 427 try { 428 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 429 const self = s.preparedSelfRecovery(f.preparation)!; 430 await s.preparePairedDelivery( 431 f.preparation, 432 f.context, 433 'reviewed_pair_preparation' 434 ); 435 const peer = await f.peerProof(), 436 intent = await f.distinctIntent(); 437 if (!peer) throw Error('missing genuine prior peer'); 438 const before = await f.stored(); 439 const refused = intent.identity 440 ? await s.commitPairedDelivery( 441 f.repository, 442 f.identity, 443 intent.identity, 444 self, 445 peer, 446 f.context.plan, 447 'reviewed_pair_commit' 448 ) 449 : undefined; 450 return { 451 safe: 452 intent.status === 'clock_conflict' || 453 (intent.status === 'reserved' && 454 intent.id !== s.selfRecoveryAcknowledgementSnapshot(self)?.id), 455 refused: !intent.identity || refused?.status === 'invalid', 456 unchanged: before === (await f.stored()) 457 }; 458 } finally { 459 f.close(); 460 } 461 }); 462 expect(result).toEqual({ safe: true, refused: true, unchanged: true }); 463 }); 464 test('concurrent genuine paired commits from the same self-only base produce one exact durable winner and one conflict', async ({ 465 page 466 }) => { 467 await load(page); 468 const result = await page.evaluate(async () => { 469 const f = window.hcp082Fixture, 470 s = window.hcp082; 471 try { 472 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 473 const self = s.preparedSelfRecovery(f.preparation)!, 474 left = await f.peerProof(), 475 right = await f.peerProof(); 476 if (!left || !right) throw Error('missing genuine competing peer proofs'); 477 const a = s.verifiedOutboundSnapshot(left), 478 b = s.verifiedOutboundSnapshot(right); 479 if (!a || !b || a.wire === b.wire) 480 throw Error('competing wrappers were not distinct'); 481 const outcomes = await Promise.all([ 482 s.commitPairedDelivery( 483 f.repository, 484 f.identity, 485 f.reserved, 486 self, 487 left, 488 f.context.plan, 489 'reviewed_pair_commit' 490 ), 491 s.commitPairedDelivery( 492 f.repository, 493 f.identity, 494 f.reserved, 495 self, 496 right, 497 f.context.plan, 498 'reviewed_pair_commit' 499 ) 500 ]); 501 const winner = outcomes.find((value) => 'receipt' in value); 502 if (!winner || !('receipt' in winner)) 503 throw Error('missing actual acknowledged winner'); 504 const expected = winner === outcomes[0] ? a : b, 505 ack = s.pairedDeliveryAcknowledgementSnapshot(winner.receipt), 506 stored = await f.storedPair(), 507 original = s.selfRecoveryAcknowledgementSnapshot(self), 508 wire = await f.stored(); 509 return { 510 statuses: outcomes.map((value) => value.status).sort(), 511 oneReceipt: outcomes.filter((value) => 'receipt' in value).length === 1, 512 peer: 513 stored?.peerArtifact?.wire === expected.wire && 514 ack?.peerArtifact.wire === expected.wire, 515 self: stored?.self.wire === original?.self.wire, 516 routes: 517 JSON.stringify(stored?.deliveryPlan?.routes) === 518 JSON.stringify(s.inboxRoutePlanSnapshot(f.context.plan)), 519 revision: stored?.revision === ack?.revision, 520 plaintext: wire.includes(f.marker) 521 }; 522 } finally { 523 f.close(); 524 } 525 }); 526 expect(result).toEqual({ 527 statuses: ['conflict', 'prepared'], 528 oneReceipt: true, 529 peer: true, 530 self: true, 531 routes: true, 532 revision: true, 533 plaintext: false 534 }); 535 }); 536 test('explicit self then pair retry after pair commit retains genuine successor evidence and exact ciphertext', async ({ 537 page 538 }) => { 539 await load(page); 540 const result = await page.evaluate(async () => { 541 const f = window.hcp082Fixture, 542 s = window.hcp082; 543 try { 544 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 545 const self = s.preparedSelfRecovery(f.preparation); 546 await s.preparePairedDelivery( 547 f.preparation, 548 f.context, 549 'reviewed_pair_preparation' 550 ); 551 const token = s.preparedPairedDelivery(f.preparation), 552 bytes = await f.stored(), 553 before = f.counts(), 554 selfAgain = await s.prepareSelfRecovery( 555 f.preparation, 556 'reviewed_self_recovery' 557 ), 558 pairAgain = await s.preparePairedDelivery( 559 f.preparation, 560 f.context, 561 'reviewed_pair_preparation' 562 ); 563 return { 564 self: selfAgain.status, 565 pair: pairAgain.status, 566 sameSelf: self === s.preparedSelfRecovery(f.preparation), 567 samePair: token === s.preparedPairedDelivery(f.preparation), 568 bytes: bytes === (await f.stored()), 569 counts: JSON.stringify(before) === JSON.stringify(f.counts()) 570 }; 571 } finally { 572 f.close(); 573 } 574 }); 575 expect(result).toEqual({ 576 self: 'saved', 577 pair: 'prepared', 578 sameSelf: true, 579 samePair: true, 580 bytes: true, 581 counts: true 582 }); 583 });