app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

commit c25fae87ba8f92b80c70e11e5244600d4eca0586
parent 4fb97073cb391ee8fa3c7061442dc6b257e48553
Author: triesap <tyson@radroots.org>
Date:   Wed,  7 Oct 2026 01:43:49 +0000

identity: coordinate same-origin writes across tabs (HCP-054)

- Acquire an origin and author Web Lock before the short durable capture claim.
- Require a genuine full-record and adapter session lease at public signing.
- Retain unknown captures and fence duplicate signatures and orphaned jobs.
- Verify real multi-tab IDB and SDK behavior with source and native guards.

Diffstat:
Mweb/src/lib/nostr/approved-signing.ts | 31+++++++++++++++++++++++++------
Mweb/src/lib/nostr/extension.ts | 143++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------------------
Mweb/src/lib/persistence/quota.ts | 78++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/src/lib/runtime/effect-ownership.ts | 257+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/e2e/approved-signing.spec.ts | 4++--
Aweb/tests/e2e/effect-ownership.spec.ts | 617+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/e2e/harness/approved-signing.ts | 77+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----
Aweb/tests/e2e/harness/effect-ownership.ts | 34++++++++++++++++++++++++++++++++++
Mweb/tests/integration/approved-signing.test.ts | 7++++++-
Aweb/tests/integration/effect-ownership.test.ts | 19+++++++++++++++++++
Aweb/tests/unit/effect-ownership.test.ts | 88+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11 files changed, 1305 insertions(+), 50 deletions(-)

diff --git a/web/src/lib/nostr/approved-signing.ts b/web/src/lib/nostr/approved-signing.ts @@ -2,6 +2,7 @@ import type { UnsignedEvent } from 'applesauce-core/helpers'; import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts'; import { publicRecordSnapshot, + publicRecordWire, type PublicRecordHandle } from '../persistence/records.ts'; import { @@ -19,6 +20,7 @@ type Capture = Readonly<{ revision: number; wire: string; hash: string; + recordWire: string; }>; const approvals = new WeakMap<ApprovedPublicSigning, Capture>(); // Internal captured-operation capability. This is neither a raw UI template @@ -33,7 +35,13 @@ export function approveCapturedPublicSigning( ): ApprovedPublicSigning | undefined { if (review !== 'reviewed_captured_operation') return undefined; const row = publicRecordSnapshot(record, owner, id); - if (!row || row.family === 'public_draft' || row.artifact !== null) + const recordWire = publicRecordWire(record, owner, id); + if ( + !row || + !recordWire || + row.family === 'public_draft' || + row.artifact !== null + ) return undefined; const template = inspectLocalTemplate( row.capture.wire, @@ -48,16 +56,27 @@ export function approveCapturedPublicSigning( id: row.id, revision: row.revision, wire: row.capture.wire, - hash: row.capture.hash + hash: row.capture.hash, + recordWire }); return token; } -export function approvedSigningIdentity( - approval: ApprovedPublicSigning -): Readonly<{ owner: string; id: string; revision: number }> | undefined { +export function approvedSigningIdentity(approval: ApprovedPublicSigning): + | Readonly<{ + owner: string; + id: string; + revision: number; + recordWire: string; + }> + | undefined { const saved = approvals.get(approval); return saved - ? { owner: saved.owner, id: saved.id, revision: saved.revision } + ? { + owner: saved.owner, + id: saved.id, + revision: saved.revision, + recordWire: saved.recordWire + } : undefined; } // Each acquisition is a disposable fresh JSON copy. No retained template or diff --git a/web/src/lib/nostr/extension.ts b/web/src/lib/nostr/extension.ts @@ -12,12 +12,22 @@ import { type ApprovedPublicSigning } from './approved-signing.ts'; import type { CapturedArtifact } from '../persistence/artifact-records.ts'; +import { + callOwnedExtension, + publicEffectLeaseCurrent, + publicEffectSnapshot, + markOwnedSignaturePending, + type PublicEffectLease, + type PublicEffectCapture +} from '../runtime/effect-ownership.ts'; export type ApprovedSignResult = | Readonly<{ status: 'signed'; artifact: CapturedArtifact }> | Readonly<{ status: | 'invalid_approval' + | 'invalid_ownership' + | 'unknown' | 'unavailable' | 'busy' | 'stale' @@ -65,7 +75,11 @@ type Controller = { connect(): Promise<ExtensionSnapshot>; recheck(): Promise<ExtensionSnapshot>; probe(review: unknown): Promise<ExtensionSnapshot>; - sign(approval: ApprovedPublicSigning): Promise<ApprovedSignResult>; + capture(): PublicEffectCapture | undefined; + sign( + approval: ApprovedPublicSigning, + lease: PublicEffectLease + ): Promise<ApprovedSignResult>; }; const adapters = new WeakMap<ExtensionAdapter, Controller>(); function present(): Readonly<{ signingCandidate: boolean }> | undefined { @@ -353,7 +367,8 @@ export function createExtensionAdapter(): ExtensionAdapter { }); } async function sign( - approval: ApprovedPublicSigning + approval: ApprovedPublicSigning, + lease: PublicEffectLease ): Promise<ApprovedSignResult> { const captured = approvedSigningIdentity(approval); if (!captured) return { status: 'invalid_approval' }; @@ -367,46 +382,84 @@ export function createExtensionAdapter(): ExtensionAdapter { return { status: 'unavailable' }; const original = generation, owner = key; + const authority = { + owner, + id: captured.id, + recordWire: captured.recordWire, + session: original + }; + if (!publicEffectLeaseCurrent(lease, authority)) + return { status: 'invalid_ownership' }; const current = () => - generation === original && !cancelled && key === owner; + generation === original && + !cancelled && + key === owner && + publicEffectLeaseCurrent(lease, authority); signing = true; try { - const scheduler = browserExtensionScheduler(); - if (!scheduler) return { status: 'unavailable' }; - const admitted = await runExtensionAction( - scheduler, - { owner, session: original, operation: Symbol() }, - current, - async (action): Promise<ApprovedSignResult> => { - const before = await freshKey(current, action); - if (!current()) return { status: 'stale' }; - if (before !== owner) { - guest(before ? 'changed_key' : 'invalid_key'); - return { status: 'stale' }; - } - const disposable = disposableApprovedTemplate(approval); - if (!disposable) return { status: 'invalid_approval' }; - const signer = new ExtensionSigner(); - const response: unknown = await invokeExtension(action, 'sign', () => - signer.signEvent(disposable) + const owned = await callOwnedExtension( + lease, + authority, + async (): Promise<ApprovedSignResult> => { + const scheduler = browserExtensionScheduler(); + if (!scheduler) return { status: 'unavailable' }; + const admitted = await runExtensionAction( + scheduler, + { owner, session: original, operation: Symbol() }, + current, + async (action): Promise<ApprovedSignResult> => { + const before = await freshKey(current, action); + if (!current()) return { status: 'stale' }; + if (before !== owner) { + guest(before ? 'changed_key' : 'invalid_key'); + return { status: 'stale' }; + } + const disposable = disposableApprovedTemplate(approval); + if (!disposable) return { status: 'invalid_approval' }; + const signer = new ExtensionSigner(); + if (!current() || !markOwnedSignaturePending(lease)) + return { status: 'stale' }; + const response: unknown = await invokeExtension( + action, + 'sign', + () => signer.signEvent(disposable) + ); + if (!current()) return { status: 'stale' }; + const artifact = bindApprovedResponse(approval, response); + if (!artifact) return { status: 'mismatch' }; + const after = await freshKey(current, action); + if (!current()) return { status: 'stale' }; + if (after !== owner) { + guest(after ? 'changed_key' : 'invalid_key'); + return { status: 'stale' }; + } + return { status: 'signed', artifact }; + } ); + if (admitted.status === 'busy') return { status: 'busy' }; if (!current()) return { status: 'stale' }; - const artifact = bindApprovedResponse(approval, response); - if (!artifact) return { status: 'mismatch' }; - const after = await freshKey(current, action); - if (!current()) return { status: 'stale' }; - if (after !== owner) { - guest(after ? 'changed_key' : 'invalid_key'); - return { status: 'stale' }; - } - return { status: 'signed', artifact }; + return 'value' in admitted && admitted.value + ? admitted.value + : { status: admitted.status === 'denied' ? 'refused' : 'stale' }; } ); - if (admitted.status === 'busy') return { status: 'busy' }; - if (!current()) return { status: 'stale' }; - return 'value' in admitted && admitted.value - ? admitted.value - : { status: admitted.status === 'denied' ? 'refused' : 'stale' }; + if (owned.status === 'settled') + return owned.current + ? owned.value + : { + status: + publicEffectSnapshot(lease)?.state === 'unknown' + ? 'unknown' + : 'stale' + }; + return { + status: + owned.status === 'invalid' + ? 'invalid_ownership' + : owned.status === 'stopped' + ? 'stale' + : owned.status + }; } catch { return { status: current() ? 'refused' : 'stale' }; } finally { @@ -420,6 +473,16 @@ export function createExtensionAdapter(): ExtensionAdapter { connect, recheck, probe, + capture() { + if (!key || cancelled) return undefined; + const owner = key, + original = generation; + return { + owner, + session: original, + current: () => generation === original && !cancelled && key === owner + }; + }, sign }); return adapter; @@ -469,10 +532,16 @@ export function probeExtensionAdapter( // adapter or an unrestricted raw-event signing/publishing function. export function signApprovedExtensionAdapter( adapter: ExtensionAdapter, - approval: ApprovedPublicSigning + approval: ApprovedPublicSigning, + lease: PublicEffectLease ): Promise<ApprovedSignResult> { return ( - adapters.get(adapter)?.sign(approval) ?? + adapters.get(adapter)?.sign(approval, lease) ?? Promise.resolve({ status: 'unavailable' }) ); } +export function extensionOwnershipCapture( + adapter: ExtensionAdapter +): PublicEffectCapture | undefined { + return adapters.get(adapter)?.capture(); +} diff --git a/web/src/lib/persistence/quota.ts b/web/src/lib/persistence/quota.ts @@ -83,6 +83,12 @@ function scopeOf(repository: PublicQuotaRepository): Scope | undefined { return undefined; } } +// Metadata only; this does not grant installed-account or effect authority. +export function publicQuotaOwner( + repository: PublicQuotaRepository +): string | undefined { + return scopeOf(repository)?.owner; +} // A namespace capability only; installed-account authorization belongs to the // account workflow. This repository never acquires any private store. export function createPublicQuotaRepository( @@ -269,6 +275,78 @@ export function admitPublicOperation( return { ok: true, value: { id, revision: 0 } }; }); } +// Claim under the caller's origin/author Web Lock. A previous capture is never +// overwritten or automatically signed again, even after a page lost its lock. +// No extension/network await occurs inside the short transaction. +export function claimPublicOperation( + repository: PublicQuotaRepository, + expectedId: unknown, + handle: PublicRecordHandle +): Promise< + PublicQuotaResult< + Readonly<{ state: 'created' | 'existing'; record: PublicRecordHandle }> + > +> { + const scope = scopeOf(repository), + id = canonicalLocalId(expectedId); + if (!scope) return Promise.resolve(failed('invalid_scope')); + if (!id) return Promise.resolve(failed('invalid_record')); + const record = publicRecordSnapshot(handle, scope.owner, id), + wire = publicRecordWire(handle, scope.owner, id); + if ( + !record || + !wire || + record.family === 'public_draft' || + record.revision !== 0 || + record.artifact !== null + ) + return Promise.resolve(failed('invalid_record')); + const store: Store = + record.family === 'public_operation' + ? 'public_operations' + : 'preference_operations'; + const bytes = new TextEncoder().encode(wire).length; + return transaction< + Readonly<{ state: 'created' | 'existing'; record: PublicRecordHandle }> + >(scope, 'readwrite', (rows, active, refuse) => { + const previous = rows.find( + (row) => row.record.family !== 'public_draft' && row.record.id === id + ); + if (previous) { + const original = previous.record; + if ( + original.family === 'public_draft' || + original.family !== record.family || + JSON.stringify(original.source) !== JSON.stringify(record.source) || + JSON.stringify(original.capture) !== JSON.stringify(record.capture) || + ('consent' in original ? original.consent : null) !== + ('consent' in record ? record.consent : null) + ) { + refuse('conflict'); + return; + } + const decoded = decodePublicRecord(previous.wire, scope.owner, id); + if (!decoded.ok) { + refuse('corrupt_record'); + return; + } + return { ok: true, value: { state: 'existing', record: decoded.value } }; + } + const operations = rows.filter( + (row) => row.record.family !== 'public_draft' + ); + if ( + operations.length >= LOCAL_PERSISTENCE_BUDGETS.publicOperations || + operations.reduce((sum, row) => sum + row.bytes, bytes) > + LOCAL_PERSISTENCE_BUDGETS.publicOperationBytes + ) { + refuse('capacity'); + return; + } + active.objectStore(store).put({ owner: scope.owner, id, wire }); + return { ok: true, value: { state: 'created', record: handle } }; + }); +} export function inspectPublicStorage( repository: PublicQuotaRepository ): Promise<PublicQuotaResult<PublicInventory>> { diff --git a/web/src/lib/runtime/effect-ownership.ts b/web/src/lib/runtime/effect-ownership.ts @@ -0,0 +1,257 @@ +import { canonicalPublicKey } from '../contracts/public-key.ts'; +import { canonicalLocalId } from '../private-handles.ts'; +import { + publicRecordSnapshot, + publicRecordWire, + type PublicRecordHandle +} from '../persistence/records.ts'; +import { + claimPublicOperation, + publicQuotaOwner, + type PublicQuotaRepository, + type PublicQuotaFailure +} from '../persistence/quota.ts'; + +declare const leaseBrand: unique symbol; +export type PublicEffectLease = Readonly<{ [leaseBrand]: true }>; +export type PublicEffectCapture = Readonly<{ + owner: string; + session: symbol; + current(): boolean; +}>; +export type PublicEffectResult<T> = + | Readonly<{ status: 'completed'; value: T }> + | Readonly<{ status: 'unknown' | 'retained'; record: PublicRecordHandle }> + | Readonly<{ + status: + 'invalid' | 'unavailable' | 'busy' | 'stopped' | PublicQuotaFailure; + }>; +type Authority = Readonly<{ + owner: string; + id: string; + recordWire: string; + session: symbol; +}>; +type State = 'active' | 'unknown' | 'stopped' | 'closed'; +type JobResult<T> = + | Readonly<{ status: 'settled'; value: T; current: boolean }> + | Readonly<{ status: 'invalid' | 'busy' | 'stopped' | 'unknown' }>; +type Controller = { + current(authority: Authority): boolean; + call<T>(authority: Authority, work: () => Promise<T>): Promise<JobResult<T>>; + mark(): boolean; + stop(): void; + snapshot(): Readonly<{ + state: State; + pending: boolean; + owner: string; + id: string; + hash: string; + revision: number; + }>; +}; +const leases = new WeakMap<PublicEffectLease, Controller>(); + +// Lazy browser-only origin/author ownership. It coordinates this client, never +// independent Nostr clients. Only transaction completion acknowledges a plan. +export async function runCapturedPublicEffect<T>( + repository: PublicQuotaRepository, + handle: PublicRecordHandle, + expectedId: unknown, + input: PublicEffectCapture, + review: unknown, + work: (lease: PublicEffectLease) => Promise<T> +): Promise<PublicEffectResult<T>> { + try { + const owner = canonicalPublicKey(input?.owner), + id = canonicalLocalId(expectedId); + const session = input?.session, + fresh = input?.current; + const row = + owner && id ? publicRecordSnapshot(handle, owner, id) : undefined; + const recordWire = + owner && id ? publicRecordWire(handle, owner, id) : undefined; + if ( + review !== 'reviewed_captured_operation' || + !owner || + !id || + !row || + !recordWire || + row.family === 'public_draft' || + row.revision !== 0 || + row.artifact !== null || + typeof session !== 'symbol' || + typeof fresh !== 'function' || + typeof work !== 'function' + ) + return { status: 'invalid' }; + if (typeof window === 'undefined' || !navigator.locks?.request) + return { status: 'unavailable' }; + if (publicQuotaOwner(repository) !== owner) + return { status: 'invalid_scope' }; + return await navigator.locks.request( + 'harvestcircle:owner:' + owner, + { mode: 'exclusive', ifAvailable: true }, + async (lock): Promise<PublicEffectResult<T>> => { + if (!lock) return { status: 'busy' }; + if (!fresh()) return { status: 'stopped' }; + const claimed = await claimPublicOperation(repository, id, handle); + if (!claimed.ok) + return claimed.reason === 'unknown_completion' + ? { status: 'unknown', record: handle } + : { status: claimed.reason }; + const original = claimed.value.record; + if (claimed.value.state === 'existing') { + const stored = publicRecordSnapshot(original, owner, id); + return { + status: + stored && + stored.family !== 'public_draft' && + stored.artifact !== null + ? 'retained' + : 'unknown', + record: original + }; + } + let phase: State = 'active', + closed = false, + accepting = true, + started = false; + let settlement: Promise<void> | null = null; + function outstanding(): Promise<void> | null { + return settlement; + } + function stop() { + if (!closed) phase = started ? 'unknown' : 'stopped'; + } + function current() { + if (closed || phase !== 'active') return false; + let valid = false; + try { + valid = publicQuotaOwner(repository) === owner && fresh() === true; + } catch { + /* finite stale result */ + } + if (!valid) stop(); + return valid && !closed && phase === 'active'; + } + function matches(authority: Authority) { + return ( + authority.owner === owner && + authority.id === id && + authority.recordWire === recordWire && + authority.session === session + ); + } + const lease = Object.freeze({}) as PublicEffectLease; + async function call<V>( + authority: Authority, + invoke: () => Promise<V> + ): Promise<JobResult<V>> { + if (!matches(authority) || typeof invoke !== 'function') + return { status: 'invalid' }; + if (!accepting || !current()) + return { status: phase === 'unknown' ? 'unknown' : 'stopped' }; + if (outstanding()) return { status: 'busy' }; + if (started) return { status: 'stopped' }; + // Reserve the whole SDK job before invoking even its synchronous prefix. + // Callback return cannot release a forgotten/unsettled permission wait. + let release = () => {}; + const held = new Promise<void>((resolve) => { + release = resolve; + }); + settlement = held; + try { + const value = await invoke(); + return { status: 'settled', value, current: current() }; + } catch { + stop(); + return { status: phase === 'unknown' ? 'unknown' : 'stopped' }; + } finally { + settlement = null; + release(); + } + } + leases.set(lease, { + current: (authority) => matches(authority) && current(), + call, + stop, + mark() { + if (started || !outstanding() || !current()) return false; + started = true; + return true; + }, + snapshot: () => ({ + state: phase, + pending: outstanding() !== null, + owner, + id, + hash: row.capture.hash, + revision: row.revision + }) + }); + try { + if (!current()) return { status: 'stopped' }; + let value: T; + try { + value = await work(lease); + } catch { + stop(); + return { + status: 'unknown', + record: original + }; + } + accepting = false; + const waiting = outstanding(); + if (waiting) { + // An orphaned job may settle, but cannot acquire more SDK effects + // or expose an artifact after the operation callback has returned. + phase = 'unknown'; + await waiting; + } + if (!current()) + return phase === 'unknown' + ? { status: 'unknown', record: original } + : { status: 'stopped' }; + return { status: 'completed', value }; + } finally { + accepting = false; + const waiting = outstanding(); + if (waiting) await waiting; + closed = true; + if (phase === 'active') phase = 'closed'; + } + } + ); + } catch { + return { status: 'unavailable' }; + } +} +// These internal mechanical ports expose neither a signer nor a raw template. +// The adapter supplies its actual private session and genuine approval wire. +export function publicEffectLeaseCurrent( + lease: PublicEffectLease, + authority: Authority +): boolean { + return leases.get(lease)?.current(authority) ?? false; +} +export function callOwnedExtension<T>( + lease: PublicEffectLease, + authority: Authority, + work: () => Promise<T> +): Promise<JobResult<T>> { + return ( + leases.get(lease)?.call(authority, work) ?? + Promise.resolve({ status: 'invalid' }) + ); +} +export function markOwnedSignaturePending(lease: PublicEffectLease): boolean { + return leases.get(lease)?.mark() ?? false; +} +export function stopPublicEffect(lease: PublicEffectLease): void { + leases.get(lease)?.stop(); +} +export function publicEffectSnapshot(lease: PublicEffectLease) { + return leases.get(lease)?.snapshot(); +} diff --git a/web/tests/e2e/approved-signing.spec.ts b/web/tests/e2e/approved-signing.spec.ts @@ -207,7 +207,7 @@ test('unsettled signing retains shared slot and disconnect fences late exact res window.hcp053Release(); return (await window.hcp053Task).status; }) - ).toBe('stale'); + ).toBe('unknown'); expect( await page.evaluate(() => window.hcp053.extensionSnapshot(window.hcp053Adapter) @@ -255,7 +255,7 @@ for (const phase of ['before', 'after'] as const) other.close(); } }, phase); - expect(outcome.status).toBe('stale'); + expect(outcome.status).toBe(phase === 'before' ? 'stale' : 'unknown'); expect(outcome.calls).toEqual( phase === 'before' ? ['key'] : ['key', 'sign', 'key'] ); diff --git a/web/tests/e2e/effect-ownership.spec.ts b/web/tests/e2e/effect-ownership.spec.ts @@ -0,0 +1,617 @@ +import { expect, test, type Page } from '@playwright/test'; +import { build } from 'vite'; +import { fileURLToPath } from 'node:url'; +import { createHash } from 'node:crypto'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Effects from './harness/effect-ownership.ts'; +import type { PublicRecordHandle } from '../../src/lib/persistence/records.ts'; +import type { PublicQuotaRepository } from '../../src/lib/persistence/quota.ts'; +import type { BrowserDatabase } from '../../src/lib/persistence/database.ts'; +import type { + ExtensionAdapter, + ApprovedSignResult +} from '../../src/lib/nostr/extension.ts'; +import type { ApprovedPublicSigning } from '../../src/lib/nostr/approved-signing.ts'; +import type { + PublicEffectLease, + PublicEffectResult +} from '../../src/lib/runtime/effect-ownership.ts'; +declare global { + interface Window { + hcp054: typeof Effects; + hcp054Fixture: ReturnType<typeof Effects.makeFixture>; + hcp054Record: PublicRecordHandle; + hcp054Repository: PublicQuotaRepository; + hcp054Database: BrowserDatabase; + hcp054Adapter: ExtensionAdapter; + hcp054Approval: ApprovedPublicSigning; + hcp054Owner: string; + hcp054Id: string; + hcp054Wire: string; + hcp054Counts: { keys: number; signs: number; work: number }; + hcp054Release: () => void; + hcp054SignStarted: () => void; + hcp054Inner: ApprovedSignResult; + hcp054Lease: PublicEffectLease; + hcp054Task: Promise<PublicEffectResult<unknown>>; + } +} +let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string; +test.beforeAll(async () => { + server = await createStaticHarness(); + const result = await build({ + configFile: false, + logLevel: 'silent', + build: { + write: false, + minify: false, + lib: { + entry: fileURLToPath( + new URL('./harness/effect-ownership.ts', import.meta.url) + ), + name: 'hcp054', + formats: ['iife'] + } + } + }); + const output = Array.isArray(result) ? result[0] : result; + if (!('output' in output)) throw new Error('missing bundle'); + const chunks = output.output.filter((item) => item.type === 'chunk'); + expect(chunks).toHaveLength(1); + bundle = chunks[0].code; + console.log( + JSON.stringify({ + fixture: 'HCP054_ACTUAL_WEB_LOCKS_IDB_SDK_MULTITAB', + bundleSha256: createHash('sha256').update(bundle).digest('hex'), + moduleIds: Object.keys(chunks[0].modules), + qualification: + 'real local Chromium/source only; no named extension/externalclient/global cancellation claim' + }) + ); +}); +test.afterAll(async () => server.close()); +type Shared = { owner: string; id: string; wire: string }; +async function load(page: Page, shared?: Shared): Promise<Shared> { + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); + return page.evaluate(async (shared) => { + const s = window.hcp054; + const f = shared ? undefined : s.makeFixture(); + if (f) window.hcp054Fixture = f; + const owner = shared?.owner ?? f!.owner, + id = shared?.id ?? f!.id, + wire = shared?.wire ?? s.publicRecordWire(f!.record, owner, id)!; + const decoded = s.decodePublicRecord(wire, owner, id); + if (!decoded.ok) throw new Error('invalid public fixture'); + window.hcp054Owner = owner; + window.hcp054Id = id; + window.hcp054Wire = wire; + window.hcp054Record = decoded.value; + const opened = await s.openBrowserDatabase(); + if (opened.state !== 'ready') throw new Error(opened.reason); + window.hcp054Database = opened.owner; + const repo = s.createPublicQuotaRepository(opened.owner, owner); + if (!repo) throw new Error('invalid repository'); + window.hcp054Repository = repo; + window.hcp054Counts = { keys: 0, signs: 0, work: 0 }; + window.nostr = { + getPublicKey: () => { + window.hcp054Counts.keys++; + return Promise.resolve(owner); + }, + signEvent: ( + template: Parameters<ReturnType<typeof s.makeFixture>['sign']>[0] + ) => { + window.hcp054Counts.signs++; + if (!f) throw new Error('unexpected second-tab signature'); + return Promise.resolve(f.sign(template)); + } + }; + window.hcp054Adapter = s.createExtensionAdapter(); + await s.connectExtensionAdapter(window.hcp054Adapter); + const approval = s.approveCapturedPublicSigning( + decoded.value, + owner, + id, + 'reviewed_captured_operation' + ); + if (!approval) throw new Error('missing approval'); + window.hcp054Approval = approval; + window.hcp054Counts = { keys: 0, signs: 0, work: 0 }; + return { owner, id, wire }; + }, shared); +} +async function begin( + page: Page, + mode: 'hold' | 'sign_hold' | 'forgotten' | 'commit' | 'wrong_session' = 'hold' +) { + await page.evaluate((mode) => { + const s = window.hcp054, + context = s.extensionOwnershipCapture(window.hcp054Adapter); + if (!context) throw new Error('missing context'); + const signStarted = new Promise<void>((resolve) => { + window.hcp054SignStarted = resolve; + }); + if (mode === 'sign_hold' || mode === 'forgotten') + window.nostr = { + getPublicKey: () => { + window.hcp054Counts.keys++; + return Promise.resolve(window.hcp054Owner); + }, + signEvent: ( + template: Parameters<ReturnType<typeof s.makeFixture>['sign']>[0] + ) => { + window.hcp054Counts.signs++; + window.hcp054SignStarted(); + return new Promise((resolve) => { + window.hcp054Release = () => + resolve(window.hcp054Fixture.sign(template)); + }); + } + }; + const captured = + mode === 'wrong_session' ? { ...context, session: Symbol() } : context; + window.hcp054Task = s.runCapturedPublicEffect( + window.hcp054Repository, + window.hcp054Record, + window.hcp054Id, + captured, + 'reviewed_captured_operation', + async (lease) => { + window.hcp054Counts.work++; + window.hcp054Lease = lease; + if (mode === 'hold') { + await new Promise<void>((resolve) => { + window.hcp054Release = resolve; + }); + return 'original'; + } + if (mode === 'forgotten') { + void s + .signApprovedExtensionAdapter( + window.hcp054Adapter, + window.hcp054Approval, + lease + ) + .then((result) => { + window.hcp054Inner = result; + }); + await signStarted; + return 'forgotten'; + } + const result = await s.signApprovedExtensionAdapter( + window.hcp054Adapter, + window.hcp054Approval, + lease + ); + if (mode !== 'commit' || result.status !== 'signed') return result; + const next = s.preparePublicArtifactTransition( + window.hcp054Record, + window.hcp054Owner, + window.hcp054Id, + result.artifact + ); + if (!next.ok) throw new Error(next.reason); + const stored = await s.commitPublicOperationTransition( + window.hcp054Repository, + next.value + ); + if (!stored.ok) throw new Error(stored.reason); + return s.capturedArtifactSnapshot(result.artifact)?.wire; + } + ); + }, mode); +} +async function retry(page: Page) { + return page.evaluate(async () => { + const s = window.hcp054, + context = s.extensionOwnershipCapture(window.hcp054Adapter); + if (!context) throw new Error('missing context'); + const result = await s.runCapturedPublicEffect( + window.hcp054Repository, + window.hcp054Record, + window.hcp054Id, + context, + 'reviewed_captured_operation', + () => { + window.hcp054Counts.work++; + return Promise.resolve('unexpected replay'); + } + ); + const row = + 'record' in result + ? s.publicRecordSnapshot( + result.record, + window.hcp054Owner, + window.hcp054Id + ) + : undefined; + return { status: result.status, row, counts: window.hcp054Counts }; + }); +} +test.afterEach(async ({ context }) => { + for (const page of context.pages()) + if (!page.isClosed()) + await page.evaluate(() => { + window.hcp054Fixture?.close(); + if (window.hcp054Database) + window.hcp054.closeBrowserDatabase(window.hcp054Database); + }); +}); +test('two tabs same command create one durable original plan and only one active callback', async ({ + page, + context +}) => { + const original = await load(page), + other = await context.newPage(); + await load(other, original); + await begin(page); + await expect + .poll(() => page.evaluate(() => window.hcp054Counts.work)) + .toBe(1); + expect((await retry(other)).status).toBe('busy'); + expect((await retry(other)).counts).toEqual({ keys: 0, signs: 0, work: 0 }); + await page.evaluate(() => window.hcp054Release()); + expect( + await page.evaluate(async () => (await window.hcp054Task).status) + ).toBe('completed'); + const recovered = await retry(other); + expect(recovered.status).toBe('unknown'); + expect( + recovered.row && + recovered.row.family !== 'public_draft' && + recovered.row.capture.wire + ).toBe( + (JSON.parse(original.wire) as { capture: { wire: string } }).capture.wire + ); + expect(recovered.counts.work).toBe(0); +}); +test('page loss during actual SDK prompt retains original unknown capture without replan or signature', async ({ + page, + context +}) => { + const original = await load(page), + other = await context.newPage(); + await load(other, original); + await begin(page, 'sign_hold'); + await expect + .poll(() => page.evaluate(() => window.hcp054Counts.signs)) + .toBe(1); + expect((await retry(other)).status).toBe('busy'); + await page.evaluate(() => window.hcp054Fixture.close()); + await page.close(); + const recovered = await retry(other); + expect(recovered.status).toBe('unknown'); + expect( + recovered.row && + recovered.row.family !== 'public_draft' && + recovered.row.artifact + ).toBeNull(); + expect(recovered.row && JSON.stringify(recovered.row)).toBe(original.wire); + expect(recovered.counts).toEqual({ keys: 0, signs: 0, work: 0 }); +}); +test('forgotten SDK await keeps the browser lock and reports unknown after actual settlement', async ({ + page, + context +}) => { + const original = await load(page), + other = await context.newPage(); + await load(other, original); + await begin(page, 'forgotten'); + await expect + .poll(() => page.evaluate(() => window.hcp054Counts.signs)) + .toBe(1); + expect((await retry(other)).status).toBe('busy'); + await page.evaluate(() => window.hcp054Release()); + expect( + await page.evaluate(async () => (await window.hcp054Task).status) + ).toBe('unknown'); + expect((await retry(other)).status).toBe('unknown'); +}); +test('explicit stop during prompt fences late signature and retains lock until settlement', async ({ + page, + context +}) => { + const original = await load(page), + other = await context.newPage(); + await load(other, original); + await begin(page, 'sign_hold'); + await expect + .poll(() => page.evaluate(() => window.hcp054Counts.signs)) + .toBe(1); + await page.evaluate(() => window.hcp054.stopPublicEffect(window.hcp054Lease)); + expect((await retry(other)).status).toBe('busy'); + await page.evaluate(() => window.hcp054Release()); + expect( + await page.evaluate(async () => (await window.hcp054Task).status) + ).toBe('unknown'); + expect(await page.evaluate(() => window.hcp054Counts)).toEqual({ + keys: 1, + signs: 1, + work: 1 + }); +}); +test('unrelated owners acquire independent locks while same owner remains busy', async ({ + page, + context +}) => { + await load(page); + const other = await context.newPage(); + await load(other); + await begin(page); + await begin(other); + await expect + .poll(() => other.evaluate(() => window.hcp054Counts.work)) + .toBe(1); + await page.evaluate(() => window.hcp054Release()); + await other.evaluate(() => window.hcp054Release()); + expect( + await page.evaluate(async () => (await window.hcp054Task).status) + ).toBe('completed'); + expect( + await other.evaluate(async () => (await window.hcp054Task).status) + ).toBe('completed'); +}); +test('unsupported locks perform zero writes/signing and public browsing remains usable', async ({ + page +}) => { + await load(page); + await page.evaluate(() => + Object.defineProperty(navigator, 'locks', { + value: undefined, + configurable: true + }) + ); + expect((await retry(page)).status).toBe('unavailable'); + const size = await page.evaluate(async () => { + const s = window.hcp054, + inventory = await s.inspectPublicStorage(window.hcp054Repository); + return inventory.ok + ? s.publicInventorySnapshot(window.hcp054Repository, inventory.value) + ?.rows.length + : -1; + }); + expect(size).toBe(0); + expect(await page.evaluate(() => window.hcp054Counts)).toEqual({ + keys: 0, + signs: 0, + work: 0 + }); + expect(page.url()).toContain('/search'); +}); +test('a genuine lease with another session cannot authorize any SDK call', async ({ + page +}) => { + await load(page); + await begin(page, 'wrong_session'); + const result = await page.evaluate(async () => { + const value = await window.hcp054Task; + return { + status: value.status, + inner: + 'value' in value ? (value.value as { status: string }).status : null, + counts: window.hcp054Counts + }; + }); + expect(result.inner).toBe('invalid_ownership'); + expect(result.counts).toEqual({ keys: 0, signs: 0, work: 1 }); +}); +test('retained signed artifact stays exact and conflicting capture cannot create another effect', async ({ + page, + context +}) => { + const original = await load(page); + await begin(page, 'commit'); + const signed = await page.evaluate(async () => { + const value = await window.hcp054Task; + return 'value' in value ? value.value : undefined; + }); + expect(typeof signed).toBe('string'); + const other = await context.newPage(); + await load(other, original); + const replay = await retry(other); + expect(replay.status).toBe('retained'); + expect( + replay.row && + replay.row.family !== 'public_draft' && + replay.row.artifact?.wire + ).toBe(signed); + expect(replay.counts).toEqual({ keys: 0, signs: 0, work: 0 }); + const conflict = await other.evaluate(async () => { + const s = window.hcp054, + row = s.publicRecordSnapshot( + window.hcp054Record, + window.hcp054Owner, + window.hcp054Id + ); + if (!row || row.family === 'public_draft') + throw new Error('invalid fixture'); + const decoded = s.decodePublicRecord( + JSON.stringify({ + ...row, + capture: { ...row.capture, targets: ['wss://other.example.org'] } + }), + window.hcp054Owner, + window.hcp054Id + ); + if (!decoded.ok) throw new Error(decoded.reason); + const capture = s.extensionOwnershipCapture(window.hcp054Adapter)!; + return ( + await s.runCapturedPublicEffect( + window.hcp054Repository, + decoded.value, + window.hcp054Id, + capture, + 'reviewed_captured_operation', + () => Promise.resolve('forbidden') + ) + ).status; + }); + expect(conflict).toBe('conflict'); +}); + +test('one captured lease never signs the same operation twice', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const s = window.hcp054, + context = s.extensionOwnershipCapture(window.hcp054Adapter)!; + const result = await s.runCapturedPublicEffect( + window.hcp054Repository, + window.hcp054Record, + window.hcp054Id, + context, + 'reviewed_captured_operation', + async (lease) => { + const first = await s.signApprovedExtensionAdapter( + window.hcp054Adapter, + window.hcp054Approval, + lease + ); + const second = await s.signApprovedExtensionAdapter( + window.hcp054Adapter, + window.hcp054Approval, + lease + ); + return { + first: first.status, + second: second.status, + secondArtifact: 'artifact' in second + }; + } + ); + return { result, counts: window.hcp054Counts }; + }); + expect(result.counts.signs).toBe(1); + expect(result.counts.keys).toBe(2); + expect(result.result.status).toBe('completed'); + expect('value' in result.result ? result.result.value : null).toEqual({ + first: 'signed', + second: 'stale', + secondArtifact: false + }); +}); + +test('orphaned signing job cannot expose a late artifact or issue another SDK call', async ({ + page +}) => { + await load(page); + await begin(page, 'forgotten'); + await expect + .poll(() => page.evaluate(() => window.hcp054Counts.signs)) + .toBe(1); + await page.evaluate(() => window.hcp054Release()); + expect( + await page.evaluate(async () => (await window.hcp054Task).status) + ).toBe('unknown'); + await expect + .poll(() => page.evaluate(() => window.hcp054Inner?.status)) + .toBe('unknown'); + expect(await page.evaluate(() => 'artifact' in window.hcp054Inner)).toBe( + false + ); + expect(await page.evaluate(() => window.hcp054Counts.keys)).toBe(1); +}); +test('same author different operation contends before creating a second durable plan', async ({ + page, + context +}) => { + const original = await load(page), + other = await context.newPage(); + const id = crypto.randomUUID(), + row = JSON.parse(original.wire) as { id: string }; + await load(other, { ...original, id, wire: JSON.stringify({ ...row, id }) }); + await begin(page); + await expect + .poll(() => page.evaluate(() => window.hcp054Counts.work)) + .toBe(1); + expect((await retry(other)).status).toBe('busy'); + expect( + await other.evaluate(async () => { + const s = window.hcp054, + read = await s.inspectPublicStorage(window.hcp054Repository); + return read.ok + ? s.publicInventorySnapshot(window.hcp054Repository, read.value)?.rows + .length + : -1; + }) + ).toBe(1); + expect(await other.evaluate(() => window.hcp054Counts)).toEqual({ + keys: 0, + signs: 0, + work: 0 + }); + await page.evaluate(() => window.hcp054Release()); + await page.evaluate(() => window.hcp054Task); + await begin(other); + await expect + .poll(() => other.evaluate(() => window.hcp054Counts.work)) + .toBe(1); + await other.evaluate(() => window.hcp054Release()); + expect( + await other.evaluate(async () => (await window.hcp054Task).status) + ).toBe('completed'); +}); +test('mismatched full-record approval and fabricated lease perform zero SDK calls', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const s = window.hcp054, + capture = s.extensionOwnershipCapture(window.hcp054Adapter)!; + const row = s.publicRecordSnapshot( + window.hcp054Record, + window.hcp054Owner, + window.hcp054Id + ); + if (!row || row.family === 'public_draft') + throw new Error('invalid fixture'); + const changed = s.decodePublicRecord( + JSON.stringify({ + ...row, + capture: { ...row.capture, targets: ['wss://other.example.org'] } + }), + window.hcp054Owner, + window.hcp054Id + ); + if (!changed.ok) throw new Error(changed.reason); + const approval = s.approveCapturedPublicSigning( + changed.value, + window.hcp054Owner, + window.hcp054Id, + 'reviewed_captured_operation' + ); + if (!approval) throw new Error('invalid changed approval'); + return s.runCapturedPublicEffect( + window.hcp054Repository, + window.hcp054Record, + window.hcp054Id, + capture, + 'reviewed_captured_operation', + async (lease) => { + const mismatched = await s.signApprovedExtensionAdapter( + window.hcp054Adapter, + approval, + lease + ); + const forged = await s.signApprovedExtensionAdapter( + window.hcp054Adapter, + window.hcp054Approval, + {} as PublicEffectLease + ); + return { + mismatched: mismatched.status, + forged: forged.status, + counts: window.hcp054Counts + }; + } + ); + }); + expect(result.status).toBe('completed'); + expect('value' in result ? result.value : null).toEqual({ + mismatched: 'invalid_ownership', + forged: 'invalid_ownership', + counts: { keys: 0, signs: 0, work: 0 } + }); +}); diff --git a/web/tests/e2e/harness/approved-signing.ts b/web/tests/e2e/harness/approved-signing.ts @@ -6,28 +6,97 @@ import { } from 'applesauce-core/helpers'; import { decodePublicRecord, - publicRecordSnapshot + publicRecordSnapshot, + type PublicRecordHandle } from '../../../src/lib/persistence/records.ts'; import { capturedArtifactSnapshot } from '../../../src/lib/persistence/artifact-records.ts'; import { - approveCapturedPublicSigning, + approveCapturedPublicSigning as approveActual, + approvedSigningIdentity, + type ApprovedPublicSigning, disposableApprovedTemplate, bindApprovedResponse } from '../../../src/lib/nostr/approved-signing.ts'; +import { + signApprovedExtensionAdapter as signActual, + extensionOwnershipCapture, + type ExtensionAdapter, + type ApprovedSignResult +} from '../../../src/lib/nostr/extension.ts'; +import { + openBrowserDatabase, + closeBrowserDatabase +} from '../../../src/lib/persistence/database.ts'; +import { createPublicQuotaRepository } from '../../../src/lib/persistence/quota.ts'; +import { runCapturedPublicEffect } from '../../../src/lib/runtime/effect-ownership.ts'; export { createExtensionAdapter, connectExtensionAdapter, disconnectExtensionAdapter, - signApprovedExtensionAdapter, extensionSnapshot } from '../../../src/lib/nostr/extension.ts'; export { - approveCapturedPublicSigning, disposableApprovedTemplate, bindApprovedResponse, capturedArtifactSnapshot, publicRecordSnapshot }; +// Test-only orchestration of the same actual locked signing port. Production +// adapter/identity code never owns database acquisition or a signing bypass. +const capturedRecords = new WeakMap< + ApprovedPublicSigning, + PublicRecordHandle +>(); +export function approveCapturedPublicSigning( + record: PublicRecordHandle, + owner: unknown, + id: unknown, + review: unknown +) { + const approved = approveActual(record, owner, id, review); + if (approved) capturedRecords.set(approved, record); + return approved; +} +export async function signApprovedExtensionAdapter( + adapter: ExtensionAdapter, + approval: ApprovedPublicSigning +): Promise<ApprovedSignResult> { + const record = capturedRecords.get(approval), + identity = approvedSigningIdentity(approval), + capture = extensionOwnershipCapture(adapter); + if (!record || !identity) return { status: 'invalid_approval' }; + if (!capture) return { status: 'unavailable' }; + const opened = await openBrowserDatabase(); + if (opened.state !== 'ready') return { status: 'unavailable' }; + try { + const repository = createPublicQuotaRepository( + opened.owner, + identity.owner + ); + if (!repository) return { status: 'unavailable' }; + const result = await runCapturedPublicEffect( + repository, + record, + identity.id, + capture, + 'reviewed_captured_operation', + (lease) => signActual(adapter, approval, lease) + ); + if (result.status === 'completed') return result.value; + return { + status: + result.status === 'busy' + ? 'busy' + : result.status === 'unknown' + ? 'unknown' + : result.status === 'stopped' + ? 'stale' + : 'unavailable' + }; + } finally { + closeBrowserDatabase(opened.owner); + } +} export type Mode = | 'exact' | 'author' diff --git a/web/tests/e2e/harness/effect-ownership.ts b/web/tests/e2e/harness/effect-ownership.ts @@ -0,0 +1,34 @@ +export { makeFixture } from './approved-signing.ts'; +export { + openBrowserDatabase, + closeBrowserDatabase +} from '../../../src/lib/persistence/database.ts'; +export { + createPublicQuotaRepository, + claimPublicOperation, + commitPublicOperationTransition, + inspectPublicStorage, + publicInventorySnapshot +} from '../../../src/lib/persistence/quota.ts'; +export { + decodePublicRecord, + publicRecordSnapshot, + publicRecordWire +} from '../../../src/lib/persistence/records.ts'; +export { + preparePublicArtifactTransition, + capturedArtifactSnapshot +} from '../../../src/lib/persistence/artifact-records.ts'; +export { approveCapturedPublicSigning } from '../../../src/lib/nostr/approved-signing.ts'; +export { + createExtensionAdapter, + connectExtensionAdapter, + disconnectExtensionAdapter, + extensionOwnershipCapture, + signApprovedExtensionAdapter +} from '../../../src/lib/nostr/extension.ts'; +export { + runCapturedPublicEffect, + publicEffectSnapshot, + stopPublicEffect +} from '../../../src/lib/runtime/effect-ownership.ts'; diff --git a/web/tests/integration/approved-signing.test.ts b/web/tests/integration/approved-signing.test.ts @@ -8,6 +8,7 @@ import { approveCapturedPublicSigning, type ApprovedPublicSigning } from '../../src/lib/nostr/approved-signing.ts'; +import type { PublicEffectLease } from '../../src/lib/runtime/effect-ownership.ts'; await test('approved signing import/SSR and forged approval have no provider or storage effect', async () => { assert.equal(typeof window, 'undefined'); const adapter = createExtensionAdapter(); @@ -21,7 +22,11 @@ await test('approved signing import/SSR and forged approval have no provider or undefined ); assert.deepEqual( - await signApprovedExtensionAdapter(adapter, {} as ApprovedPublicSigning), + await signApprovedExtensionAdapter( + adapter, + {} as ApprovedPublicSigning, + {} as PublicEffectLease + ), { status: 'invalid_approval' } ); }); diff --git a/web/tests/integration/effect-ownership.test.ts b/web/tests/integration/effect-ownership.test.ts @@ -0,0 +1,19 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { + createExtensionAdapter, + extensionOwnershipCapture +} from '../../src/lib/nostr/extension.ts'; +import { + publicEffectSnapshot, + stopPublicEffect, + type PublicEffectLease +} from '../../src/lib/runtime/effect-ownership.ts'; +await test('actual owner/lock modules remain inert and cannot manufacture a connected SSR capture', () => { + assert.equal(typeof window, 'undefined'); + assert.equal(extensionOwnershipCapture(createExtensionAdapter()), undefined); + const fake = {} as PublicEffectLease; + assert.equal(publicEffectSnapshot(fake), undefined); + stopPublicEffect(fake); + assert.equal(publicEffectSnapshot(fake), undefined); +}); diff --git a/web/tests/unit/effect-ownership.test.ts b/web/tests/unit/effect-ownership.test.ts @@ -0,0 +1,88 @@ +import { describe, expect, it } from 'vitest'; +import { makeFixture } from '../e2e/harness/approved-signing.ts'; +import { + runCapturedPublicEffect, + publicEffectSnapshot, + type PublicEffectLease +} from '../../src/lib/runtime/effect-ownership.ts'; +import type { PublicQuotaRepository } from '../../src/lib/persistence/quota.ts'; +describe('owned effect admission boundaries', () => { + it('keeps genuine browser-only capture unavailable in SSR without invoking work', async () => { + const f = makeFixture(); + let calls = 0; + try { + const result = await runCapturedPublicEffect( + {} as PublicQuotaRepository, + f.record, + f.id, + { owner: f.owner, session: Symbol(), current: () => true }, + 'reviewed_captured_operation', + () => { + calls++; + return Promise.resolve('forbidden'); + } + ); + expect(result.status).toBe('unavailable'); + expect(calls).toBe(0); + } finally { + f.close(); + } + }); + it('rejects unreviewed or forged and cross-ID capture before invoking effects', async () => { + const f = makeFixture(); + let calls = 0; + try { + const context = { + owner: f.owner, + session: Symbol(), + current: () => true + }, + work = () => { + calls++; + return Promise.resolve(); + }; + expect( + ( + await runCapturedPublicEffect( + {} as PublicQuotaRepository, + f.record, + f.id, + context, + undefined, + work + ) + ).status + ).toBe('invalid'); + expect( + ( + await runCapturedPublicEffect( + {} as PublicQuotaRepository, + {} as never, + f.id, + context, + 'reviewed_captured_operation', + work + ) + ).status + ).toBe('invalid'); + expect( + ( + await runCapturedPublicEffect( + {} as PublicQuotaRepository, + f.record, + crypto.randomUUID(), + context, + 'reviewed_captured_operation', + work + ) + ).status + ).toBe('invalid'); + expect(calls).toBe(0); + } finally { + f.close(); + } + }); + it('fabricated ownership leases have no capability or mutable snapshot', () => { + expect(publicEffectSnapshot({} as PublicEffectLease)).toBeUndefined(); + }); +});