@astrosheep/square 0.3.70 → 0.3.72

package/dist/presentation-operations.js

@@ -1,65 +1,56 @@
 import { formatActivityId, parseActivityId } from './square-core.js';
-import { deriveDeliveryModel } from './delivery.js';
-import { recordObservation } from './runtime.js';
-/** Present one pending activity; artifact seen remains the authoritative receipt. */
+import { pendingHead, sameJoin } from './delivery.js';
+/** Presentation evidence is not a receipt; only the fenced receipt transaction marks seen. */
 export async function presentPending(input) {
     const index = typeof input.activity === 'number' ? input.activity : parseActivityId(input.activity);
     if (index === undefined)
         return { presented: false };
-    let before;
-    try {
-        before = await input.artifact.read(input.signal);
-    }
-    catch {
-        return { presented: false };
-    }
-    const delivery = deriveDeliveryModel(before.state);
-    const item = before.state.acts.find((activity) => activity.index === index);
-    if (input.current?.(before.state) === false || item === undefined || delivery.isSeen(input.participant, index) || !delivery.pendingFor(input.participant).some((notification) => notification.item.index === index))
+    const before = await input.artifact.read((facts) => {
+        if (input.current?.(facts) === false || !pendingHead(facts, input.participant, index))
+            return undefined;
+        return { item: facts.activity(index), participant: facts.participant(input.participant) };
+    }, input.signal).catch(() => undefined);
+    if (before?.value === undefined)
         return { presented: false };
+    const { item, participant } = before.value;
+    const current = (facts) => sameJoin(facts, participant) && input.current?.(facts) !== false
+        && pendingHead(facts, participant.name, index) !== undefined;
+    const coordinate = { location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation' };
     let claimToken;
+    const release = async () => {
+        if (claimToken !== undefined)
+            await input.hostLedger.releaseEvidence({ ...coordinate, claimToken });
+    };
     if (input.hostLedger !== undefined && input.session !== undefined) {
-        const claim = await input.hostLedger.claimEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', leaseMs: input.timeoutMs ?? 5000 });
+        const claim = await input.hostLedger.claimEvidence({ ...coordinate, leaseMs: input.timeoutMs ?? 5000 });
         if (claim.status !== 'acquired')
             return { presented: false };
         claimToken = claim.claimToken;
-        let current;
-        try {
-            current = await input.artifact.read(input.signal);
-        }
-        catch {
-            await input.hostLedger.releaseEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', claimToken }).catch(() => undefined);
-            return { presented: false };
-        }
-        if (input.current?.(current.state) === false || deriveDeliveryModel(current.state).isSeen(input.participant, index)) {
-            await input.hostLedger.releaseEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', claimToken }).catch(() => undefined);
+        const fresh = await input.artifact.read(current, input.signal).catch(() => undefined);
+        if (!fresh?.value) {
+            await release().catch(() => undefined);
             return { presented: false };
         }
-        try {
-            await input.sink.present(item);
-        }
-        catch (error) {
-            await input.hostLedger.appendEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', outcome: 'failed', message: error instanceof Error ? error.message : String(error), claimToken });
-            throw error;
-        }
     }
-    else
+    try {
         await input.sink.present(item);
-    const committed = await input.artifact.transact((state) => {
-        const current = deriveDeliveryModel(state);
-        if (input.current?.(state) === false || current.isSeen(input.participant, index) || !current.pendingFor(input.participant).some((notification) => notification.item.index === index))
-            return { result: false };
-        if (input.markSeen === false)
-            return { result: true };
-        const changed = recordObservation(state, input.participant, index, 'seen', input.now ?? Date.now());
-        return changed ? { state, result: true } : { result: false };
+    }
+    catch (error) {
+        if (claimToken !== undefined)
+            await input.hostLedger.appendEvidence({ ...coordinate, outcome: 'failed', message: error instanceof Error ? error.message : String(error), claimToken });
+        throw error;
+    }
+    const { value: committed } = await input.artifact.transact((facts) => {
+        if (!current(facts))
+            return false;
+        return input.markSeen === false || facts.markSeen(participant.name, [index], input.now ?? Date.now()) > 0;
     }, input.signal);
     if (!committed) {
-        if (input.hostLedger !== undefined && input.session !== undefined && claimToken !== undefined)
-            await input.hostLedger.releaseEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', claimToken });
+        await release();
         return { presented: false };
     }
-    if (input.hostLedger !== undefined && input.session !== undefined && claimToken !== undefined)
-        await input.hostLedger.appendEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', outcome: input.markSeen === false ? 'clipped' : 'presented', ...(input.markSeen === false ? { message: 'presentation clipped' } : {}), claimToken });
+    if (claimToken !== undefined)
+        await input.hostLedger.appendEvidence({ ...coordinate, outcome: input.markSeen === false ? 'clipped' : 'presented',
+            ...(input.markSeen === false ? { message: 'presentation clipped' } : {}), claimToken });
     return { presented: true, activity: item };
 }

package/dist/presentation.d.ts

@@ -1,7 +1,7 @@
-import { type StoredAct, type SquareState, type PublicAct, type RoomChangeAct } from './model.js';
+import { type StoredAct, type RoomChangeAct } from './model.js';
 export { participantIdentity } from './participant-identity.js';
 import { type Perception } from './square-core.js';
-import type { UnreadActivitySummary, ParticipantStatus } from './decisions.js';
+import type { Activity, UnreadActivitySummary, ParticipantSummary } from './square-facade.js';
 export type WatchStatus = 'stale' | 'empty-now' | 'quorum' | 'capped';
 interface HeaderOptions {
     participantCount?: number;
@@ -23,7 +23,7 @@ interface ActivityLimitOptions extends ParticipantOutputOptions {
 interface ActivityBlockedOptions extends ParticipantOutputOptions {
     retryCommand: string;
     forceCommand: string;
-    activitySummaries: UnreadActivitySummary[];
+    activitySummaries: readonly UnreadActivitySummary[];
     draftPath?: string;
 }
 interface ExpressWaitingOptions {
@@ -44,7 +44,7 @@ interface WatchStatusOptions extends ParticipantOutputOptions {
     status: WatchStatus;
     idleMs?: number;
     presence?: {
-        participants: ParticipantStatus[];
+        participants: readonly ParticipantSummary[];
         now: number;
     };
     showCatchHint?: boolean;
@@ -58,6 +58,7 @@ export declare function formatRefusal(squarePath: string, bodyLines: string[], o
     participantCount?: number;
     held?: boolean;
 }): string;
+export declare function refusalText(error: unknown): string;
 export declare function quoteShell(value: string): string;
 export declare function commandPrefix(squarePath: string): string;
 export declare function participantCommandPrefix(squarePath: string, name: string): string;
@@ -66,44 +67,42 @@ export declare function joinRecoveryCommand(squarePath: string, name: string): s
 /** Taking a name is an explicit recovery choice, never an automatic retry. */
 export declare function takeoverRecoveryLines(squarePath: string, name: string): string[];
 export declare function participantsRecoveryCommand(squarePath: string): string;
-export declare function renderPresenceLines(participants: ParticipantStatus[], now: number, limit?: number): string[];
+export declare function renderPresenceLines(recent: readonly ParticipantSummary[], now: number, limit?: number): string[];
 export declare function expressHintLine(ownActivityCount: number): string | undefined;
 export declare function truncateChars(body: string, maxChars: number): {
     text: string;
     remaining: number;
 };
 export declare function truncateExternalDiagnostic(diagnostic: string): string;
-export declare function renderRoomChangeText(event: RoomChangeAct): string;
+export declare function renderRoomChangeText(event: RoomChangeAct | Activity): string;
 interface RenderedEvent {
     text: string;
     /** The rendered body was cut short by `preview`. */
     bodyClipped: boolean;
 }
-export declare function renderEventCli(event: StoredAct, opts?: {
+export declare function renderEventCli(event: StoredAct | Activity, opts?: {
     now?: number;
     preview?: number;
     actNumber?: number;
     mention?: string;
 }): string;
-export declare function renderAmbientEventFacts(event: StoredAct, viewer: string, opts?: {
+export declare function renderAmbientEventFacts(event: StoredAct | Activity, viewer: string, opts?: {
     now?: number;
     preview?: number;
     presencePreview?: number;
     actNumber?: number;
     mention?: string;
-    squareState?: SquareState;
     perception?: Perception;
 }): RenderedEvent;
-export declare function renderAmbientEvent(event: StoredAct, viewer: string, opts?: {
+export declare function renderAmbientEvent(event: StoredAct | Activity, viewer: string, opts?: {
     now?: number;
     preview?: number;
     presencePreview?: number;
     actNumber?: number;
     mention?: string;
-    squareState?: SquareState;
     perception?: Perception;
 }): string;
-export declare function renderPendingFeed(history: StoredAct[], publicItems: PublicAct[], viewer: string | undefined, squareState: SquareState): string;
+export declare function renderPendingFeed(publicItems: readonly StoredAct[], sayNumbers: Readonly<Record<number, number>>, perceptions: Readonly<Record<number, Perception>>, viewer: string): string;
 export declare function renderActivityBlocked(opts: ActivityBlockedOptions): string;
 /** An indeterminate or already-committed send only points to inspection, never resend. */
 export declare function renderActivityUncertain(opts: ParticipantOutputOptions & {
@@ -114,7 +113,7 @@ export declare function renderActivityUncertain(opts: ParticipantOutputOptions &
 export declare function renderExpressWaiting(opts: ExpressWaitingOptions): string;
 export declare function renderExpressNoWait(opts: ExpressNoWaitOptions): string;
 export declare function renderPresenceAnchor(names: readonly string[]): string;
-export declare function renderGrepActivitiesView(visible: StoredAct[], totalMatches: number, noTruncate: boolean | undefined, squarePath: string, pattern: string, fixed?: boolean, perception?: (act: StoredAct) => Perception): string;
+export declare function renderGrepActivitiesView(visible: readonly StoredAct[], totalMatches: number, noTruncate: boolean | undefined, squarePath: string, pattern: string, fixed?: boolean, perception?: (act: StoredAct) => Perception): string;
 export declare function renderActivityLimit(opts: ActivityLimitOptions): string;
 export declare function renderWatchAlreadyActive(opts: ParticipantOutputOptions): string;
 export declare function renderWatchForceTakeover(_opts: ParticipantOutputOptions): string;
@@ -123,9 +122,3 @@ export declare function renderWatchReplaced(_opts: ParticipantOutputOptions): st
 export declare function renderWatchStatus(opts: WatchStatusOptions): string;
 export declare function renderDoctorClean(): string;
 export declare function renderDoctorUnfixable(reason: string): string;
-export declare function renderWatchOutput(history: StoredAct[], publicItems: PublicAct[], opts: {
-    mention?: string;
-    viewer: string;
-    squareState?: SquareState;
-    perceptions?: ReadonlyMap<number, Perception>;
-}): string;

package/dist/presentation.js

@@ -1,13 +1,11 @@
-import { sameName } from './model.js';
+import { sameName, isSquareError } from './model.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { participantIdentity } from './participant-identity.js';
 export { participantIdentity } from './participant-identity.js';
-import { audienceIncludes, audienceOf, MAX_IDENTITY_SET_SIZE } from './square-core.js';
-import { perceiveActivity } from './delivery.js';
-import { actId, sayNumberFor, HELD_WAIT_BUDGET_MS } from './runtime.js';
+import { formatActivityId, MAX_IDENTITY_SET_SIZE } from './square-core.js';
+import { HELD_WAIT_BUDGET_MS } from './runtime.js';
 import { formatDuration, formatRelativeTime, formatTimestamp } from './time.js';
-import { compareParticipantActivity } from './decisions.js';
 import { grepSnippet } from './search.js';
 import { style } from './tty-style.js';
 export function displayPath(squarePath, cwd = process.cwd()) {
@@ -39,6 +37,11 @@ export function formatRefusal(squarePath, bodyLines, opts = {}) {
         return body === '' ? '' : `${body}\n`;
     return withPathOutput(squarePath, body, { ...opts, plain: true });
 }
+export function refusalText(error) {
+    const text = error instanceof Error ? error.message : String(error);
+    const marked = isSquareError(error) && ['never_joined', 'not_standing', 'unmatched_mention'].includes(error.facts?.reason ?? '');
+    return marked ? text.split('\n').map((line) => `✕ ${line}`).join('\n') : text;
+}
 export function quoteShell(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -69,11 +72,7 @@ function formatAge(ms) {
         return `${Math.max(0, ms)}ms`;
     return `${Math.floor(ms / 1000)}s`;
 }
-const PRESENCE_WINDOW_MS = 8 * 60 * 60 * 1000;
-export function renderPresenceLines(participants, now, limit = 5) {
-    const recent = participants
-        .filter((p) => p.state === 'done' || p.presence === 'watching' || (p.lastActiveAt !== undefined && now - p.lastActiveAt <= PRESENCE_WINDOW_MS))
-        .sort(compareParticipantActivity);
+export function renderPresenceLines(recent, now, limit = 5) {
     const shown = recent.slice(0, limit);
     if (shown.length === 0)
         return [style('dim', '  ○ nobody nearby')];
@@ -137,9 +136,11 @@ export function renderRoomChangeText(event) {
         case 'resume':
             return `${identity} lowered the hand`;
         case 'listen':
-            return `${identity} turned an ear toward ${participantIdentity(event.target)}`;
+            return `${identity} turned an ear toward ${participantIdentity(event.target ?? 'someone')}`;
         case 'ignore':
-            return `${identity} turned away from ${participantIdentity(event.target)}`;
+            return `${identity} turned away from ${participantIdentity(event.target ?? 'someone')}`;
+        default:
+            throw new Error('Expected a lifecycle activity');
     }
 }
 function renderedBody(body, maxChars) {
@@ -152,6 +153,12 @@ function bodySuffix(body) {
         return '';
     return `\n${body.split('\n').map((line) => `  ${line}`).join('\n')}`;
 }
+function eventId(event) {
+    return 'index' in event ? formatActivityId(event.index) : event.id;
+}
+function replyId(reply) {
+    return typeof reply === 'number' ? formatActivityId(reply) : reply;
+}
 function renderEventCliFacts(event, opts = {}) {
     const now = opts.now;
     const maxBody = opts.preview;
@@ -168,17 +175,17 @@ function renderEventCliFacts(event, opts = {}) {
         case 'say': {
             const body = renderedBody(event.body, maxBody);
             const mention = opts.mention;
-            const mentionSuffix = mention !== undefined && audienceIncludes(audienceOf(event), mention)
+            const mentionSuffix = mention !== undefined && (event.reach === 'bell' || event.mentions?.some((name) => sameName(name, mention)))
                 ? ` · calls your name across the square — ${participantIdentity(mention)}`
                 : '';
-            const replySuffix = event.reply === undefined ? '' : ` · replies to ${actId(event.reply)}`;
-            const meta = ` #${opts.actNumber ?? 1} · ${actId(event)} · ${formatRelativeTime(event.at, now)}${mentionSuffix}${replySuffix}`;
+            const replySuffix = event.reply === undefined ? '' : ` · replies to ${replyId(event.reply)}`;
+            const meta = ` #${opts.actNumber ?? 1} · ${eventId(event)} · ${formatRelativeTime(event.at, now)}${mentionSuffix}${replySuffix}`;
             return { text: `● ${participantIdentity(event.actor)}${style('dim', meta)}${bodySuffix(body.text)}`, bodyClipped: body.clipped };
         }
         case 'done': {
             const body = renderedBody(event.body, maxBody);
             return {
-                text: `${style('dim', '○')} ${participantIdentity(event.actor)} stepped out of the square — done${style('dim', ` · ${actId(event)} · ${formatRelativeTime(event.at, now)}`)}${bodySuffix(body.text)}`,
+                text: `${style('dim', '○')} ${participantIdentity(event.actor)} stepped out of the square — done${style('dim', ` · ${eventId(event)} · ${formatRelativeTime(event.at, now)}`)}${bodySuffix(body.text)}`,
                 bodyClipped: body.clipped,
             };
         }
@@ -190,9 +197,8 @@ export function renderEventCli(event, opts = {}) {
     return renderEventCliFacts(event, opts).text;
 }
 function renderPresenceOnlySay(event, opts = {}) {
-    const audience = audienceOf(event);
-    const targets = audience.kind === 'bell' ? [] : audience.names;
-    const meta = style('dim', ` #${opts.actNumber ?? 1} · ${actId(event)} · ${formatRelativeTime(event.at, opts.now)}`);
+    const targets = event.reach === 'bell' ? [] : event.mentions ?? [];
+    const meta = style('dim', ` #${opts.actNumber ?? 1} · ${eventId(event)} · ${formatRelativeTime(event.at, opts.now)}`);
     if (targets.length === 0) {
         return `● ${participantIdentity(event.actor)}${meta}`;
     }
@@ -207,10 +213,9 @@ function renderPresenceOnlySay(event, opts = {}) {
 export function renderAmbientEventFacts(event, viewer, opts = {}) {
     if (event.kind !== 'say')
         return renderEventCliFacts(event, opts);
-    if (opts.perception === undefined && opts.squareState === undefined) {
-        throw new Error('Ambient say rendering requires a settled perception or SquareState');
-    }
-    const seen = opts.perception ?? perceiveActivity(opts.squareState, event, viewer);
+    if (opts.perception === undefined)
+        throw new Error('Ambient say rendering requires a settled perception');
+    const seen = opts.perception;
     if (seen === 'presence') {
         const presence = renderPresenceOnlySay(event, opts);
         const body = opts.presencePreview === undefined ? { text: '', clipped: false } : renderedBody(event.body, opts.presencePreview);
@@ -248,17 +253,8 @@ function renderUnreadSummary(opts) {
         ...(remainingSummaries === 0 ? [] : [style('dim', `  · ${remainingSummaries} more participants have unread activity`)]),
     ];
 }
-export function renderPendingFeed(history, publicItems, viewer = '', squareState) {
-    const lines = [];
-    for (const act of publicItems) {
-        const rendered = renderAmbientEvent(act, viewer, {
-            actNumber: act.kind === 'say' ? sayNumberFor(history, act) : undefined,
-            ...(squareState === undefined ? {} : { squareState }),
-        });
-        if (rendered !== '')
-            lines.push(rendered);
-    }
-    return lines.join('\n\n');
+export function renderPendingFeed(publicItems, sayNumbers, perceptions, viewer) {
+    return publicItems.map((act) => renderAmbientEvent(act, viewer, { actNumber: sayNumbers[act.index], perception: perceptions[act.index] })).filter(Boolean).join('\n\n');
 }
 export function renderActivityBlocked(opts) {
     const readNowCommand = `${participantCommandPrefix(opts.squarePath, opts.name)} catch`;
@@ -344,7 +340,7 @@ export function renderGrepActivitiesView(visible, totalMatches, noTruncate, squa
     let truncated = false;
     for (const act of publicVisible) {
         const rawBody = act.body ?? '';
-        const header = `${style('dim', actId(act.index))} · ${act.actor === undefined ? 'unknown' : participantIdentity(act.actor)} · ${style('dim', formatTimestamp(act.at))}`;
+        const header = `${style('dim', formatActivityId(act.index))} · ${act.actor === undefined ? 'unknown' : participantIdentity(act.actor)} · ${style('dim', formatTimestamp(act.at))}`;
         if (perception?.(act) === 'presence') {
             chunks.push(header);
             continue;
@@ -370,10 +366,10 @@ export function renderGrepActivitiesView(visible, totalMatches, noTruncate, squa
         chunks.push(`${header}\n  ${text.trim()}${omitted}`);
     }
     if (publicVisible.length === 1) {
-        chunks.push(`${commandPrefix(squarePath)} history --at ${actId(publicVisible[0].index)} -C 2${truncated ? ' --no-truncate' : ''}`);
+        chunks.push(`${commandPrefix(squarePath)} history --at ${formatActivityId(publicVisible[0].index)} -C 2${truncated ? ' --no-truncate' : ''}`);
     }
     else if (truncated && publicVisible.length > 1) {
-        chunks.push(`${commandPrefix(squarePath)} history --at ${actId(publicVisible[0].index)} -C 2 --no-truncate`);
+        chunks.push(`${commandPrefix(squarePath)} history --at ${formatActivityId(publicVisible[0].index)} -C 2 --no-truncate`);
     }
     return chunks.join('\n\n');
 }
@@ -447,20 +443,3 @@ export function renderDoctorClean() {
 export function renderDoctorUnfixable(reason) {
     return ['✕ unreadable artifact', `  · ${truncateExternalDiagnostic(reason)}`].join('\n');
 }
-export function renderWatchOutput(history, publicItems, opts) {
-    const sections = [];
-    if (publicItems.length > 0) {
-        const rendered = publicItems
-            .map((act) => renderAmbientEvent(act, opts.viewer, {
-            actNumber: act.kind === 'say' ? sayNumberFor(history, act) : undefined,
-            mention: opts.mention,
-            ...(opts.perceptions?.has(act.index) ? { perception: opts.perceptions.get(act.index) } : {}),
-            ...(opts.squareState === undefined ? {} : { squareState: opts.squareState }),
-        }))
-            .filter(Boolean)
-            .join('\n\n');
-        if (rendered !== '')
-            sections.push(rendered);
-    }
-    return sections.join('\n\n') + '\n';
-}

package/dist/registry.d.ts

@@ -2,6 +2,8 @@
 import { type FileHostLedgerPort } from './host-ledger-file-adapter.js';
 import type { HostLedgerPort, PresenceChannel, PresenceRecord } from './host-ledger.js';
 export declare function presenceEpoch(record: PresenceRecord | undefined): number;
+/** The current owner: the highest epoch wins, then the most recently updated row. */
+export declare function currentOwner(rows: readonly PresenceRecord[]): PresenceRecord | undefined;
 export declare function localParticipantName(squarePath: string, hostLedger: HostLedgerPort, env?: NodeJS.ProcessEnv): Promise<string | undefined>;
 export declare function squareAssignedParticipantName(env?: NodeJS.ProcessEnv): string | undefined;
 export type OwnershipClaim = {

package/dist/registry.js

@@ -8,7 +8,7 @@ export function presenceEpoch(record) {
     return typeof record?.epoch === 'number' && Number.isSafeInteger(record.epoch) && record.epoch > 0 ? record.epoch : 0;
 }
 /** The current owner: the highest epoch wins, then the most recently updated row. */
-function currentOwner(rows) {
+export function currentOwner(rows) {
     return [...rows].sort((left, right) => presenceEpoch(right) - presenceEpoch(left) || (right.updatedAt ?? 0) - (left.updatedAt ?? 0))[0];
 }
 export async function localParticipantName(squarePath, hostLedger, env = process.env) { const canonical = await canonicalPath(squarePath); const names = new Set((await Promise.all(localSessionIdentities(env).map(async (identity) => (await hostLedger.listPresence({ location: canonical, session: identity.sessionId })).map((row) => row.participant)))).flat()); return names.size === 1 ? [...names][0] : undefined; }

package/dist/routes.d.ts

@@ -1,4 +1,5 @@
 import { type WakeRoute, type WakeRouteKind } from './model.js';
+import type { SquareRead, SquareWrite } from './ports.js';
 export { WAKE_ROUTE_KINDS } from './model.js';
 export type { WakeRoute, WakeRouteKind } from './model.js';
 export declare const ROUTE_FRESH_MS: number;
@@ -18,25 +19,17 @@ export declare function routeIdentityKey(route: Pick<WakeRoute, 'location' | 'pa
 export type RouteEpoch = {
     readonly epoch?: number;
 };
-export declare function applyWakeRouteToState(state: import('./model.js').SquareState, route: Omit<WakeRoute, 'updatedAt'> & RouteEpoch, at?: number): void;
-export declare function dropSessionWakeRoutesFromState(state: import('./model.js').SquareState, location: string, sessionId: string, expectedEpoch?: number): void;
-/**
- * Drop one ended session's routes at a location, atomically with the lifecycle decide.
- *
- * A route survives when the ending transaction did not commit `done` and this session
- * still holds the sole live presence for its participant — an in-flight same-session
- * rejoin. `liveParticipants === undefined` means the ledger could not be read, so
- * nothing is dropped on suspicion. An explicit epoch fence additionally keeps routes
- * published by a later generation.
- */
-export declare function dropEndedSessionWakeRoutesFromState(state: import('./model.js').SquareState, location: string, sessionId: string, opts: {
+export declare function applyWakeRoute(facts: SquareWrite, route: Omit<WakeRoute, 'updatedAt'> & RouteEpoch, at?: number): void;
+export declare function dropSessionWakeRoutes(facts: SquareWrite, location: string, sessionId: string, expectedEpoch?: number): void;
+/** Keep an in-flight same-session rejoin; unknown host evidence is not a reason to retire it. */
+export declare function dropEndedSessionWakeRoutes(facts: SquareWrite, location: string, sessionId: string, opts: {
     readonly expectedEpoch?: number;
     readonly liveParticipants?: ReadonlySet<string>;
     readonly force: boolean;
     readonly participant?: string;
 }): void;
-export declare function dropParticipantWakeRoutesFromState(state: import('./model.js').SquareState, location: string, participant: string): void;
-export declare function sessionCanEndParticipant(state: import('./model.js').SquareState, location: string, participant: string, sessionId: string, currentSessionId?: string): boolean;
+export declare function dropParticipantWakeRoutes(facts: SquareWrite, location: string, participant: string): void;
+export declare function sessionCanEndParticipant(facts: SquareRead, location: string, participant: string, sessionId: string, sessionIdNow?: string): boolean;
 export declare function publishWakeRoute(artifact: import('./ports.js').SquareArtifactPort, route: Omit<WakeRoute, 'updatedAt'> & RouteEpoch, opts?: {
     at?: number;
     requireCurrentSession?: boolean;

package/dist/routes.js

@@ -1,18 +1,8 @@
 import { nameKey } from './model.js';
-import { isCurrentlyJoined } from './runtime.js';
 import { canonicalPath, canonicalPathSync } from './canonical-path.js';
 export { WAKE_ROUTE_KINDS } from './model.js';
 export const ROUTE_FRESH_MS = 24 * 60 * 60 * 1000;
 export async function defaultWakeRouteCapabilities(hostLedger) {
-    let userCapable = hostLedger !== undefined;
-    if (hostLedger !== undefined) {
-        try {
-            await hostLedger.listPresence({ now: Date.now() });
-        }
-        catch {
-            userCapable = false;
-        }
-    }
     const available = new Set();
     try {
         const { CodexQueueAdapter } = await import('./codex-queue.js');
@@ -24,7 +14,7 @@ export async function defaultWakeRouteCapabilities(hostLedger) {
         available.add(new PaseoAdapter().kind);
     }
     catch { /* optional */ }
-    return { canUse: (kind, address) => userCapable && available.has(kind) && Object.values(address).every((value) => value.trim() !== '') };
+    return { canUse: (kind, address) => hostLedger !== undefined && available.has(kind) && Object.values(address).every((value) => value.trim() !== '') };
 }
 export function resolvePrimaryWakeRoute(boundary, env, capabilities) {
     const paseoAgentId = env.PASEO_AGENT_ID?.trim();
@@ -44,89 +34,61 @@ function sameRouteAddress(left, right) {
     const rightKeys = Object.keys(right).sort();
     return leftKeys.length === rightKeys.length && leftKeys.every((key, index) => rightKeys[index] === key && left[key] === right[key]);
 }
-export function applyWakeRouteToState(state, route, at = Date.now()) {
+export function applyWakeRoute(facts, route, at = Date.now()) {
     const location = canonicalPathSync(route.location);
-    state.routes = [...(state.routes ?? []).filter((item) => {
-            const itemLocation = canonicalPathSync(item.location);
-            return !(itemLocation === location && routeIdentityKey(item, itemLocation) === routeIdentityKey(route, location));
-        }), { ...route, location, updatedAt: at }];
+    const identity = routeIdentityKey(route, location);
+    facts.replaceRoutes([...facts.routes().filter((item) => routeIdentityKey(item, canonicalPathSync(item.location)) !== identity),
+        { ...route, location, updatedAt: at, extra: {} }]);
 }
-export function dropSessionWakeRoutesFromState(state, location, sessionId, expectedEpoch) {
+export function dropSessionWakeRoutes(facts, location, sessionId, expectedEpoch) {
     const canonical = canonicalPathSync(location);
-    state.routes = (state.routes ?? []).filter((item) => {
-        if (item.sessionId !== sessionId || canonicalPathSync(item.location) !== canonical)
-            return true;
-        if (expectedEpoch === undefined)
-            return false;
-        return item.epoch !== expectedEpoch;
-    });
+    facts.replaceRoutes(facts.routes().filter((item) => item.sessionId !== sessionId || canonicalPathSync(item.location) !== canonical
+        || (expectedEpoch !== undefined && item.epoch !== expectedEpoch)));
 }
-/**
- * Drop one ended session's routes at a location, atomically with the lifecycle decide.
- *
- * A route survives when the ending transaction did not commit `done` and this session
- * still holds the sole live presence for its participant — an in-flight same-session
- * rejoin. `liveParticipants === undefined` means the ledger could not be read, so
- * nothing is dropped on suspicion. An explicit epoch fence additionally keeps routes
- * published by a later generation.
- */
-export function dropEndedSessionWakeRoutesFromState(state, location, sessionId, opts) {
+/** Keep an in-flight same-session rejoin; unknown host evidence is not a reason to retire it. */
+export function dropEndedSessionWakeRoutes(facts, location, sessionId, opts) {
     const canonical = canonicalPathSync(location);
-    state.routes = (state.routes ?? []).filter((item) => {
+    facts.replaceRoutes(facts.routes().filter((item) => {
         if (item.sessionId !== sessionId || canonicalPathSync(item.location) !== canonical)
             return true;
         if (opts.participant !== undefined && nameKey(item.participant) !== nameKey(opts.participant))
             return true;
-        if (!opts.force) {
-            // Keep only a route whose participant is still joined and whose ended session still
-            // holds the sole live presence — an in-flight same-session rejoin. A no-longer-joined
-            // participant is retired even when a stale presence row survives.
-            if (isCurrentlyJoined(state.acts, item.participant)
-                && (opts.liveParticipants === undefined || opts.liveParticipants.has(nameKey(item.participant))))
-                return true;
-        }
-        if (opts.expectedEpoch !== undefined && item.epoch !== opts.expectedEpoch)
+        if (!opts.force && facts.participant(item.participant)?.joined
+            && (opts.liveParticipants === undefined || opts.liveParticipants.has(nameKey(item.participant))))
             return true;
-        return false;
-    });
+        return opts.expectedEpoch !== undefined && item.epoch !== opts.expectedEpoch;
+    }));
 }
-export function dropParticipantWakeRoutesFromState(state, location, participant) {
+export function dropParticipantWakeRoutes(facts, location, participant) {
     const canonical = canonicalPathSync(location);
-    state.routes = (state.routes ?? []).filter((item) => !(nameKey(item.participant) === nameKey(participant) && canonicalPathSync(item.location) === canonical));
+    facts.replaceRoutes(facts.routes().filter((item) => !(nameKey(item.participant) === nameKey(participant) && canonicalPathSync(item.location) === canonical)));
 }
-export function sessionCanEndParticipant(state, location, participant, sessionId, currentSessionId) {
+export function sessionCanEndParticipant(facts, location, participant, sessionId, sessionIdNow) {
     const canonical = canonicalPathSync(location);
-    const owned = (state.routes ?? []).filter((item) => nameKey(item.participant) === nameKey(participant) && canonicalPathSync(item.location) === canonical);
+    const owned = facts.routes().filter((item) => nameKey(item.participant) === nameKey(participant) && canonicalPathSync(item.location) === canonical);
     if (owned.length === 0)
-        return currentSessionId === sessionId;
-    return owned.every((item) => item.sessionId === sessionId) && (currentSessionId === undefined || currentSessionId === sessionId);
+        return sessionIdNow === sessionId;
+    return owned.every((item) => item.sessionId === sessionId) && (sessionIdNow === undefined || sessionIdNow === sessionId);
 }
 export async function publishWakeRoute(artifact, route, opts = {}) {
     const location = await canonicalPath(route.location);
     const at = opts.at ?? Date.now();
-    await artifact.transact((state) => {
-        if (opts.requireCurrentSession) {
-            if (!isCurrentlyJoined(state.acts, route.participant)
-                || (state.routes ?? []).some((item) => nameKey(item.participant) === nameKey(route.participant) && canonicalPathSync(item.location) === location && item.sessionId !== route.sessionId))
-                return { state, result: undefined };
-        }
-        const identity = routeIdentityKey({ ...route, location });
-        const matching = (state.routes ?? []).filter((item) => routeIdentityKey(item, canonicalPathSync(item.location)) === identity);
+    await artifact.transact((facts) => {
+        const routes = facts.routes();
+        if (opts.requireCurrentSession && (!facts.participant(route.participant)?.joined
+            || routes.some((item) => nameKey(item.participant) === nameKey(route.participant) && canonicalPathSync(item.location) === location && item.sessionId !== route.sessionId)))
+            return;
+        const identity = routeIdentityKey(route, location);
+        const matching = routes.filter((item) => routeIdentityKey(item, canonicalPathSync(item.location)) === identity);
         const existing = matching[0];
-        const existingEpoch = existing?.epoch;
-        const epochMatches = route.epoch === undefined ? existingEpoch === undefined : existingEpoch === route.epoch;
-        if (matching.length === 1 && existing !== undefined && existing.updatedAt > at - ROUTE_FRESH_MS && existing.kind === route.kind && existing.channel === route.channel && sameRouteAddress(existing.address, route.address) && epochMatches)
-            return { result: undefined };
-        return { state: { ...state, routes: [...(state.routes ?? []).filter((item) => routeIdentityKey(item, canonicalPathSync(item.location)) !== identity), { ...route, location, updatedAt: at }] }, result: undefined };
+        if (matching.length === 1 && existing.updatedAt > at - ROUTE_FRESH_MS && existing.kind === route.kind
+            && existing.channel === route.channel && sameRouteAddress(existing.address, route.address) && existing.epoch === route.epoch)
+            return;
+        applyWakeRoute(facts, { ...route, location }, at);
     });
 }
 export async function retireWakeRouteFromArtifact(artifact, route, opts = {}) {
     const location = await canonicalPath(route.location);
-    const target = routeIdentityKey({ ...route, location });
-    await artifact.transact((state) => ({ state: { ...state, routes: (state.routes ?? []).filter((item) => {
-                const itemLocation = canonicalPathSync(item.location);
-                if (routeIdentityKey(item, itemLocation) !== target)
-                    return true;
-                return opts.expectedEpoch !== undefined && item.epoch !== opts.expectedEpoch;
-            }) }, result: undefined }));
+    const target = routeIdentityKey(route, location);
+    await artifact.transact((facts) => facts.replaceRoutes(facts.routes().filter((item) => routeIdentityKey(item, canonicalPathSync(item.location)) !== target || (opts.expectedEpoch !== undefined && item.epoch !== opts.expectedEpoch))));
 }