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:
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();
+ });
+});