commit f5799cc957d3b205696b1c4c2de01419e18103ed
parent bd1348e67dd0618eb29f0f30f50d2379a342fdc7
Author: triesap <tyson@radroots.org>
Date: Fri, 9 Oct 2026 15:21:25 +0000
web: render message requests and conversations as simple lists (HCP-102)
Diffstat:
13 files changed, 1429 insertions(+), 21 deletions(-)
diff --git a/web/src/lib/components/ConversationRow.svelte b/web/src/lib/components/ConversationRow.svelte
@@ -0,0 +1,53 @@
+<script lang="ts">
+ import Button from './primitives/Button.svelte';
+ import {
+ inboxConversationRow,
+ type InboxView
+ } from '../messaging/inbox-view.ts';
+ import type { InboxListRow } from '../messaging/inbox-list.ts';
+ let {
+ controller,
+ row,
+ onopen
+ }: {
+ controller: InboxView;
+ row: InboxListRow;
+ onopen?: (peer: string) => void;
+ } = $props();
+ // A detached row is only an invalidation/peer selection hint. Its body, unread
+ // and role are never rendered without the same current genuine controller.
+ const current = $derived(
+ row ? inboxConversationRow(controller, row.peer) : undefined
+ );
+ const preview = $derived(
+ current
+ ? Array.from(current.latest.content).slice(0, 160).join('') +
+ (Array.from(current.latest.content).length > 160 ? '…' : '')
+ : ''
+ );
+ const time = $derived(
+ current ? new Date(current.latest.createdAt * 1000) : undefined
+ );
+</script>
+
+{#if current}
+ <article class="stack" aria-label="Local conversation">
+ <div class="cluster">
+ <span class="key"
+ >Peer {current.peer.slice(0, 8)}…{current.peer.slice(-8)}</span
+ >{#if current.unread > 0}<span>New</span>{/if}<span class="text-small"
+ >{time && !Number.isNaN(time.getTime())
+ ? time.toLocaleString()
+ : 'Time unavailable'}</span
+ >
+ </div>
+ <p>{current.latest.role === 'self_archive' ? 'You: ' : ''}{preview}</p>
+ <Button
+ label={'Open conversation with ' + current.peer}
+ disabled={!onopen}
+ onclick={() => {
+ if (current) onopen?.(current.peer);
+ }}
+ />
+ </article>
+{/if}
diff --git a/web/src/lib/components/InboxStatus.svelte b/web/src/lib/components/InboxStatus.svelte
@@ -1,5 +1,8 @@
<script lang="ts">
import { getContext, onMount } from 'svelte';
+ import { goto } from '$app/navigation';
+ import { internalHref } from '../navigation-url.ts';
+ import ConversationRow from './ConversationRow.svelte';
import CapabilityGate from './CapabilityGate.svelte';
import InboxSetup from './InboxSetup.svelte';
import Button from './primitives/Button.svelte';
@@ -26,6 +29,11 @@
import {
createInboxView,
inboxViewSnapshot,
+ inboxListSnapshot,
+ inboxListRevision,
+ openInboxConversation,
+ loadOlderInboxView,
+ inboxViewOlderAvailable,
inboxViewSetup,
subscribeInboxView,
unlockInboxView,
@@ -42,11 +50,24 @@
publicContext = getContext<PublicRuntimeContext>(PUBLIC_RUNTIME_CONTEXT);
let identity = $state(identityViewSnapshot(identityContext)),
panel = $state(inboxViewSnapshot(undefined)),
+ list = $state(inboxListSnapshot(undefined)),
+ olderAvailable = $state(false),
owned = $state.raw<InboxView | undefined>();
let runtime: PublicRuntime | undefined,
off = () => {};
const setup = $derived(inboxViewSetup(owned));
onMount(() => {
+ let observedRevision = -2,
+ observedMode = '';
+ function updateList() {
+ const revision = inboxListRevision(owned),
+ mode = panel.state + ':' + panel.count + ':' + (panel.reason ?? '');
+ if (revision !== observedRevision || mode !== observedMode) {
+ list = inboxListSnapshot(owned);
+ observedRevision = revision;
+ observedMode = mode;
+ }
+ }
let disposed = false;
function acquire() {
if (disposed) return;
@@ -72,8 +93,13 @@
}
}
panel = inboxViewSnapshot(owned);
+ observedRevision = -2;
+ updateList();
+ olderAvailable = inboxViewOlderAvailable(owned);
off = subscribeInboxView(owned, (next) => {
panel = next;
+ updateList();
+ olderAvailable = inboxViewOlderAvailable(owned);
});
}
const identityOff = identityContext
@@ -101,6 +127,19 @@
}
};
});
+ async function openConversation(peer: string) {
+ const original = owned;
+ if (!original) return;
+ const result = await openInboxConversation(
+ original,
+ peer,
+ 'reviewed_admitted_conversation_navigation'
+ );
+ const href = internalHref(result);
+ if (owned !== original || inboxListSnapshot(original).status !== 'ready')
+ return;
+ if (href) void goto(href);
+ }
const effectiveIdentity = $derived(
panel.owner ? panel.identity : identity.identity
);
@@ -213,8 +252,41 @@
}}
/>
{/if}
- <h2>Message requests</h2>
- <h2>Conversations</h2>
+ {#if owned && list.status === 'ready'}
+ {#if list.requests.length > 0}<section
+ class="stack"
+ aria-label="Message requests"
+ >
+ <h2>Message requests</h2>
+ {#each list.requests as row (row.peer)}<ConversationRow
+ controller={owned}
+ {row}
+ onopen={openConversation}
+ />{/each}
+ </section>{/if}
+ {#if list.conversations.length > 0}<section
+ class="stack"
+ aria-label="Conversations"
+ >
+ <h2>Conversations</h2>
+ {#each list.conversations as row (row.peer)}<ConversationRow
+ controller={owned}
+ {row}
+ onopen={openConversation}
+ />{/each}
+ </section>{/if}
+ <p class="text-small">
+ New means locally unread in this browser. No remote read receipt or
+ background message awareness is implied.
+ </p>
+ {/if}
+ <Button
+ label="Load older messages"
+ disabled={!owned || panel.busy || !olderAvailable}
+ onclick={() => {
+ if (owned) void loadOlderInboxView(owned, 'reviewed_load_older');
+ }}
+ />
<Button
label="Lock messages"
disabled={!owned}
diff --git a/web/src/lib/messaging/inbox-list.ts b/web/src/lib/messaging/inbox-list.ts
@@ -0,0 +1,110 @@
+import { canonicalPublicKey } from '../contracts/public-key.ts';
+import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts';
+import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts';
+import { localUnreadRumors } from './unread.ts';
+import type { ConversationData } from './admit-conversation.ts';
+export type InboxListRow = Readonly<{
+ peer: string;
+ count: number;
+ unread: number;
+ latest: ConversationData;
+}>;
+export type InboxListSnapshot = Readonly<{
+ status: 'ready' | 'locked' | 'unavailable';
+ requests: readonly InboxListRow[];
+ conversations: readonly InboxListRow[];
+}>;
+const unavailable = (): InboxListSnapshot => ({
+ status: 'unavailable',
+ requests: [],
+ conversations: []
+});
+function arrayValue(value: unknown): boolean {
+ return Array.isArray(value);
+}
+// Pure detached presentation. These values never authenticate a sender or grant
+// storage, navigation, decryption, query or reply permission.
+export function groupInboxMessages(
+ owner: unknown,
+ messages: readonly ConversationData[],
+ read: readonly string[]
+): InboxListSnapshot {
+ if (
+ !canonicalPublicKey(owner) ||
+ !arrayValue(messages) ||
+ !arrayValue(read) ||
+ messages.length > LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes
+ )
+ return unavailable();
+ const rows = new Map<string, ConversationData>(),
+ wires = new Map<string, string>();
+ for (const row of messages) {
+ if (
+ !row ||
+ row.owner !== owner ||
+ !canonicalPublicKey(row.peer) ||
+ row.peer === owner ||
+ !['inbound', 'self_archive'].includes(row.role) ||
+ row.sender !== (row.role === 'inbound' ? row.peer : owner) ||
+ row.recipient !== (row.role === 'inbound' ? owner : row.peer) ||
+ typeof row.rumorId !== 'string' ||
+ !/^[0-9a-f]{64}$/.test(row.rumorId) ||
+ !Number.isSafeInteger(row.createdAt) ||
+ row.createdAt < 0 ||
+ typeof row.content !== 'string' ||
+ !boundedUtf8(row.content, 4096) ||
+ (row.subject !== null && typeof row.subject !== 'string') ||
+ (row.replyTo !== null &&
+ (typeof row.replyTo !== 'string' ||
+ !/^[0-9a-f]{64}$/.test(row.replyTo)))
+ )
+ return unavailable();
+ const wire = JSON.stringify([
+ row.owner,
+ row.peer,
+ row.sender,
+ row.recipient,
+ row.role,
+ row.rumorId,
+ row.createdAt,
+ row.content,
+ row.subject,
+ row.replyTo
+ ]),
+ old = wires.get(row.rumorId);
+ if (old !== undefined && old !== wire) return unavailable();
+ wires.set(row.rumorId, wire);
+ rows.set(row.rumorId, { ...row });
+ }
+ const grouped = new Map<string, ConversationData[]>();
+ for (const row of rows.values())
+ grouped.set(row.peer, (grouped.get(row.peer) ?? []).concat(row));
+ let requests = Array.from<InboxListRow>([]),
+ conversations = Array.from<InboxListRow>([]);
+ for (const [peer, group] of grouped) {
+ const ordered = group
+ .slice()
+ .sort(
+ (a, b) =>
+ b.createdAt - a.createdAt || b.rumorId.localeCompare(a.rumorId)
+ ),
+ row = {
+ peer,
+ count: group.length,
+ unread: localUnreadRumors(group, owner as string, read).length,
+ latest: { ...ordered[0] }
+ };
+ if (group.some((value) => value.role === 'self_archive'))
+ conversations = conversations.concat(row);
+ else requests = requests.concat(row);
+ }
+ const order = (a: InboxListRow, b: InboxListRow) =>
+ b.latest.createdAt - a.latest.createdAt ||
+ b.latest.rumorId.localeCompare(a.latest.rumorId) ||
+ a.peer.localeCompare(b.peer);
+ return {
+ status: 'ready',
+ requests: requests.sort(order),
+ conversations: conversations.sort(order)
+ };
+}
diff --git a/web/src/lib/messaging/inbox-view.ts b/web/src/lib/messaging/inbox-view.ts
@@ -1,3 +1,32 @@
+import { canonicalPublicKey } from '../contracts/public-key.ts';
+import {
+ groupInboxMessages,
+ type InboxListSnapshot,
+ type InboxListRow
+} from './inbox-list.ts';
+import {
+ captureMessageMetadata,
+ messageMetadataSnapshot,
+ type MessageMetadata
+} from '../persistence/message-metadata.ts';
+import {
+ captureConversationDirectory,
+ rememberAdmittedConversation,
+ closeConversationDirectory,
+ type ConversationDirectory
+} from './conversation-directory.ts';
+import {
+ conversationSnapshot,
+ type AdmittedConversation
+} from './admit-conversation.ts';
+import { decryptionQueueConversations } from './decryption-queue.ts';
+import {
+ captureOlderInbox,
+ loadOlderInbox,
+ stopOlderInbox,
+ olderInboxSnapshot,
+ type OlderInbox
+} from './history-pagination.ts';
import {
identityMessagingOwnership,
identitySessionSnapshot,
@@ -33,6 +62,7 @@ import {
captureUnlockedSession,
closeUnlockedSession,
readUnlockedMessages,
+ unlockedConversationCurrent,
type UnlockedSession
} from './unlocked-session.ts';
import {
@@ -71,6 +101,12 @@ type Inputs = Readonly<{ identity: IdentitySession; setup: InboxSetupView }>;
type Controller = {
snapshot(): InboxViewSnapshot;
setup(): InboxSetupView | undefined;
+ list(): InboxListSnapshot;
+ row(peer: unknown): InboxListRow | undefined;
+ revision(): number;
+ open(peer: unknown, review: unknown): Promise<string | undefined>;
+ older(review: unknown): Promise<boolean>;
+ olderAvailable(): boolean;
subscribe(listener: (view: InboxViewSnapshot) => void): () => void;
unlock(review: unknown): Promise<boolean>;
check(review: unknown): Promise<boolean>;
@@ -118,6 +154,16 @@ export function createInboxView(input: Inputs): InboxView | undefined {
unlocked: UnlockedSession | undefined,
queue: DecryptionQueue | undefined,
sync: InboxSync | undefined;
+ let metadata: MessageMetadata | undefined,
+ directory: ConversationDirectory | undefined,
+ older: OlderInbox | undefined;
+ let list: InboxListSnapshot = groupInboxMessages('', [], []);
+ let listReason: string | null = null;
+ let listRevision = 0;
+ const rowProofs = new Map<
+ string,
+ Readonly<{ data: InboxListRow; room: AdmittedConversation }>
+ >();
let off = () => {},
privateOff = () => {},
setupOff = () => {},
@@ -142,6 +188,186 @@ export function createInboxView(input: Inputs): InboxView | undefined {
current()
);
}
+ function rowSnapshot(peer: unknown): InboxListRow | undefined {
+ if (
+ typeof peer !== 'string' ||
+ !privateCurrent() ||
+ !unlocked ||
+ !queue ||
+ list.status !== 'ready'
+ )
+ return;
+ const proof = rowProofs.get(peer);
+ if (!proof || !unlockedConversationCurrent(unlocked, proof.room)) return;
+ const actual = conversationSnapshot(proof.room);
+ if (
+ !actual ||
+ actual.owner !== capture.owner ||
+ actual.peer !== peer ||
+ actual.rumorId !== proof.data.latest.rumorId
+ )
+ return;
+ return { ...proof.data, latest: { ...actual } };
+ }
+ function listSnapshot(): InboxListSnapshot {
+ if (!privateCurrent() || !unlocked || !queue)
+ return { status: 'locked', requests: [], conversations: [] };
+ if (list.status !== 'ready')
+ return { status: list.status, requests: [], conversations: [] };
+ const requests = list.requests.map((row) => rowSnapshot(row.peer)),
+ conversations = list.conversations.map((row) => rowSnapshot(row.peer));
+ if (requests.some((row) => !row) || conversations.some((row) => !row))
+ return { status: 'unavailable', requests: [], conversations: [] };
+ return {
+ status: 'ready',
+ requests: requests.filter((row) => row !== undefined),
+ conversations: conversations.filter((row) => row !== undefined)
+ };
+ }
+ async function refreshList(generation = epoch) {
+ if (!privateCurrent() || !unlocked || !metadata) return false;
+ try {
+ const local = await messageMetadataSnapshot(metadata);
+ if (!current(generation) || !privateCurrent() || !unlocked) return false;
+ const cached = readUnlockedMessages(unlocked);
+ if (
+ local.status !== 'ready' ||
+ local.owner !== capture.owner ||
+ cached.status !== 'ready'
+ ) {
+ list = { status: 'unavailable', requests: [], conversations: [] };
+ rowProofs.clear();
+ listRevision++;
+ listReason = 'storage_unavailable';
+ return false;
+ }
+ list = groupInboxMessages(
+ capture.owner,
+ cached.messages,
+ local.readRumors
+ );
+ rowProofs.clear();
+ const rooms = queue && decryptionQueueConversations(queue),
+ byRumor = new Map<string, AdmittedConversation>();
+ for (const room of rooms ?? []) {
+ const observed = conversationSnapshot(room);
+ if (observed) byRumor.set(observed.rumorId, room);
+ }
+ for (const row of list.requests.concat(list.conversations)) {
+ const room = byRumor.get(row.latest.rumorId);
+ if (room) rowProofs.set(row.peer, { data: row, room });
+ }
+ listRevision++;
+ listReason = list.status === 'ready' ? null : 'unavailable';
+ return list.status === 'ready';
+ } catch {
+ if (current(generation) && privateCurrent()) {
+ list = { status: 'unavailable', requests: [], conversations: [] };
+ rowProofs.clear();
+ listRevision++;
+ listReason = 'storage_unavailable';
+ }
+ return false;
+ }
+ }
+ function olderAvailable() {
+ if (busy || !privateCurrent() || !unlocked || !repository || !sync)
+ return false;
+ const transport = inboxSyncSnapshot(sync),
+ ownership = inboxSyncHistoryOwnership(sync),
+ own = inboxSetupViewOwnership(input.setup),
+ original = session && privateSessionOwnership(session);
+ if (
+ !own?.current() ||
+ !own.resolver ||
+ !original?.current() ||
+ !ownership?.current() ||
+ transport?.backfill !== 'complete' ||
+ transport.pending !== 0
+ )
+ return false;
+ return (
+ messagingReadinessSnapshot(
+ input.identity,
+ session,
+ own.policy,
+ own.resolver,
+ undefined,
+ own.observeAccess
+ ).ownAccess === 'qualified_exercised'
+ );
+ }
+ async function open(peer: unknown, review: unknown) {
+ if (
+ review !== 'reviewed_admitted_conversation_navigation' ||
+ busy ||
+ !privateCurrent() ||
+ !queue ||
+ !directory ||
+ !canonicalPublicKey(peer)
+ )
+ return;
+ const room = decryptionQueueConversations(queue).find(
+ (value) => conversationSnapshot(value)?.peer === peer
+ );
+ if (!room) return;
+ const generation = epoch;
+ busy = true;
+ notify();
+ try {
+ const result = await rememberAdmittedConversation(
+ directory,
+ room,
+ review
+ );
+ if (!current(generation) || !privateCurrent()) return;
+ if (result.status !== 'saved' && result.status !== 'existing') {
+ reason = 'unavailable';
+ return;
+ }
+ await refreshList(generation);
+ if (!current(generation) || !privateCurrent()) return;
+ return '/messages/' + result.conversationId;
+ } catch {
+ if (current(generation)) reason = 'unavailable';
+ return;
+ } finally {
+ if (current(generation)) {
+ busy = false;
+ notify();
+ }
+ }
+ }
+ async function loadOlder(review: unknown) {
+ if (
+ review !== 'reviewed_load_older' ||
+ !olderAvailable() ||
+ !sync ||
+ !queue
+ )
+ return false;
+ older ??= captureOlderInbox(sync, review);
+ if (!older) return false;
+ const generation = epoch;
+ busy = true;
+ notify();
+ try {
+ const result = await loadOlderInbox(older, review);
+ if (!current(generation) || !privateCurrent() || !queue) return false;
+ await refreshDecryptionQueue(queue);
+ if (!current(generation) || !privateCurrent()) return false;
+ await refreshList(generation);
+ return current(generation) && privateCurrent() && result;
+ } catch {
+ if (current(generation)) reason = 'unavailable';
+ return false;
+ } finally {
+ if (current(generation)) {
+ busy = false;
+ notify();
+ }
+ }
+ }
function snapshot(): InboxViewSnapshot {
if (!current())
return { ...unavailable(), cleanupRequired: pendingCleanup.length > 0 };
@@ -167,6 +393,7 @@ export function createInboxView(input: Inputs): InboxView | undefined {
};
const cached = readUnlockedMessages(unlocked),
decrypt = decryptionQueueSnapshot(queue),
+ paging = older && olderInboxSnapshot(older),
transport = sync && inboxSyncSnapshot(sync);
const scope = inboxSetupViewOwnership(input.setup);
const exercised =
@@ -184,6 +411,8 @@ export function createInboxView(input: Inputs): InboxView | undefined {
reason !== null ||
!exercised ||
cached.status !== 'ready' ||
+ list.status === 'unavailable' ||
+ !!paging?.reason ||
decrypt.state === 'paused' ||
transport?.state === 'needs_action' ||
transport?.state === 'stopped';
@@ -200,6 +429,8 @@ export function createInboxView(input: Inputs): InboxView | undefined {
: 'ready',
reason:
reason ??
+ listReason ??
+ paging?.reason ??
decrypt.reason ??
transport?.reason ??
(!exercised ? 'access_unavailable' : null),
@@ -228,9 +459,17 @@ export function createInboxView(input: Inputs): InboxView | undefined {
originalSync = sync,
originalUnlocked = unlocked,
originalSession = session,
- originalDatabase = database;
+ originalDatabase = database,
+ originalDirectory = directory,
+ originalOlder = older;
const tasks = pendingCleanup.concat([
() => {
+ if (originalOlder) stopOlderInbox(originalOlder);
+ },
+ () => {
+ if (originalDirectory) closeConversationDirectory(originalDirectory);
+ },
+ () => {
if (originalQueue) stopDecryptionQueue(originalQueue);
},
() => {
@@ -255,6 +494,13 @@ export function createInboxView(input: Inputs): InboxView | undefined {
pendingCleanup = pendingCleanup.concat(cleanup);
}
if (pendingCleanup.length > 0) reason = 'cleanup_required';
+ metadata = undefined;
+ directory = undefined;
+ older = undefined;
+ list = { status: 'locked', requests: [], conversations: [] };
+ listReason = null;
+ rowProofs.clear();
+ listRevision++;
queue = undefined;
sync = undefined;
unlocked = undefined;
@@ -346,7 +592,8 @@ export function createInboxView(input: Inputs): InboxView | undefined {
try {
const result = await runDecryptionBatch(queue, reviewed);
if (!current(generation) || !privateCurrent()) return false;
- return result;
+ await refreshList(generation);
+ return current(generation) && privateCurrent() && result;
} finally {
if (current(generation)) {
busy = false;
@@ -410,10 +657,27 @@ export function createInboxView(input: Inputs): InboxView | undefined {
unlocked,
'reviewed_inbox_unlock'
);
- if (!queue) {
+ if (!queue || !unlocked) {
reason = 'unavailable';
return false;
}
+ metadata = captureMessageMetadata(
+ database,
+ session,
+ unlocked,
+ 'reviewed_local_message_metadata'
+ );
+ directory =
+ metadata &&
+ captureConversationDirectory(
+ session,
+ metadata,
+ 'reviewed_conversation_directory'
+ );
+ if (!metadata || !directory) {
+ reason = 'storage_unavailable';
+ return false;
+ }
privateOff = subscribePrivateSessionClose(session, () => {
epoch++;
releasePrivate();
@@ -428,7 +692,8 @@ export function createInboxView(input: Inputs): InboxView | undefined {
if (!privateCurrent()) return false;
const result = await runDecryptionBatch(queue, 'reviewed_decrypt_batch');
if (!current(generation) || !privateCurrent()) return false;
- return result;
+ await refreshList(generation);
+ return current(generation) && privateCurrent() && result;
} catch {
if (current(generation)) reason = 'unavailable';
return false;
@@ -455,6 +720,7 @@ export function createInboxView(input: Inputs): InboxView | undefined {
notify();
return false;
}
+ const generation = epoch;
reason = null;
if (sync) {
if (
@@ -487,10 +753,17 @@ export function createInboxView(input: Inputs): InboxView | undefined {
checkPending = true;
notify();
await sample();
- return privateCurrent();
+ if (current(generation) && privateCurrent()) await refreshList(generation);
+ return current(generation) && privateCurrent();
}
views.set(token, {
snapshot,
+ list: listSnapshot,
+ row: rowSnapshot,
+ revision: () => (privateCurrent() ? listRevision : -1),
+ open,
+ older: loadOlder,
+ olderAvailable,
setup: () => (current() ? input.setup : undefined),
subscribe(listener) {
const key = Symbol();
@@ -585,3 +858,43 @@ export function stopInboxView(token: InboxView): void {
export function closeInboxView(token: InboxView): boolean {
return views.get(token)?.close() ?? true;
}
+
+// Fresh genuine original cache observation. Returned rows are detached and
+// never replace the original room/native authority used by explicit Open.
+export function inboxListSnapshot(
+ token: InboxView | undefined
+): InboxListSnapshot {
+ return (
+ (token && views.get(token)?.list()) || {
+ status: 'unavailable',
+ requests: [],
+ conversations: []
+ }
+ );
+}
+export function openInboxConversation(
+ token: InboxView,
+ peer: unknown,
+ review: unknown
+): Promise<string | undefined> {
+ return views.get(token)?.open(peer, review) ?? Promise.resolve(undefined);
+}
+export function loadOlderInboxView(
+ token: InboxView,
+ review: unknown
+): Promise<boolean> {
+ return views.get(token)?.older(review) ?? Promise.resolve(false);
+}
+export function inboxViewOlderAvailable(token: InboxView | undefined): boolean {
+ return !!token && !!views.get(token)?.olderAvailable();
+}
+
+export function inboxConversationRow(
+ token: InboxView | undefined,
+ peer: unknown
+): InboxListRow | undefined {
+ return token ? views.get(token)?.row(peer) : undefined;
+}
+export function inboxListRevision(token: InboxView | undefined): number {
+ return token ? (views.get(token)?.revision() ?? -1) : -1;
+}
diff --git a/web/tests/e2e/harness/inbox-list-panel.svelte b/web/tests/e2e/harness/inbox-list-panel.svelte
@@ -0,0 +1,7 @@
+<script lang="ts">
+ import InboxStatus from '../../../src/lib/components/InboxStatus.svelte';
+ import type { InboxView } from '../../../src/lib/messaging/inbox-view.ts';
+ let { controller }: { controller: InboxView } = $props();
+</script>
+
+<InboxStatus {controller} />
diff --git a/web/tests/e2e/harness/inbox-list.ts b/web/tests/e2e/harness/inbox-list.ts
@@ -0,0 +1,228 @@
+import { mount, unmount } from 'svelte';
+import Panel from './inbox-list-panel.svelte';
+import { makeFixture as makeMetadataFixture } from './message-metadata.ts';
+import {
+ createInboxSetupView,
+ checkInboxSetupView,
+ closeInboxSetupView
+} from '../../../src/lib/messaging/inbox-setup-view.ts';
+import {
+ createInboxView,
+ inboxViewSnapshot,
+ inboxListSnapshot,
+ unlockInboxView,
+ readNewInboxView,
+ checkInboxView,
+ loadOlderInboxView,
+ openInboxConversation,
+ stopInboxView,
+ closeInboxView
+} from '../../../src/lib/messaging/inbox-view.ts';
+import { identityMessagingOwnership } from '../../../src/lib/runtime/identity-session.ts';
+import {
+ readRelayPolicy,
+ validateRelayPolicy
+} from '../../../src/lib/config/relays.ts';
+import {
+ openBrowserDatabase,
+ closeBrowserDatabase,
+ browserDatabaseTransaction
+} from '../../../src/lib/persistence/database.ts';
+import {
+ admitInboxEnvelope,
+ retainInboxEnvelope
+} from '../../../src/lib/persistence/inbox-envelope-repository.ts';
+import { finalizeEvent } from 'applesauce-core/helpers';
+import { nip44 } from 'applesauce-core/helpers/encryption';
+let navigations = Array.from<string>([]);
+// Harness-only alias for Kit navigation. Production retains actual Kit goto.
+export function goto(href: string) {
+ navigations.push(href);
+ return Promise.resolve();
+}
+export async function renderFixture(
+ kind: 'inbound' | 'self_archive' | 'hostile_text' = 'inbound',
+ qualified = false,
+ variant: 'single' | 'duplicate' | 'mixed' = 'single'
+) {
+ const f = await makeMetadataFixture(kind);
+ const original = identityMessagingOwnership(f.identity);
+ if (!original) throw Error('no original identity');
+ if (variant === 'duplicate') await f.anotherWrap(false);
+ if (variant === 'mixed') {
+ const record = (await f.row())!.record;
+ const envelope = admitInboxEnvelope(
+ record.self.wire,
+ f.owner,
+ 'wss://archive.example.org',
+ 102
+ );
+ const session = f.navigationInputs().privateSession;
+ if (
+ !envelope ||
+ (await retainInboxEnvelope(f.repository, session, envelope)).status !==
+ 'retained'
+ )
+ throw Error('no actual self archive');
+ }
+ async function native() {
+ const opened = await openBrowserDatabase();
+ if (opened.state !== 'ready') throw Error('no actual DB');
+ try {
+ const tx = browserDatabaseTransaction(
+ opened.owner,
+ ['received_envelopes', 'conversations'],
+ 'readonly'
+ ),
+ received = tx.objectStore('received_envelopes').getAll(),
+ pairs = tx.objectStore('conversations').getAll();
+ return await new Promise<{ received: unknown[]; pairs: unknown[] }>(
+ (resolve, reject) => {
+ tx.addEventListener('complete', () =>
+ resolve({ received: received.result, pairs: pairs.result })
+ );
+ tx.addEventListener('abort', () => reject(Error('scan aborted')));
+ }
+ );
+ } finally {
+ closeBrowserDatabase(opened.owner);
+ }
+ }
+ const initial = await native(),
+ raw = initial.received[0] as { wire: string },
+ record = JSON.parse(raw.wire) as { outer: string };
+ // Produce a relay-only valid old outer with the same authenticated signed seal.
+ // Both timestamps are set before signing. Nothing signed is edited afterward.
+ const outer = JSON.parse(record.outer) as {
+ pubkey: string;
+ content: string;
+ created_at: number;
+ };
+ const ownerSecret = new Uint8Array(32).fill(83),
+ outerSecret = new Uint8Array(32).fill(86);
+ let olderWire: string;
+ try {
+ const decryptKey = nip44.v2.utils.getConversationKey(
+ ownerSecret,
+ outer.pubkey
+ );
+ let seal: string;
+ try {
+ seal = nip44.v2.decrypt(outer.content, decryptKey);
+ } finally {
+ decryptKey.fill(0);
+ }
+ const encryptKey = nip44.v2.utils.getConversationKey(outerSecret, f.owner);
+ let content: string;
+ try {
+ content = nip44.v2.encrypt(seal, encryptKey);
+ } finally {
+ encryptKey.fill(0);
+ }
+ olderWire = JSON.stringify(
+ finalizeEvent(
+ {
+ kind: 1059,
+ created_at: outer.created_at - 120,
+ tags: [['p', f.owner]],
+ content
+ },
+ outerSecret
+ )
+ );
+ } finally {
+ ownerSecret.fill(0);
+ outerSecret.fill(0);
+ }
+ const policy = validateRelayPolicy(
+ JSON.stringify({
+ ...readRelayPolicy(f.context.policy),
+ messagingEnabled: true
+ })
+ );
+ if (!policy) throw Error('no policy');
+ let access = true;
+ const setup = createInboxSetupView({
+ identity: f.identity,
+ policy,
+ lookup: () => Promise.resolve(f.context.own),
+ observeAccess: qualified
+ ? (context) => ({
+ ...context,
+ receive: 'qualified_exercised',
+ archive: 'qualified_exercised',
+ current: () => access && original.current()
+ })
+ : undefined
+ });
+ if (!setup) throw Error('no setup');
+ const controller = createInboxView({ identity: f.identity, setup });
+ if (!controller) throw Error('no original page');
+ const target = document.createElement('div');
+ document.body.append(target);
+ const mounted = mount(Panel, { target, props: { controller } });
+ navigations = [];
+ const baseline = f.counts();
+ return {
+ controller,
+ owner: f.owner,
+ peer: f.peer,
+ rumorId: f.rumorId,
+ olderWire,
+ native,
+ snapshot: () => inboxViewSnapshot(controller),
+ list: () => inboxListSnapshot(controller),
+ navigations: () => navigations.slice(),
+ checkSetup: () => checkInboxSetupView(setup),
+ unlock: () => unlockInboxView(controller, 'reviewed_messages_unlock'),
+ next: () => readNewInboxView(controller, 'reviewed_decrypt_batch'),
+ check: () => checkInboxView(controller, 'reviewed_foreground_inbox'),
+ older: (review: unknown = 'reviewed_load_older') =>
+ loadOlderInboxView(controller, review),
+ open: (
+ peer: unknown = f.peer,
+ review: unknown = 'reviewed_admitted_conversation_navigation'
+ ) => openInboxConversation(controller, peer, review),
+ delta: () => ({
+ decrypts: f.counts().decrypts - baseline.decrypts,
+ signs: f.counts().signs - baseline.signs,
+ encrypts: f.counts().encrypts - baseline.encrypts
+ }),
+ copied: async () => ({
+ list: inboxListSnapshot({ ...controller }),
+ open: await openInboxConversation(
+ { ...controller },
+ f.peer,
+ 'reviewed_admitted_conversation_navigation'
+ ),
+ older: await loadOlderInboxView({ ...controller }, 'reviewed_load_older')
+ }),
+ async markRead() {
+ if (
+ (await f.unlock()) !== 'authenticated' ||
+ !f.admit(kind === 'self_archive' ? 'self_archive' : 'inbound') ||
+ !f.captureCache()
+ )
+ throw Error('no genuine explicit read proof');
+ f.cache();
+ if (!(await f.captureMetadata())) throw Error('no original metadata');
+ return await f.display();
+ },
+ stop: () => stopInboxView(controller),
+ logout: () => f.disconnect(),
+ mode: f.mode,
+ settle: () => f.settle(),
+ pending: () => f.pending(),
+ revokeAccess: () => {
+ access = false;
+ },
+ async close() {
+ f.settle();
+ closeInboxView(controller);
+ closeInboxSetupView(setup);
+ await unmount(mounted);
+ f.close();
+ target.remove();
+ }
+ };
+}
diff --git a/web/tests/e2e/harness/inbox-view.ts b/web/tests/e2e/harness/inbox-view.ts
@@ -172,3 +172,9 @@ export async function renderSetupFixture(
}
};
}
+
+// This original standalone fixture does not exercise navigation. Any SSR or
+// mounted regression action that attempts it must fail rather than succeed.
+export function goto(): never {
+ throw new Error('HCP101 standalone harness must not navigate');
+}
diff --git a/web/tests/e2e/inbox-list.spec.ts b/web/tests/e2e/inbox-list.spec.ts
@@ -0,0 +1,452 @@
+import { test, expect } from '@playwright/test';
+import { build } from 'vite';
+import { svelte } from '@sveltejs/vite-plugin-svelte';
+import { fileURLToPath } from 'node:url';
+import { once } from 'node:events';
+import { WebSocketServer } from 'ws';
+import { createStaticHarness } from '../integration/harness/static.ts';
+import type * as Fixture from './harness/inbox-list.ts';
+declare global {
+ interface Window {
+ hcp102: typeof Fixture;
+ hcp102Fixture: Awaited<ReturnType<typeof Fixture.renderFixture>>;
+ hcp102Pending?: Promise<boolean>;
+ }
+}
+let server: Awaited<ReturnType<typeof createStaticHarness>>,
+ sockets: WebSocketServer,
+ endpoint: string,
+ bundle: string;
+let requests: unknown[][] = [],
+ events: unknown[][] = [],
+ closes: unknown[][] = [],
+ olderEvent: unknown;
+test.beforeAll(async () => {
+ server = await createStaticHarness();
+ sockets = new WebSocketServer({
+ host: '127.0.0.1',
+ port: 0,
+ maxPayload: 65536
+ });
+ await once(sockets, 'listening');
+ const address = sockets.address();
+ if (!address || typeof address === 'string') throw Error('no loopback');
+ endpoint = 'ws://127.0.0.1:' + address.port;
+ sockets.on('connection', (socket) =>
+ socket.on('message', (bytes) => {
+ const raw = Buffer.isBuffer(bytes)
+ ? bytes
+ : Array.isArray(bytes)
+ ? Buffer.concat(bytes)
+ : Buffer.from(bytes);
+ const frame = JSON.parse(raw.toString()) as unknown[];
+ if (frame[0] === 'EVENT') events.push(frame);
+ if (frame[0] === 'CLOSE') closes.push(frame);
+ if (frame[0] === 'REQ') {
+ requests.push(frame);
+ const filter = frame[2] as Record<string, unknown>;
+ if (filter.limit !== 0) {
+ if (filter.until !== undefined && olderEvent)
+ socket.send(JSON.stringify(['EVENT', frame[1], olderEvent]));
+ socket.send(JSON.stringify(['EOSE', frame[1]]));
+ }
+ }
+ })
+ );
+ const result = await build({
+ configFile: false,
+ logLevel: 'silent',
+ plugins: [svelte({ configFile: false })],
+ resolve: {
+ conditions: ['browser'],
+ alias: {
+ '$app/navigation': fileURLToPath(
+ new URL('./harness/inbox-list.ts', import.meta.url)
+ )
+ }
+ },
+ build: {
+ write: false,
+ minify: false,
+ lib: {
+ entry: fileURLToPath(
+ new URL('./harness/inbox-list.ts', import.meta.url)
+ ),
+ name: 'hcp102',
+ formats: ['iife']
+ }
+ }
+ });
+ const output = Array.isArray(result) ? result[0] : result;
+ if (!('output' in output)) throw Error('no bundle');
+ const chunks = output.output.filter((row) => row.type === 'chunk');
+ expect(chunks).toHaveLength(1);
+ bundle = chunks[0].code;
+});
+test.afterAll(async () => {
+ for (const socket of sockets.clients) socket.terminate();
+ await new Promise<void>((resolve) => sockets.close(() => resolve()));
+ await server.close();
+});
+test.beforeEach(async ({ page }) => {
+ requests = [];
+ events = [];
+ closes = [];
+ olderEvent = undefined;
+ await page.addInitScript(
+ ({ endpoint }) => {
+ const Native = window.WebSocket;
+ window.WebSocket = class extends Native {
+ constructor(url: string | URL, protocols?: string | string[]) {
+ if (
+ ![
+ 'wss://archive.example.org',
+ 'wss://discovery.example.org'
+ ].includes(new URL(String(url)).origin)
+ )
+ throw Error('unapproved destination');
+ super(endpoint, protocols);
+ }
+ };
+ },
+ { endpoint }
+ );
+ await page.goto(server.url + '/search');
+ await page.addScriptTag({ content: bundle });
+});
+test.afterEach(async ({ page }) => {
+ if (!page.isClosed())
+ await page.evaluate(async () => {
+ window.hcp102Fixture?.settle();
+ await window.hcp102Pending;
+ await window.hcp102Fixture?.close();
+ });
+});
+async function ready(
+ page: import('@playwright/test').Page,
+ kind: 'inbound' | 'self_archive' | 'hostile_text' = 'inbound',
+ qualified = false,
+ variant: 'single' | 'duplicate' | 'mixed' = 'single'
+) {
+ await page.evaluate(
+ async ({ kind, qualified, variant }) => {
+ window.hcp102Fixture = await window.hcp102.renderFixture(
+ kind,
+ qualified,
+ variant
+ );
+ },
+ { kind, qualified, variant }
+ );
+ await page.getByRole('button', { name: 'Check current preference' }).click();
+}
+async function unlock(page: import('@playwright/test').Page) {
+ await page
+ .getByRole('button', { name: 'Unlock messages', exact: true })
+ .click();
+ await expect
+ .poll(() => page.evaluate(() => window.hcp102Fixture.list().status))
+ .toBe('ready');
+}
+test('production guest never renders request previews or background notification fiction', async ({
+ page
+}) => {
+ await page.goto(server.url + '/messages');
+ await expect(
+ page.getByRole('heading', { name: 'Connect or unlock' })
+ ).toBeVisible();
+ await expect(
+ page.getByRole('heading', { name: 'Message requests' })
+ ).toHaveCount(0);
+ await expect(page.getByText('Actual encrypted room fixture')).toHaveCount(0);
+ expect(requests).toEqual([]);
+ expect(events).toEqual([]);
+});
+test('actual stored incoming ciphertext remains unpreviewed while original page is locked', async ({
+ page
+}) => {
+ await ready(page);
+ await expect(
+ page.getByRole('button', { name: 'Unlock messages', exact: true })
+ ).toBeVisible();
+ await expect(page.getByText('Actual encrypted room fixture')).toHaveCount(0);
+ await expect(
+ page.getByRole('heading', { name: 'Message requests' })
+ ).toHaveCount(0);
+ expect(await page.evaluate(() => window.hcp102Fixture.delta())).toMatchObject(
+ { decrypts: 0, signs: 0, encrypts: 0 }
+ );
+ expect(requests).toEqual([]);
+});
+test('genuine authenticated incoming peer is one locally New request after explicit SDK decrypt', async ({
+ page
+}) => {
+ await ready(page);
+ await unlock(page);
+ await expect(
+ page.getByRole('heading', { name: 'Message requests', exact: true })
+ ).toBeVisible();
+ await expect(
+ page.getByRole('heading', { name: 'Conversations', exact: true })
+ ).toHaveCount(0);
+ await expect(
+ page.getByText('Actual encrypted room fixture', { exact: true })
+ ).toBeVisible();
+ await expect(page.getByText('New', { exact: true })).toHaveCount(1);
+ const view = await page.evaluate(() => window.hcp102Fixture.list());
+ expect(view.requests).toHaveLength(1);
+ expect(view.requests[0].peer).toBe(
+ await page.evaluate(() => window.hcp102Fixture.peer)
+ );
+ expect(await page.evaluate(() => window.hcp102Fixture.delta())).toMatchObject(
+ { decrypts: 2, signs: 0, encrypts: 0 }
+ );
+ expect(requests).toEqual([]);
+});
+test('genuine self archive is a local conversation without outgoing New or empty request clutter', async ({
+ page
+}) => {
+ await ready(page, 'self_archive');
+ await unlock(page);
+ await expect(
+ page.getByRole('heading', { name: 'Conversations', exact: true })
+ ).toBeVisible();
+ await expect(
+ page.getByRole('heading', { name: 'Message requests', exact: true })
+ ).toHaveCount(0);
+ await expect(page.getByText('New', { exact: true })).toHaveCount(0);
+ await expect(
+ page.getByText('You: Actual encrypted room fixture', { exact: true })
+ ).toBeVisible();
+ expect(
+ (await page.evaluate(() => window.hcp102Fixture.list())).conversations
+ ).toHaveLength(1);
+ expect(events).toEqual([]);
+});
+test('one authenticated pair with incoming and self archive stays one local conversation', async ({
+ page
+}) => {
+ await ready(page, 'inbound', false, 'mixed');
+ await unlock(page);
+ const view = await page.evaluate(() => window.hcp102Fixture.list());
+ expect(view.requests).toEqual([]);
+ expect(view.conversations).toHaveLength(1);
+ expect(view.conversations[0]).toMatchObject({ count: 2, unread: 1 });
+ await expect(page.getByText('New', { exact: true })).toHaveCount(1);
+ expect(events).toEqual([]);
+ expect(requests).toEqual([]);
+});
+test('two actual different outer wraps of one rumor produce one request and one local New', async ({
+ page
+}) => {
+ await ready(page, 'inbound', false, 'duplicate');
+ await unlock(page);
+ const view = await page.evaluate(() => window.hcp102Fixture.list());
+ expect(view.requests).toHaveLength(1);
+ expect(view.requests[0]).toMatchObject({ count: 1, unread: 1 });
+ expect(
+ (await page.evaluate(() => window.hcp102Fixture.native())).received
+ ).toHaveLength(2);
+ expect(await page.evaluate(() => window.hcp102Fixture.delta())).toMatchObject(
+ { decrypts: 4 }
+ );
+ await expect(page.getByText('New', { exact: true })).toHaveCount(1);
+});
+test('actual original local read flag suppresses New without changing request acceptance or notifying a peer', async ({
+ page
+}) => {
+ await ready(page);
+ await unlock(page);
+ await expect(page.getByText('New', { exact: true })).toHaveCount(1);
+ const saved = await page.evaluate(() => window.hcp102Fixture.markRead());
+ expect(saved?.status).toBe('saved');
+ await page.evaluate(() => window.hcp102Fixture.next());
+ await expect(page.getByText('New', { exact: true })).toHaveCount(0);
+ expect(
+ (await page.evaluate(() => window.hcp102Fixture.list())).requests
+ ).toHaveLength(1);
+ expect(events).toEqual([]);
+ expect(requests).toEqual([]);
+});
+test('explicit original row mapping returns opaque local UUID and does not mark read or persist plaintext', async ({
+ page
+}) => {
+ await ready(page);
+ await unlock(page);
+ const before = await page.evaluate(() => window.hcp102Fixture.native());
+ expect(before.pairs).toEqual([]);
+ await page.getByRole('button', { name: /Open conversation/ }).click();
+ await expect
+ .poll(() => page.evaluate(() => window.hcp102Fixture.navigations().length))
+ .toBe(1);
+ const href = await page.evaluate(() => window.hcp102Fixture.navigations()[0]);
+ expect(href).toMatch(
+ /^\/messages\/[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/
+ );
+ const after = await page.evaluate(() => window.hcp102Fixture.native());
+ expect(after.pairs).toHaveLength(1);
+ expect(after.received).toEqual(before.received);
+ expect(JSON.stringify(after)).not.toContain('Actual encrypted room fixture');
+ await expect(page.getByText('New', { exact: true })).toHaveCount(1);
+ expect(events).toEqual([]);
+ expect(requests).toEqual([]);
+});
+test('copied page and scalar peer arguments cannot import rows or native mapping/history effects', async ({
+ page
+}) => {
+ await ready(page);
+ await unlock(page);
+ const before = await page.evaluate(() => window.hcp102Fixture.native()),
+ delta = await page.evaluate(() => window.hcp102Fixture.delta()),
+ copied = await page.evaluate(() => window.hcp102Fixture.copied());
+ expect(copied).toMatchObject({
+ list: { status: 'unavailable', requests: [], conversations: [] },
+ older: false
+ });
+ expect(copied.open).toBeUndefined();
+ expect(await page.evaluate(() => window.hcp102Fixture.native())).toEqual(
+ before
+ );
+ expect(await page.evaluate(() => window.hcp102Fixture.delta())).toEqual(
+ delta
+ );
+ expect(requests).toEqual([]);
+ expect(events).toEqual([]);
+});
+test('Stop removes decrypted rows and denies stale original row action before any native change', async ({
+ page
+}) => {
+ await ready(page);
+ await unlock(page);
+ const before = await page.evaluate(() => window.hcp102Fixture.native());
+ await page
+ .getByRole('button', { name: 'Lock messages', exact: true })
+ .click();
+ await expect(page.getByText('Actual encrypted room fixture')).toHaveCount(0);
+ await expect(page.getByText('New', { exact: true })).toHaveCount(0);
+ expect(
+ await page.evaluate(() => window.hcp102Fixture.open())
+ ).toBeUndefined();
+ expect(await page.evaluate(() => window.hcp102Fixture.native())).toEqual(
+ before
+ );
+ expect(requests).toEqual([]);
+ expect(events).toEqual([]);
+});
+test('logout during actual held decrypt cannot render old-generation previews after SDK settlement', async ({
+ page
+}) => {
+ await ready(page);
+ await page.evaluate(() => {
+ window.hcp102Fixture.mode('hold_decrypt');
+ window.hcp102Pending = window.hcp102Fixture.unlock();
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.hcp102Fixture.pending()))
+ .toBe(true);
+ await page.evaluate(() => window.hcp102Fixture.logout());
+ await expect(page.getByText('Actual encrypted room fixture')).toHaveCount(0);
+ await page.evaluate(async () => {
+ window.hcp102Fixture.settle();
+ await window.hcp102Pending;
+ });
+ await expect(page.getByText('Actual encrypted room fixture')).toHaveCount(0);
+ expect(
+ (await page.evaluate(() => window.hcp102Fixture.list())).requests
+ ).toEqual([]);
+ expect(events).toEqual([]);
+ expect(requests).toEqual([]);
+});
+test('partial unlocked local list has visible limitations and never remote Seen or a live badge', async ({
+ page
+}) => {
+ await ready(page, 'hostile_text');
+ await unlock(page);
+ await expect(
+ page.getByText(
+ 'Inbox access has not been qualified and exercised. Unlocked local copies do not prove a successful relay check.',
+ { exact: true }
+ )
+ ).toBeVisible();
+ await expect(page.getByText(/https:\/\/untrusted.example.org/)).toBeVisible();
+ await expect(page.locator('a[href*="untrusted.example.org"]')).toHaveCount(0);
+ await expect(
+ page.getByText(/^(Live|Seen|Read by|Order accepted)$/)
+ ).toHaveCount(0);
+ await expect(
+ page.getByRole('heading', { name: 'Conversations', exact: true })
+ ).toHaveCount(0);
+ expect(events).toEqual([]);
+ expect(requests).toEqual([]);
+});
+test('unqualified original Load older stays unavailable without private REQ or SDK work', async ({
+ page
+}) => {
+ await ready(page);
+ await unlock(page);
+ const before = await page.evaluate(() => window.hcp102Fixture.delta());
+ expect(await page.evaluate(() => window.hcp102Fixture.older())).toBe(false);
+ expect(await page.evaluate(() => window.hcp102Fixture.delta())).toEqual(
+ before
+ );
+ expect(events).toEqual([]);
+ expect(requests).toEqual([]);
+});
+test('qualified explicit Load older uses original outer cursor and retains a real relay-only cipher without automatic decrypt', async ({
+ page
+}) => {
+ await ready(page, 'inbound', true);
+ await unlock(page);
+ await page
+ .getByRole('button', { name: 'Check for messages', exact: true })
+ .click();
+ await expect.poll(() => requests.length).toBe(3);
+ await expect
+ .poll(() =>
+ page.evaluate(() => window.hcp102Fixture.snapshot().lastCheckedAt)
+ )
+ .not.toBeNull();
+ const before = await page.evaluate(() => window.hcp102Fixture.native()),
+ delta = await page.evaluate(() => window.hcp102Fixture.delta());
+ olderEvent = JSON.parse(
+ await page.evaluate(() => window.hcp102Fixture.olderWire)
+ );
+ await page
+ .getByRole('button', { name: 'Load older messages', exact: true })
+ .click();
+ await expect.poll(() => requests.length).toBe(4);
+ const filter = requests[3][2] as Record<string, unknown>;
+ expect(filter.limit).toBe(200);
+ expect(filter.until).toBe(1699999800);
+ await expect
+ .poll(() =>
+ page.evaluate(
+ async () => (await window.hcp102Fixture.native()).received.length
+ )
+ )
+ .toBe(before.received.length + 1);
+ expect(await page.evaluate(() => window.hcp102Fixture.delta())).toEqual(
+ delta
+ );
+ await expect(
+ page.getByRole('button', { name: 'Read new messages (1)', exact: true })
+ ).toBeVisible();
+ expect(
+ (await page.evaluate(() => window.hcp102Fixture.list())).requests
+ ).toHaveLength(1);
+ await page
+ .getByRole('button', { name: 'Read new messages (1)', exact: true })
+ .click();
+ await expect
+ .poll(() => page.evaluate(() => window.hcp102Fixture.delta().decrypts))
+ .toBe(delta.decrypts + 2);
+ expect(
+ (await page.evaluate(() => window.hcp102Fixture.list())).requests[0].count
+ ).toBe(1);
+ expect(events).toEqual([]);
+ expect(
+ requests.filter(
+ (frame) => (frame[2] as Record<string, unknown>).limit === 0
+ )
+ ).toHaveLength(1);
+});
diff --git a/web/tests/e2e/inbox-view.spec.ts b/web/tests/e2e/inbox-view.spec.ts
@@ -54,7 +54,14 @@ test.beforeAll(async () => {
configFile: false,
logLevel: 'silent',
plugins: [svelte({ configFile: false })],
- resolve: { conditions: ['browser'] },
+ resolve: {
+ conditions: ['browser'],
+ alias: {
+ '$app/navigation': fileURLToPath(
+ new URL('./harness/inbox-view.ts', import.meta.url)
+ )
+ }
+ },
build: {
write: false,
minify: false,
diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs
@@ -345,7 +345,9 @@ import { auditOutput } from '../../tools/check-output.mjs';
'src/lib/components/InboxStatus.svelte',
'src/lib/messaging/inbox-view.ts',
'src/lib/messaging/inbox-sync.ts',
- 'src/lib/messaging/decryption-queue.ts'
+ 'src/lib/messaging/decryption-queue.ts',
+ 'src/lib/components/ConversationRow.svelte',
+ 'src/lib/messaging/inbox-list.ts'
])
await check(
'linked inbox presentation requires exact owned source ' +
@@ -365,7 +367,7 @@ import { auditOutput } from '../../tools/check-output.mjs';
}
);
for (const mutation of [
- 'missing-unlocked',
+ 'missing-private-cache-directory',
'extra-private-edge',
'missing-private-edge',
'private-dynamic',
@@ -387,8 +389,9 @@ import { auditOutput } from '../../tools/check-output.mjs';
assert.ok(row);
return row;
};
- const [key, row] = find('unlocked-session');
- if (mutation === 'missing-unlocked') delete manifest[key];
+ const [key, row] = find('conversation-directory');
+ if (mutation === 'missing-private-cache-directory')
+ delete manifest[key];
if (mutation === 'extra-private-edge')
row.imports = row.imports.concat(find('references')[0]);
if (mutation === 'missing-private-edge')
@@ -404,6 +407,38 @@ import { auditOutput } from '../../tools/check-output.mjs';
}
);
+ for (const mutation of [
+ 'directory-missing-context',
+ 'directory-entry-role',
+ 'directory-duplicate-role'
+ ])
+ await check(
+ 'actual inbox list compiler rejects ' + mutation,
+ async (t) => {
+ const f = await fixture(t),
+ file = path.join(
+ f.web,
+ '.svelte-kit/output/client/.vite/manifest.json'
+ ),
+ manifest = JSON.parse(await readFile(file, 'utf8'));
+ const entry = Object.entries(manifest).find(
+ ([, row]) => row.name === 'conversation-directory'
+ );
+ assert.ok(entry);
+ const [, row] = entry;
+ if (mutation === 'directory-missing-context')
+ row.imports = row.imports.filter(
+ (/** @type {string} */ value) =>
+ manifest[value].name !== 'AccountGate'
+ );
+ if (mutation === 'directory-entry-role') row.isEntry = true;
+ if (mutation === 'directory-duplicate-role')
+ manifest['_forged_directory.js'] = { ...row };
+ await writeFile(file, JSON.stringify(manifest));
+ await assert.rejects(f.audit, /compiler|duplicate|inventory/);
+ }
+ );
+
for (const name of [
'components/InboxSetup.svelte',
'messaging/inbox-setup-view.ts',
diff --git a/web/tests/unit/inbox-list.test.ts b/web/tests/unit/inbox-list.test.ts
@@ -0,0 +1,117 @@
+import { test, expect } from 'vitest';
+import { getPublicKey } from 'applesauce-core/helpers';
+import { groupInboxMessages } from '../../src/lib/messaging/inbox-list.ts';
+import {
+ inboxListSnapshot,
+ openInboxConversation,
+ loadOlderInboxView,
+ type InboxView
+} from '../../src/lib/messaging/inbox-view.ts';
+import type { ConversationData } from '../../src/lib/messaging/admit-conversation.ts';
+const owner = getPublicKey(new Uint8Array(32).fill(83)),
+ peer = getPublicKey(new Uint8Array(32).fill(84)),
+ other = getPublicKey(new Uint8Array(32).fill(85));
+const message = (
+ id = '1'.repeat(64),
+ role: 'inbound' | 'self_archive' = 'inbound',
+ time = 1700000000,
+ content = 'Plain private fixture'
+): ConversationData => ({
+ owner,
+ peer,
+ sender: role === 'inbound' ? peer : owner,
+ recipient: role === 'inbound' ? owner : peer,
+ role,
+ rumorId: id,
+ createdAt: time,
+ content,
+ subject: null,
+ replyTo: null
+});
+test('authenticated incoming projection groups a new peer under local requests', () => {
+ const view = groupInboxMessages(owner, [message()], []);
+ expect(view.status).toBe('ready');
+ expect(view.requests).toHaveLength(1);
+ expect(view.conversations).toEqual([]);
+ expect(view.requests[0]).toMatchObject({ peer, count: 1, unread: 1 });
+});
+test('actual self-archive history makes one known pair without a required acceptance task', () => {
+ const view = groupInboxMessages(
+ owner,
+ [message(), message('2'.repeat(64), 'self_archive', 1700000001)],
+ []
+ );
+ expect(view.requests).toEqual([]);
+ expect(view.conversations).toHaveLength(1);
+ expect(view.conversations[0]).toMatchObject({ peer, count: 2, unread: 1 });
+ expect(view.conversations[0].latest.role).toBe('self_archive');
+});
+test('repeated wraps of the same verified rumor do not duplicate local New or rows', () => {
+ const view = groupInboxMessages(owner, [message(), message()], []);
+ expect(view.requests).toHaveLength(1);
+ expect(view.requests[0]).toMatchObject({ count: 1, unread: 1 });
+});
+test('read state is by verified rumor rather than signed timestamp or outgoing archive', () => {
+ const view = groupInboxMessages(
+ owner,
+ [
+ message('1'.repeat(64), 'inbound', 1),
+ message('2'.repeat(64), 'self_archive', 1700000002)
+ ],
+ ['1'.repeat(64)]
+ );
+ expect(view.conversations[0].unread).toBe(0);
+ expect(
+ groupInboxMessages(owner, [message('3'.repeat(64), 'inbound', 1)], [])
+ .requests[0].unread
+ ).toBe(1);
+});
+test('latest sender-time-text selection is deterministic and does not parse a body link', () => {
+ const body = '<script>private</script> https://untrusted.example.org';
+ const input = [
+ message('2'.repeat(64), 'inbound', 1700000000, body),
+ message('1'.repeat(64))
+ ];
+ const a = groupInboxMessages(owner, input, []),
+ b = groupInboxMessages(owner, input.slice().reverse(), []);
+ expect(a).toEqual(b);
+ expect(a.requests[0].latest.content).toBe(body);
+ expect(a.requests[0].latest.rumorId).toBe('2'.repeat(64));
+});
+test('invalid or foreign detached rows cannot enter an owner projection', () => {
+ for (const row of [
+ { ...message(), owner: other },
+ { ...message(), peer: 'invalid' },
+ { ...message(), createdAt: NaN },
+ { ...message(), role: 'group' }
+ ])
+ expect(groupInboxMessages(owner, [row as ConversationData], [])).toEqual({
+ status: 'unavailable',
+ requests: [],
+ conversations: []
+ });
+});
+test('conflicting bytes of one rumor fail closed instead of substituting a preview', () =>
+ expect(
+ groupInboxMessages(
+ owner,
+ [message(), message('1'.repeat(64), 'inbound', 1700000000, 'different')],
+ []
+ )
+ ).toEqual({ status: 'unavailable', requests: [], conversations: [] }));
+test('SSR/copied scalar page tokens cannot inspect rows, map peers or request older history', async () => {
+ const fake = { owner, unlocked: true, ready: true } as unknown as InboxView;
+ expect(inboxListSnapshot(fake)).toEqual({
+ status: 'unavailable',
+ requests: [],
+ conversations: []
+ });
+ expect(
+ await openInboxConversation(
+ fake,
+ peer,
+ 'reviewed_admitted_conversation_navigation'
+ )
+ ).toBeUndefined();
+ expect(await loadOlderInboxView(fake, 'reviewed_load_older')).toBe(false);
+});
diff --git a/web/tests/unit/route-inventory.test.ts b/web/tests/unit/route-inventory.test.ts
@@ -26,6 +26,11 @@ const errorState = vi.hoisted(() => ({
params: { naddr: 'invalid-reference' }
}));
vi.mock('$app/state', () => ({ page: errorState }));
+vi.mock('$app/navigation', () => ({
+ goto: () => {
+ throw new Error('SSR must not navigate');
+ }
+}));
const routeRoot = fileURLToPath(new URL('../../src/routes/', import.meta.url));
const expectedPages = [
diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs
@@ -509,15 +509,19 @@ async function inboxPresentationAdmission(web) {
'src/routes/messages/+page.svelte':
'8279a92770f38858e197e790839bc98b4d7889214ebecdf47e542d632afbc84f',
'src/lib/components/InboxStatus.svelte':
- '605b92b9f8bb45ffb01ea4682869a37ec5b673a20a0deb7d9385ab659673f27f',
+ '519d13dad65d3d57db57329ee693cd6a2ea3e14bb1b51f334d8d58c3b677bf92',
'src/lib/messaging/inbox-view.ts':
- '008feb690302c8d9bf563581bd7eb071e619da7da1e56a12108d6560888e3c2c',
+ '9fb55cd5a227d4a23f56a5ff6d30902cdf7c8bfb16cb313e36f55d78cce9a7ec',
'src/lib/messaging/inbox-sync.ts':
'84f9b3bb165a81878bb281c51d245aff7eb06a0fa55b857a49b13d0cb1cff8ae',
'src/lib/messaging/inbox-setup-view.ts':
'7559ec04394624a8275280027c031b90d0a62b78f94aec3933df6f3b50077450',
'src/lib/messaging/decryption-queue.ts':
- '07661a883ee360e9fd7bd411893d637fd6b4b70aecb20101b826fe41b7ca4810'
+ '07661a883ee360e9fd7bd411893d637fd6b4b70aecb20101b826fe41b7ca4810',
+ 'src/lib/components/ConversationRow.svelte':
+ 'c5d0926ac9cdda18a6befe365227dfe62405f71598f59964ff36af9a0e85d743',
+ 'src/lib/messaging/inbox-list.ts':
+ '9cc82877bfa8dbb2a7fa41bceb842793349416271f19569f49fdd5cfc1de07e5'
};
for (const [name, pin] of Object.entries(producers)) {
const bytes = await readOwned(web, name);
@@ -685,7 +689,7 @@ export async function auditOutput(webDirectory) {
if (hasProductPresentation) names.add('publishers');
if (hasInboxSetup) names.add('private-handles');
if (hasInboxPresentation)
- for (const name of ['unlocked-session', 'read']) names.add(name);
+ for (const name of ['conversation-directory', 'read']) names.add(name);
const admitted = new Map([['build-info.json', expectedMetadata]]);
const seen = new Set();
for (const [key, record] of Object.entries(manifest)) {
@@ -1000,7 +1004,7 @@ export async function auditOutput(webDirectory) {
/** @type {[string,string[]][]} */
const dependencies = [
[
- 'unlocked-session',
+ 'conversation-directory',
[
'public-key',
'private-handles',
@@ -1018,9 +1022,10 @@ export async function auditOutput(webDirectory) {
'references',
'client',
'Button',
+ 'navigation',
'view-context',
'AccountGate',
- 'unlocked-session',
+ 'conversation-directory',
'read'
]
],
@@ -1028,14 +1033,12 @@ export async function auditOutput(webDirectory) {
'nodes/5',
[
'public-key',
- 'public-runtime',
'client',
- 'Button',
'client.svelte',
'state',
'view-context',
'AccountGate',
- 'unlocked-session'
+ 'conversation-directory'
]
]
];