@astrosheep/square 0.3.23 → 0.3.25

package/dist/presented.d.ts

@@ -1,5 +1,13 @@
 import { type InboxMembership } from './model.js';
+export interface PresentedAttention {
+    ownerId: string;
+    squarePath: string;
+    name: string;
+    actIndex: number;
+}
 export declare function presentedPath(env?: NodeJS.ProcessEnv): string;
+/** Read the current presentation facts once for a derived evidence projection. */
+export declare function readPresentedAttentions(env?: NodeJS.ProcessEnv, now?: number): PresentedAttention[];
 export declare function hasPresentedForOwner(ownerId: string, squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, now?: number): boolean;
 /** True when any current participant owner has already received this attention. */
 export declare function hasPresentedAttention(squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, now?: number): boolean;

package/dist/presented.js

@@ -48,6 +48,15 @@ function readRows(filePath, now = Date.now()) {
     }
     return rows;
 }
+/** Read the current presentation facts once for a derived evidence projection. */
+export function readPresentedAttentions(env = process.env, now = Date.now()) {
+    return readRows(presentedPath(env), now).map((row) => ({
+        ownerId: row.owner_id,
+        squarePath: canonicalSquarePath(row.square_path),
+        name: row.name,
+        actIndex: row.act_index,
+    }));
+}
 function writeRows(filePath, rows) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     const temp = `${filePath}.${process.pid}.${Date.now()}.tmp`;

package/dist/registry.d.ts

@@ -28,6 +28,7 @@ export declare function registryPath(): string;
 export declare function canonicalSquarePath(squarePath: string): string;
 export declare function recordJoin(sessionId: string, name: string, squarePath: string, options?: RegistryWriteOptions): void;
 export declare function recordDone(sessionId: string, name: string, squarePath: string, options?: RegistryWriteOptions): void;
+export declare function readActiveBindings(now?: number): RegistryBinding[];
 export declare function lookupSessionBindings(sessionId: string, now?: number): RegistryBinding[];
 export declare function lookupSession(sessionId: string, now?: number): Array<{
     name: string;

package/dist/registry.js

@@ -205,7 +205,7 @@ export function recordJoin(sessionId, name, squarePath, options = {}) {
 export function recordDone(sessionId, name, squarePath, options = {}) {
     writeLifecycle('done', sessionId, name, squarePath, options);
 }
-function readActiveBindings(now = Date.now()) {
+export function readActiveBindings(now = Date.now()) {
     try {
         return foldRegistry(fs.readFileSync(registryPath(), 'utf8'), now);
     }

package/dist/runtime.d.ts

@@ -1,4 +1,4 @@
-import { type ActivityId, type Reach } from './square-core.js';
+import { type ActivityId, type LandedAudienceReplay, type Reach } from './square-core.js';
 import { type StoredAct, type SquareState, type HoldState, type ActivityObservation, type ObservationState, type WatchLease } from './model.js';
 export declare const WATCH_HEARTBEAT_MS: number;
 export declare const SLEEP_MS: number;
@@ -36,7 +36,7 @@ export declare function publicActs(acts: StoredAct[]): Array<Extract<StoredAct,
 }>>;
 export declare function observationFor(squareState: SquareState, name: string, index: number): ActivityObservation | undefined;
 export declare function recordObservation(squareState: SquareState, name: string, index: number, state: ObservationState, at?: number, ownerId?: string): boolean;
-export declare function readCursor(squareState: SquareState, name: string): number;
+export declare function readCursor(squareState: SquareState, name: string, landed?: LandedAudienceReplay): number;
 export declare function latestActIndex(acts: StoredAct[]): number;
 export declare function freshWatchLease(squareState: SquareState, name: string, at?: number): WatchLease | undefined;
 export declare function watchLease(squareState: SquareState, name: string): WatchLease | undefined;

package/dist/runtime.js

@@ -1,4 +1,4 @@
-import { audienceIncludes, audienceOf, fold, formatActivityId, landedAudienceIncludes } from './square-core.js';
+import { audienceIncludes, audienceOf, fold, formatActivityId, replayLandedAudiences } from './square-core.js';
 import { SquareError, findParticipantName, nameKey, sameName, } from './model.js';
 function parseIntegerEnvValue(name, raw, fallback) {
     if (raw === undefined)
@@ -162,21 +162,22 @@ export function recordObservation(squareState, name, index, state, at = Date.now
     ((squareState.runtime.observations ??= {})[key] ??= {})[id] = next;
     return true;
 }
-export function readCursor(squareState, name) {
-    const boundary = lastJoinIndex(squareState.acts, name) ?? -1;
+export function readCursor(squareState, name, landed = replayLandedAudiences(squareState.acts)) {
+    const recipient = landed.resolveParticipant(name) ?? name;
+    const boundary = landed.lastJoinIndex(recipient) ?? -1;
     let cursor = boundary;
     for (const act of squareState.acts) {
         if (act.index <= boundary || act.kind === 'read' || act.actor === undefined)
             continue;
-        if (sameName(act.actor, name)) {
+        if (sameName(act.actor, recipient)) {
             cursor = act.index;
             continue;
         }
-        if (!landedAudienceIncludes(squareState.acts, act, name)) {
+        if (!landed.includes(act, recipient)) {
             cursor = act.index;
             continue;
         }
-        if (observationFor(squareState, name, act.index)?.state !== 'seen')
+        if (squareState.runtime.observations?.[recipient]?.[formatActivityId(act.index)]?.state !== 'seen')
             break;
         cursor = act.index;
     }

package/dist/square-core.d.ts

@@ -82,6 +82,15 @@ export interface FoldedSquareState {
     /** Derived sender blocks; kept outside the artifact schema. */
     ignored: Map<string, Participant[]>;
 }
+export interface LandedAudienceReplay {
+    readonly participants: readonly Participant[];
+    readonly joined: readonly Participant[];
+    readonly replayedActivityCount: number;
+    recipientsFor(activity: Act): readonly Participant[];
+    includes(activity: Act, participant: Participant): boolean;
+    lastJoinIndex(participant: Participant): number | undefined;
+    resolveParticipant(name: Participant): Participant | undefined;
+}
 export type ValidationResult = {
     ok: true;
 } | {
@@ -120,14 +129,11 @@ export declare function audienceIncludes(audience: Audience, name: string): bool
 export declare function resolveAudience(audience: Audience, candidateNames: readonly string[]): string[];
 export declare function activeListeners(state: FoldedSquareState, sender: string): string[];
 export declare function isIgnored(state: FoldedSquareState, listener: string, sender: string): boolean;
-export declare function audienceBefore(acts: readonly Act[], say: Extract<Act, {
-    kind: 'say';
-}>): string[];
-/** Whether a peer say was directed to this participant when it landed. */
-export declare function landedAudienceIncludes(acts: readonly Act[], activity: Act, viewer: string): boolean;
 export declare function listeningTo(state: FoldedSquareState, listener: string): string[];
 export declare function isListening(state: FoldedSquareState, listener: string, sender: string): boolean;
 export declare function fold(acts: readonly Act[]): FoldedSquareState;
+/** Replay the activity stream once to fix every say's audience at landing. */
+export declare function replayLandedAudiences(acts: readonly Act[]): LandedAudienceReplay;
 export declare function validate(state: FoldedSquareState, act: Act, options?: SquareValidationOptions): ValidationResult;
 export declare function perceive(act: Act, viewer: Participant | string): Perception;
 export {};

package/dist/square-core.js

@@ -67,11 +67,9 @@ export function activeListeners(state, sender) {
 export function isIgnored(state, listener, sender) {
     return (state.ignored.get(nameKey(listener)) ?? []).some((target) => sameName(target, sender));
 }
-export function audienceBefore(acts, say) {
-    const position = acts.findIndex((act) => act === say || ('index' in act && 'index' in say && act.index === say.index));
-    const before = fold(position < 0 ? acts : acts.slice(0, position));
+function recipientsAtLanding(before, say) {
     const audience = audienceOf(say);
-    const mentionTargets = resolveAudience(audience, before.joined);
+    const mentionTargets = resolveAudience(audience, before.participants.filter((participant) => participant.joined).map((participant) => participant.name));
     const listeners = activeListeners(before, say.actor);
     const recipients = [];
     for (const name of [...mentionTargets, ...listeners]) {
@@ -83,12 +81,6 @@ export function audienceBefore(acts, say) {
     }
     return recipients;
 }
-/** Whether a peer say was directed to this participant when it landed. */
-export function landedAudienceIncludes(acts, activity, viewer) {
-    if (activity.kind !== 'say' || sameName(activity.actor, viewer))
-        return false;
-    return audienceBefore(acts, activity).some((recipient) => sameName(recipient, viewer));
-}
 export function listeningTo(state, listener) {
     return [...(state.listening.get(nameKey(listener)) ?? [])];
 }
@@ -142,97 +134,154 @@ function bellRecentAt(state, actor, at, windowMs) {
     }
     return latest;
 }
-export function fold(acts) {
+function createFoldAccumulator() {
     const ordered = [];
     const byKey = new Map();
     const hold = { active: false };
-    const state = {
-        participants: ordered,
-        hold,
-        joined: [],
-        done: [],
-        throttleActivityAts: [],
-        bellSayAtsByActor: new Map(),
-        listening: new Map(),
-        ignored: new Map(),
+    return {
+        byKey,
+        ordered,
+        state: {
+            participants: ordered,
+            hold,
+            joined: [],
+            done: [],
+            throttleActivityAts: [],
+            bellSayAtsByActor: new Map(),
+            listening: new Map(),
+            ignored: new Map(),
+        },
     };
-    for (const act of acts) {
-        const actor = actorOf(act);
-        const snapshot = actor === undefined ? undefined : touchParticipant(byKey, ordered, actor);
-        switch (act.kind) {
-            case 'join':
-                if (snapshot !== undefined) {
-                    snapshot.joined = true;
-                    snapshot.done = false;
-                    snapshot.lastActiveAt = act.at ?? snapshot.lastActiveAt;
-                }
-                break;
-            case 'done':
-                if (snapshot !== undefined) {
-                    snapshot.joined = false;
-                    snapshot.done = true;
-                    snapshot.lastActiveAt = act.at ?? snapshot.lastActiveAt;
-                    state.listening.delete(nameKey(snapshot.name));
-                }
-                break;
-            case 'listen': {
-                const key = nameKey(act.actor);
-                const targets = state.listening.get(key) ?? [];
-                if (!targets.some((target) => sameName(target, act.target)))
-                    targets.push(act.target);
-                state.listening.set(key, targets);
-                const ignored = (state.ignored.get(key) ?? []).filter((target) => !sameName(target, act.target));
-                if (ignored.length === 0)
-                    state.ignored.delete(key);
-                else
-                    state.ignored.set(key, ignored);
-                break;
+}
+function applyActivity(accumulator, act) {
+    const { state, byKey, ordered } = accumulator;
+    const actor = actorOf(act);
+    const snapshot = actor === undefined ? undefined : touchParticipant(byKey, ordered, actor);
+    switch (act.kind) {
+        case 'join':
+            if (snapshot !== undefined) {
+                snapshot.joined = true;
+                snapshot.done = false;
+                snapshot.lastActiveAt = act.at ?? snapshot.lastActiveAt;
             }
-            case 'ignore': {
-                const key = nameKey(act.actor);
-                const targets = (state.listening.get(key) ?? []).filter((target) => !sameName(target, act.target));
-                if (targets.length === 0)
-                    state.listening.delete(key);
-                else
-                    state.listening.set(key, targets);
-                const ignored = state.ignored.get(key) ?? [];
-                if (!ignored.some((target) => sameName(target, act.target)))
-                    ignored.push(act.target);
-                state.ignored.set(key, ignored);
-                break;
+            break;
+        case 'done':
+            if (snapshot !== undefined) {
+                snapshot.joined = false;
+                snapshot.done = true;
+                snapshot.lastActiveAt = act.at ?? snapshot.lastActiveAt;
+                state.listening.delete(nameKey(snapshot.name));
             }
-            case 'say':
-                if (snapshot !== undefined) {
-                    snapshot.activityCount += 1;
-                    snapshot.lastActiveAt = act.at ?? snapshot.lastActiveAt;
-                }
-                pushThrottleAt(state, act.at);
-                if (act.reach === 'bell')
-                    pushBellAt(state, act.actor, act.at);
-                break;
-            case 'hold':
-                hold.active = true;
-                hold.at = act.at;
-                hold.reason = act.body;
-                hold.actor = act.actor;
-                break;
-            case 'resume':
-                hold.active = false;
-                delete hold.at;
-                delete hold.reason;
-                delete hold.actor;
-                break;
-            case 'read':
-                if (snapshot !== undefined) {
-                    snapshot.lastReadThrough = Math.max(snapshot.lastReadThrough, act.through);
-                }
-                break;
+            break;
+        case 'listen': {
+            const key = nameKey(act.actor);
+            const targets = state.listening.get(key) ?? [];
+            if (!targets.some((target) => sameName(target, act.target)))
+                targets.push(act.target);
+            state.listening.set(key, targets);
+            const ignored = (state.ignored.get(key) ?? []).filter((target) => !sameName(target, act.target));
+            if (ignored.length === 0)
+                state.ignored.delete(key);
+            else
+                state.ignored.set(key, ignored);
+            break;
+        }
+        case 'ignore': {
+            const key = nameKey(act.actor);
+            const targets = (state.listening.get(key) ?? []).filter((target) => !sameName(target, act.target));
+            if (targets.length === 0)
+                state.listening.delete(key);
+            else
+                state.listening.set(key, targets);
+            const ignored = state.ignored.get(key) ?? [];
+            if (!ignored.some((target) => sameName(target, act.target)))
+                ignored.push(act.target);
+            state.ignored.set(key, ignored);
+            break;
         }
+        case 'say':
+            if (snapshot !== undefined) {
+                snapshot.activityCount += 1;
+                snapshot.lastActiveAt = act.at ?? snapshot.lastActiveAt;
+            }
+            pushThrottleAt(state, act.at);
+            if (act.reach === 'bell')
+                pushBellAt(state, act.actor, act.at);
+            break;
+        case 'hold':
+            state.hold.active = true;
+            state.hold.at = act.at;
+            state.hold.reason = act.body;
+            state.hold.actor = act.actor;
+            break;
+        case 'resume':
+            state.hold.active = false;
+            delete state.hold.at;
+            delete state.hold.reason;
+            delete state.hold.actor;
+            break;
+        case 'read':
+            if (snapshot !== undefined) {
+                snapshot.lastReadThrough = Math.max(snapshot.lastReadThrough, act.through);
+            }
+            break;
     }
+}
+function finishFold(accumulator) {
+    const { state, ordered } = accumulator;
     state.joined = ordered.filter((item) => item.joined).map((item) => item.name);
     state.done = ordered.filter((item) => item.done).map((item) => item.name);
     return state;
 }
+export function fold(acts) {
+    const accumulator = createFoldAccumulator();
+    for (const act of acts)
+        applyActivity(accumulator, act);
+    return finishFold(accumulator);
+}
+/** Replay the activity stream once to fix every say's audience at landing. */
+export function replayLandedAudiences(acts) {
+    const accumulator = createFoldAccumulator();
+    const byActivity = new Map();
+    const byIndex = new Map();
+    const lastJoinByKey = new Map();
+    for (const act of acts) {
+        if (act.kind === 'say') {
+            const recipients = recipientsAtLanding(accumulator.state, act);
+            byActivity.set(act, recipients);
+            const index = 'index' in act ? act.index : undefined;
+            if (typeof index === 'number')
+                byIndex.set(index, recipients);
+        }
+        if (act.kind === 'join' && 'index' in act && typeof act.index === 'number') {
+            lastJoinByKey.set(nameKey(act.actor), act.index);
+        }
+        applyActivity(accumulator, act);
+    }
+    const state = finishFold(accumulator);
+    const participants = state.participants.map((participant) => participant.name);
+    function recipientsFor(activity) {
+        const direct = byActivity.get(activity);
+        if (direct !== undefined)
+            return direct;
+        const index = 'index' in activity ? activity.index : undefined;
+        return typeof index === 'number' ? byIndex.get(index) ?? [] : [];
+    }
+    function resolveParticipant(name) {
+        return participants.find((participant) => sameName(participant, name));
+    }
+    return {
+        participants,
+        joined: state.joined,
+        replayedActivityCount: acts.length,
+        recipientsFor,
+        includes: (activity, participant) => activity.kind === 'say'
+            && !sameName(activity.actor, participant)
+            && recipientsFor(activity).some((recipient) => sameName(recipient, participant)),
+        lastJoinIndex: (participant) => lastJoinByKey.get(nameKey(participant)),
+        resolveParticipant,
+    };
+}
 export function validate(state, act, options = {}) {
     const actor = actorOf(act);
     const current = actor === undefined ? undefined : currentParticipant(state, actor);

package/dist/square-storage.js

@@ -116,25 +116,36 @@ export function createFileCell(squarePath) {
     let closed = false;
     let version = 0;
     let fingerprint = fileFingerprint(squarePath);
+    let cached;
     function observe() {
         const next = fileFingerprint(squarePath);
-        if (next === fingerprint)
-            return;
-        fingerprint = next;
-        version += 1;
+        if (next !== fingerprint) {
+            fingerprint = next;
+            cached = undefined;
+            version += 1;
+        }
+        return fingerprint;
+    }
+    function currentState() {
+        const observed = observe();
+        if (cached?.fingerprint === observed)
+            return cloneState(cached.state);
+        const decoded = readSquareFile(squarePath);
+        cached = { fingerprint: observed, state: cloneState(decoded) };
+        return cloneState(cached.state);
     }
     return {
         async transact(fn) {
             assertCellOpen(closed);
             return withFileLock(`${squarePath}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, () => {
                 assertCellOpen(closed);
-                observe();
-                const current = readSquareFile(squarePath);
+                const current = currentState();
                 const working = cloneState(current);
                 const outcome = fn(working, version);
                 if (outcome.state !== undefined) {
                     writeSquareSnapshot(squarePath, outcome.state);
                     fingerprint = fileFingerprint(squarePath);
+                    cached = { fingerprint, state: cloneState(outcome.state) };
                     version += 1;
                 }
                 return outcome.result;
@@ -142,9 +153,7 @@ export function createFileCell(squarePath) {
         },
         async read() {
             assertCellOpen(closed);
-            observe();
-            const state = readSquareFile(squarePath);
-            return { state: cloneState(state), version };
+            return { state: currentState(), version };
         },
         async changed(sinceVersion, timeoutMs) {
             assertCellOpen(closed);

package/dist/views.d.ts

@@ -1,6 +1,6 @@
 import { type ActivityId } from './square-core.js';
 import { coreParticipants, coreStatus } from './decisions.js';
-import { type PlannedNotification } from './delivery.js';
+import { type DeliveryModel, type PlannedNotification } from './delivery.js';
 import { type ActivitiesOptions, type ActivityObservation, type InboxNotification, type PublicAct, type RoomChangeAct, type SquareState, type StoredAct } from './model.js';
 import type { OpenSquare } from './open-square.js';
 import type { Activity, HistoryQuery, ParticipantStatus, PerceivedActivity, SquareSnapshot } from './square-facade.js';
@@ -96,6 +96,7 @@ export declare function watchPresentation(square: OpenSquare, name: string): Pro
 export declare function inboxProjection(square: OpenSquare, name: string, ownerId: string): Promise<InboxProjection>;
 export declare function streamProjection(square: OpenSquare, cursor: number, recipient?: string): Promise<StreamProjection>;
 export declare function notificationForAct(square: OpenSquare, actIndex: number): Promise<readonly PlannedNotification[]>;
+export declare function pendingDeliveriesFromState(state: SquareState, delivery?: DeliveryModel): readonly PendingDeliveryProjection[];
 export declare function pendingDeliveries(square: OpenSquare): Promise<readonly PendingDeliveryProjection[]>;
 export declare function notificationEvidence(square: OpenSquare, recipient: string, actIndex: number): Promise<{
     readonly delivered: boolean;

package/dist/views.js

@@ -1,16 +1,16 @@
 import { extractMentions, formatActivityId, parseActivityId } from './square-core.js';
 import { deliveryDelta, directedPeerSays } from './activity-feed.js';
 import { coreActivities, coreParticipants, coreStatus, resolveKnownName } from './decisions.js';
-import { deriveDeliveryModel, isActivitySeen, perceiveActivity, planActNotifications } from './delivery.js';
+import { deriveDeliveryModel, isActivitySeen } from './delivery.js';
 import { SquareError, nameKey } from './model.js';
-import { countSays, currentHold, foldedState, freshWatchLease, inSquareCount, isCurrentlyJoined, observationFor, readCursor, resolveRosterName, rosterNames, watchTerminalStatus } from './runtime.js';
+import { countSays, currentHold, foldedState, freshWatchLease, inSquareCount, isCurrentlyJoined, resolveRosterName, rosterNames, watchTerminalStatus } from './runtime.js';
 function expose(stored) {
     if (stored.kind === 'read' || stored.actor === undefined)
         throw new Error(`Cannot expose stored activity ${formatActivityId(stored.index)}`);
     return { id: formatActivityId(stored.index), at: stored.at, kind: stored.kind, actor: stored.actor, ...('body' in stored && stored.body !== undefined ? { body: stored.body } : {}), mentions: stored.kind === 'say' ? extractMentions(stored.body) : [], ...('target' in stored ? { target: stored.target } : {}), ...(stored.kind === 'say' && stored.reply !== undefined ? { reply: formatActivityId(stored.reply) } : {}) };
 }
-function exposePerceived(state, stored, viewer) {
-    const perception = perceiveActivity(state, stored, viewer);
+function exposePerceived(stored, viewer, delivery) {
+    const perception = delivery.perceive(stored, viewer);
     const activity = expose(stored);
     if (perception === 'full' || activity.body === undefined)
         return { ...activity, perception };
@@ -36,12 +36,16 @@ function selectHistory(stored, query) {
     return query.order === 'desc' ? selected.reverse() : selected;
 }
 function statuses(square, state) {
-    return coreStatus(state, square.clock()).participants.filter((participant) => participant.state !== 'not joined').map((participant) => ({ name: participant.name, state: participant.state === 'done' ? 'done' : 'joined', consumedThrough: readCursor(state, participant.name) < 0 ? null : formatActivityId(readCursor(state, participant.name)), watching: participant.presence === 'watching', listening: participant.listening }));
+    const delivery = deriveDeliveryModel(state);
+    return coreStatus(state, square.clock(), delivery).participants.filter((participant) => participant.state !== 'not joined').map((participant) => {
+        const cursor = delivery.cursorFor(participant.name);
+        return { name: participant.name, state: participant.state === 'done' ? 'done' : 'joined', consumedThrough: cursor < 0 ? null : formatActivityId(cursor), watching: participant.presence === 'watching', listening: participant.listening };
+    });
 }
-function anchors(state) {
+function anchors(state, delivery) {
     const result = {};
-    for (const name of rosterNames(state)) {
-        const activity = state.acts.findLast((candidate) => candidate.index <= readCursor(state, name) && (candidate.kind === 'say' || candidate.kind === 'done'));
+    for (const name of delivery.participants()) {
+        const activity = state.acts.findLast((candidate) => candidate.index <= delivery.cursorFor(name) && (candidate.kind === 'say' || candidate.kind === 'done'));
         if (activity !== undefined)
             result[activity.index] = [...(result[activity.index] ?? []), name];
     }
@@ -59,25 +63,26 @@ function sayNumbers(state) {
     return result;
 }
 export async function history(square, query = {}) { const { state } = await square.cell.read(); return selectHistory(coreActivities(state, historyOptions(query)), query).map(expose); }
-export async function participantHistory(square, name, query = {}) { const { state } = await square.cell.read(); const viewer = resolveKnownName(state, name); const effective = query.all === true || query.limit !== undefined ? query : { ...query, limit: 10 }; return selectHistory(coreActivities(state, historyOptions(effective, viewer)), effective).map((activity) => exposePerceived(state, activity, viewer)); }
+export async function participantHistory(square, name, query = {}) { const { state } = await square.cell.read(); const viewer = resolveKnownName(state, name); const delivery = deriveDeliveryModel(state); const effective = query.all === true || query.limit !== undefined ? query : { ...query, limit: 10 }; return selectHistory(coreActivities(state, historyOptions(effective, viewer), delivery), effective).map((activity) => exposePerceived(activity, viewer, delivery)); }
 export async function resolveParticipant(square, name) { const { state } = await square.cell.read(); return { name: resolveKnownName(state, name), roster: rosterNames(state) }; }
 export async function currentParticipant(square, name) { const { state } = await square.cell.read(); const known = resolveRosterName(state, name); return known !== undefined && isCurrentlyJoined(state.acts, known) ? known : undefined; }
 export async function participants(square) { const { state } = await square.cell.read(); return statuses(square, state); }
 export async function snapshot(square) { const { state } = await square.cell.read(); const folded = foldedState(state); return { context: [...state.preamble, ...state.warmup].join('\n'), actCount: state.acts.filter((activity) => activity.kind !== 'read').length, hardCap: state.hardCap, ...(state.throttlePerMinute === undefined ? {} : { throttlePerMinute: state.throttlePerMinute }), held: folded.hold.active && folded.hold.actor !== undefined ? { by: folded.hold.actor, ...(folded.hold.reason === undefined ? {} : { reason: folded.hold.reason }) } : null, participants: statuses(square, state), delivered(name, id) { return isActivitySeen(state, name, parseRequiredActivityId(id)); } }; }
-export async function activityPresentation(square, name) { const { state } = await square.cell.read(); const known = resolveKnownName(state, name); const delta = deliveryDelta(state, known); const hold = currentHold(state.acts); return { name: known, roster: rosterNames(state), pendingPublic: directedPeerSays(state, delta, known), pendingRoomChanges: [], activities: state.acts, state, participantCount: inSquareCount(state), held: hold.active, ...(hold.reason === undefined ? {} : { holdReason: hold.reason }), ownActivityCount: countSays(state.acts, known), hardCap: state.hardCap }; }
+export async function activityPresentation(square, name) { const { state } = await square.cell.read(); const known = resolveKnownName(state, name); const delivery = deriveDeliveryModel(state); const delta = deliveryDelta(state, known, delivery); const hold = currentHold(state.acts); return { name: known, roster: rosterNames(state), pendingPublic: directedPeerSays(state, delta, known, delivery), pendingRoomChanges: [], activities: state.acts, state, participantCount: inSquareCount(state), held: hold.active, ...(hold.reason === undefined ? {} : { holdReason: hold.reason }), ownActivityCount: countSays(state.acts, known), hardCap: state.hardCap }; }
 export async function entryPresentation(square, name, lastN = 10) { const { state } = await square.cell.read(); const known = resolveRosterName(state, name) ?? name; const publicActivities = state.acts.filter((activity) => activity.kind === 'say' || activity.kind === 'done'); return { joined: isCurrentlyJoined(state.acts, known), scene: state.warmup.join('\n').trim(), context: state.preamble.join('\n').trim(), joinContext: (state.preamble.at(-1) === '---' ? state.preamble.slice(0, -1) : state.preamble).join('\n').trim(), recentActivities: lastN === null ? publicActivities : publicActivities.slice(-lastN), state, sayNumbers: sayNumbers(state), participantCount: inSquareCount(state) }; }
-export async function historyPresentation(square, options) { const { state } = await square.cell.read(); return { activities: coreActivities(state, options).map((activity) => ({ ...activity, perception: options.viewer === undefined ? 'full' : perceiveActivity(state, activity, options.viewer) })), sayNumbers: sayNumbers(state), presenceAnchors: anchors(state), participantCount: inSquareCount(state) }; }
-export async function participantsPresentation(square) { const { state } = await square.cell.read(); return coreParticipants(state, square.clock()); }
+export async function historyPresentation(square, options) { const { state } = await square.cell.read(); const delivery = deriveDeliveryModel(state); return { activities: coreActivities(state, options, delivery).map((activity) => ({ ...activity, perception: options.viewer === undefined ? 'full' : delivery.perceive(activity, options.viewer) })), sayNumbers: sayNumbers(state), presenceAnchors: anchors(state, delivery), participantCount: inSquareCount(state) }; }
+export async function participantsPresentation(square) { const { state } = await square.cell.read(); const delivery = deriveDeliveryModel(state); return coreParticipants(state, square.clock(), delivery); }
 export async function listPresentation(square) { const { state } = await square.cell.read(); return { context: state.preamble, participants: foldedState(state).participants.filter((participant) => participant.joined).sort((left, right) => (right.lastActiveAt ?? -Infinity) - (left.lastActiveAt ?? -Infinity) || left.name.localeCompare(right.name)).map((participant) => participant.name), activities: state.acts.filter((activity) => activity.kind === 'say').length }; }
-export async function statusPresentation(square) { const { state } = await square.cell.read(); const status = coreStatus(state, square.clock()); return { state, status, ...(status.latestAct?.kind === 'say' ? { latestActNumber: countSays(state.acts, status.latestAct.actor) } : {}) }; }
+export async function statusPresentation(square) { const { state } = await square.cell.read(); const delivery = deriveDeliveryModel(state); const status = coreStatus(state, square.clock(), delivery); return { state, status, ...(status.latestAct?.kind === 'say' ? { latestActNumber: countSays(state.acts, status.latestAct.actor) } : {}) }; }
 export async function eventPresentation(square, id) { const { state } = await square.cell.read(); const activity = state.acts.find((candidate) => candidate.index === parseRequiredActivityId(id)); if (activity === undefined)
     throw new SquareError('invalid_args', `Unknown activity id: ${id}`); return { activity, participantCount: inSquareCount(state), held: currentHold(state.acts).active }; }
-export async function watchPresentation(square, name) { const { state } = await square.cell.read(); const known = resolveKnownName(state, name); const now = square.clock(); const terminal = watchTerminalStatus(state, known); return { activities: state.acts, state, participantCount: inSquareCount(state), presence: { participants: coreParticipants(state, now), now }, ...(terminal === undefined ? {} : { terminalStatus: terminal }) }; }
-export async function inboxProjection(square, name, ownerId) { const { state } = await square.cell.read(); const known = resolveRosterName(state, name); if (known === undefined || !isCurrentlyJoined(state.acts, known))
-    return { name, joined: false, notifications: [] }; const lease = freshWatchLease(state, known, square.clock()); return { name: known, joined: true, notifications: deriveDeliveryModel(state).pendingFor(known).map(({ item, route }) => ({ actIndex: item.index, actor: item.actor, at: item.at, route, body: item.body })), ...(lease?.ownerId === ownerId ? { catchLease: lease } : {}) }; }
-export async function streamProjection(square, cursor, recipient) { const { state } = await square.cell.read(); return { activities: state.acts.filter((activity) => activity.index > cursor).flatMap((activity) => { if (recipient === undefined)
-        return [{ activity }]; const notification = planActNotifications(state, activity).find((candidate) => nameKey(candidate.recipient) === nameKey(recipient)); return notification === undefined ? [] : [{ activity, route: notification.route }]; }), cursor: Math.max(cursor, ...state.acts.map((activity) => activity.index)) }; }
-export async function notificationForAct(square, actIndex) { const { state } = await square.cell.read(); const activity = state.acts.find((candidate) => candidate.index === actIndex); return activity === undefined ? [] : planActNotifications(state, activity); }
-export async function pendingDeliveries(square) { const { state } = await square.cell.read(); return [...new Set(state.acts.filter((activity) => activity.kind === 'join').map((activity) => activity.actor))].filter((name) => isCurrentlyJoined(state.acts, name)).map((recipient) => ({ recipient, notifications: deriveDeliveryModel(state).pendingFor(recipient) })); }
-export async function notificationEvidence(square, recipient, actIndex) { const { state } = await square.cell.read(); return { delivered: isActivitySeen(state, recipient, actIndex), observation: observationFor(state, recipient, actIndex) }; }
-export async function notificationDelivered(square, recipient, actIndex) { const { state } = await square.cell.read(); return isActivitySeen(state, recipient, actIndex); }
+export async function watchPresentation(square, name) { const { state } = await square.cell.read(); const known = resolveKnownName(state, name); const now = square.clock(); const terminal = watchTerminalStatus(state, known); const delivery = deriveDeliveryModel(state); return { activities: state.acts, state, participantCount: inSquareCount(state), presence: { participants: coreParticipants(state, now, delivery), now }, ...(terminal === undefined ? {} : { terminalStatus: terminal }) }; }
+export async function inboxProjection(square, name, ownerId) { const { state } = await square.cell.read(); const delivery = deriveDeliveryModel(state); const known = delivery.knownParticipant(name); if (known === undefined || !delivery.joinedRecipients().some((recipient) => nameKey(recipient) === nameKey(known)))
+    return { name, joined: false, notifications: [] }; const lease = freshWatchLease(state, known, square.clock()); return { name: known, joined: true, notifications: delivery.pendingFor(known).map(({ item, route }) => ({ actIndex: item.index, actor: item.actor, at: item.at, route, body: item.body })), ...(lease?.ownerId === ownerId ? { catchLease: lease } : {}) }; }
+export async function streamProjection(square, cursor, recipient) { const { state } = await square.cell.read(); const delivery = recipient === undefined ? undefined : deriveDeliveryModel(state); return { activities: state.acts.filter((activity) => activity.index > cursor).flatMap((activity) => { if (delivery === undefined || recipient === undefined)
+        return [{ activity }]; const notification = delivery.plan(activity).find((candidate) => nameKey(candidate.recipient) === nameKey(recipient)); return notification === undefined ? [] : [{ activity, route: notification.route }]; }), cursor: Math.max(cursor, ...state.acts.map((activity) => activity.index)) }; }
+export async function notificationForAct(square, actIndex) { const { state } = await square.cell.read(); const activity = state.acts.find((candidate) => candidate.index === actIndex); return activity === undefined ? [] : deriveDeliveryModel(state).plan(activity); }
+export function pendingDeliveriesFromState(state, delivery = deriveDeliveryModel(state)) { return delivery.joinedRecipients().map((recipient) => ({ recipient, notifications: delivery.pendingFor(recipient) })); }
+export async function pendingDeliveries(square) { const { state } = await square.cell.read(); return pendingDeliveriesFromState(state); }
+export async function notificationEvidence(square, recipient, actIndex) { const { state } = await square.cell.read(); const delivery = deriveDeliveryModel(state); const known = delivery.knownParticipant(recipient) ?? recipient; return { delivered: delivery.isSeen(known, actIndex), observation: state.runtime.observations?.[known]?.[formatActivityId(actIndex)] }; }
+export async function notificationDelivered(square, recipient, actIndex) { const { state } = await square.cell.read(); return deriveDeliveryModel(state).isSeen(recipient, actIndex); }

package/dist/wake-evidence.d.ts

@@ -1,4 +1,6 @@
 import { type WakeRoute } from './model.js';
+import { type DeliveryModel } from './delivery.js';
+import { type SquareState } from './model.js';
 import { type WakeAttempt } from './wake-attempts.js';
 export interface WakeEvidence {
     delivered: boolean;
@@ -8,6 +10,12 @@ export interface WakeEvidence {
     terminal?: WakeAttempt;
     attemptableRoutes: WakeRoute[];
 }
+export interface WakeEvidenceProjection {
+    evidence(recipient: string, actIndex: number): WakeEvidence;
+}
+/** Capture the primary wake facts once and derive any number of eligibility decisions from them. */
+export declare function wakeEvidenceProjection(squarePath: string, now: number, env: NodeJS.ProcessEnv): Promise<WakeEvidenceProjection>;
+export declare function wakeEvidenceProjectionFromState(squarePath: string, state: SquareState, now: number, env: NodeJS.ProcessEnv, delivery?: DeliveryModel): WakeEvidenceProjection;
 /** Project every wake decision from the same primary evidence. */
 export declare function wakeEvidence(squarePath: string, recipient: string, actIndex: number, now: number, env: NodeJS.ProcessEnv): Promise<WakeEvidence>;
 export declare function wakeIsEligible(evidence: WakeEvidence): boolean;