@astrosheep/square 0.3.63 → 0.3.64

package/dist/views.d.ts

@@ -1,14 +1,13 @@
 import { type ActivityId } from './square-core.js';
 import { coreParticipants, coreStatus } from './decisions.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 ActivitiesOptions, type PublicAct, type SquareState, type StoredAct } from './model.js';
 import type { OpenSquare } from './open-square.js';
 import type { Activity, HistoryQuery, OperationControl, ParticipantStatus, SquareSnapshot } from './square-facade.js';
 export interface ActivityPresentation {
     readonly name: string;
     readonly roster: readonly string[];
     readonly pendingPublic: readonly PublicAct[];
-    readonly pendingRoomChanges: readonly RoomChangeAct[];
     readonly activities: readonly StoredAct[];
     readonly state: SquareState;
     readonly participantCount: number;
@@ -53,12 +52,6 @@ export interface WatchPresentation {
     };
     readonly terminalStatus?: 'capped' | 'quorum';
 }
-export interface InboxProjection {
-    readonly name: string;
-    readonly joined: boolean;
-    readonly notifications: readonly InboxNotification[];
-    readonly catchLease?: import('./model.js').WatchLease;
-}
 export interface StreamProjection {
     readonly activities: readonly {
         readonly activity: StoredAct;
@@ -71,6 +64,9 @@ export interface PendingDeliveryProjection {
     readonly recipient: string;
     readonly notifications: readonly PlannedNotification[];
 }
+/** The one StoredAct-to-public-Activity field mapping. Rejects read and actorless acts. */
+export declare function toPublicActivity(stored: StoredAct): Activity;
+export declare function parseRequiredActivityId(id: ActivityId): number;
 export declare function history(square: OpenSquare, query?: HistoryQuery, control?: OperationControl): Promise<Activity[]>;
 export declare function participantHistory(square: OpenSquare, _name: string, query?: HistoryQuery, control?: OperationControl): Promise<Activity[]>;
 export declare function resolveParticipant(square: OpenSquare, name: string): Promise<{
@@ -92,7 +88,6 @@ export declare function eventPresentation(square: OpenSquare, id: ActivityId): P
     readonly held: boolean;
 }>;
 export declare function watchPresentation(square: OpenSquare, name: string): Promise<WatchPresentation>;
-export declare function inboxProjection(square: OpenSquare, name: string, _sessionId?: string): Promise<InboxProjection>;
 export declare function streamProjection(square: OpenSquare | {
     readonly cell: {
         read(): Promise<{
@@ -107,11 +102,4 @@ export declare function streamTailProjection(square: OpenSquare | {
         }>;
     };
 }, last?: 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;
-    readonly observation: ActivityObservation | undefined;
-}>;
-export declare function notificationDelivered(square: OpenSquare, recipient: string, actIndex: number): Promise<boolean>;

package/dist/views.js

@@ -3,13 +3,14 @@ import { deliveryDelta, directedPeerSays } from './activity-feed.js';
 import { coreActivities, coreParticipants, coreStatus, resolveKnownName } from './decisions.js';
 import { deriveDeliveryModel, isActivitySeen } from './delivery.js';
 import { SquareError, nameKey } from './model.js';
-import { countSays, currentHold, foldedState, freshWatchLease, inSquareCount, isCurrentlyJoined, presenceAnchor, resolveRosterName, rosterNames, watchTerminalStatus } from './runtime.js';
-function expose(stored) {
+import { countSays, currentHold, foldedState, inSquareCount, isCurrentlyJoined, presenceAnchor, resolveRosterName, rosterNames, watchTerminalStatus } from './runtime.js';
+/** The one StoredAct-to-public-Activity field mapping. Rejects read and actorless acts. */
+export function toPublicActivity(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, ...(stored.kind === 'say' && stored.reach !== undefined ? { reach: stored.reach } : {}), ...('body' in stored && stored.body !== undefined ? { body: stored.body } : {}), mentions: stored.kind === 'say' ? stored.mentions ?? [] : [], ...('target' in stored ? { target: stored.target } : {}), ...(stored.kind === 'say' && stored.reply !== undefined ? { reply: formatActivityId(stored.reply) } : {}) };
 }
-function parseRequiredActivityId(id) {
+export function parseRequiredActivityId(id) {
     const index = parseActivityId(id);
     if (index === undefined)
         throw new SquareError('invalid_args', `Invalid activity id: ${id}`);
@@ -59,13 +60,13 @@ function sayNumbers(state) {
         }
     return result;
 }
-export async function history(square, query = {}, control) { const { state } = await square.artifact.read(control?.signal); return selectHistory(coreActivities(state, historyOptions(query)), query).map(expose); }
-export async function participantHistory(square, _name, query = {}, control) { const { state } = await square.artifact.read(control?.signal); const effective = query.limit !== undefined ? query : { ...query, limit: 10 }; return selectHistory(coreActivities(state, historyOptions(effective)), effective).map(expose); }
+export async function history(square, query = {}, control) { const { state } = await square.artifact.read(control?.signal); return selectHistory(coreActivities(state, historyOptions(query)), query).map(toPublicActivity); }
+export async function participantHistory(square, _name, query = {}, control) { const { state } = await square.artifact.read(control?.signal); const effective = query.limit !== undefined ? query : { ...query, limit: 10 }; return selectHistory(coreActivities(state, historyOptions(effective)), effective).map(toPublicActivity); }
 export async function resolveParticipant(square, name) { const { state } = await square.artifact.read(); return { name: resolveKnownName(state, name), roster: rosterNames(state) }; }
 export async function currentParticipant(square, name) { const { state } = await square.artifact.read(); const known = resolveRosterName(state, name); return known !== undefined && isCurrentlyJoined(state.acts, known) ? known : undefined; }
 export async function participants(square) { const { state } = await square.artifact.read(); return statuses(square, state); }
 export async function snapshot(square) { const { state } = await square.artifact.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.artifact.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 activityPresentation(square, name) { const { state } = await square.artifact.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), 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.artifact.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.artifact.read(); const delivery = deriveDeliveryModel(state); return { activities: coreActivities(state, options, delivery), sayNumbers: sayNumbers(state), presenceAnchors: anchors(state, delivery), participantCount: inSquareCount(state) }; }
 export async function participantsPresentation(square) { const { state } = await square.artifact.read(); const delivery = deriveDeliveryModel(state); return coreParticipants(state, square.clock(), delivery); }
@@ -74,8 +75,6 @@ export async function statusPresentation(square) { const { state } = await squar
 export async function eventPresentation(square, id) { const { state } = await square.artifact.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.artifact.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, _sessionId) { const { state } = await square.artifact.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 === undefined ? {} : { catchLease: lease }) }; }
 const STREAM_BATCH_MAX = 100;
 function projectStreamActivities(state, activities, recipient) {
     const delivery = recipient === undefined ? undefined : deriveDeliveryModel(state);
@@ -86,12 +85,6 @@ function projectStreamActivities(state, activities, recipient) {
         return notification === undefined ? [] : [{ activity, route: notification.route }];
     });
 }
-function selectStreamTail(activities, last) {
-    if (!Number.isSafeInteger(last) || last < 0 || last > STREAM_BATCH_MAX) {
-        throw new SquareError('invalid_args', `Invalid stream tail: expected a non-negative safe integer no greater than ${STREAM_BATCH_MAX}.`);
-    }
-    return last === 0 ? [] : activities.slice(-last);
-}
 export async function streamProjection(square, cursor, recipient) {
     const artifact = 'artifact' in square ? square.artifact : square.cell;
     const { state } = await artifact.read();
@@ -106,14 +99,14 @@ export async function streamProjection(square, cursor, recipient) {
 export async function streamTailProjection(square, last = 10, recipient) {
     const artifact = 'artifact' in square ? square.artifact : square.cell;
     const { state } = await artifact.read();
+    const activities = projectStreamActivities(state, state.acts, recipient);
+    if (!Number.isSafeInteger(last) || last < 0 || last > STREAM_BATCH_MAX) {
+        throw new SquareError('invalid_args', `Invalid stream tail: expected a non-negative safe integer no greater than ${STREAM_BATCH_MAX}.`);
+    }
     return {
-        activities: selectStreamTail(projectStreamActivities(state, state.acts, recipient), last),
+        activities: last === 0 ? [] : activities.slice(-last),
         cursor: state.acts.at(-1)?.index ?? -1,
         hasMore: false,
     };
 }
-export async function notificationForAct(square, actIndex) { const { state } = await square.artifact.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.artifact.read(); return pendingDeliveriesFromState(state); }
-export async function notificationEvidence(square, recipient, actIndex) { const { state } = await square.artifact.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.artifact.read(); return deriveDeliveryModel(state).isSeen(recipient, actIndex); }

package/dist/wake-attempts.d.ts

@@ -1,51 +1,5 @@
-import { type WakeRouteKind } from './model.js';
-import type { WakeAttempt as ProjectedWakeAttempt } from './square-projections.js';
-export { hasAttemptableWakeRoute, isWakeRouteAttemptable, terminalWakeEvidence } from './square-projections.js';
-export type WakeOutcome = 'accepted' | 'unknown' | 'failed';
-export interface WakeAttention {
-    squarePath: string;
-    actIndex: number;
-    recipient: string;
-}
-export interface WakeReleaseDiagnostic {
-    readonly at: number;
-    readonly attention: WakeAttention;
-    readonly routeKind?: WakeRouteKind;
-    readonly attemptN?: number;
-    readonly session?: string;
-    readonly signature?: string;
-    readonly message?: string;
-    readonly diagnostic?: unknown;
-}
-export type WakeAttempt = ProjectedWakeAttempt;
-export interface WakeDispatchLease {
-    readonly leaseId: string;
-    readonly expiresAt: number;
-    readonly phase: 'claimed' | 'dispatching';
-    readonly routeKind?: WakeRouteKind;
-    readonly attemptN?: number;
-    readonly session?: string;
-}
-export type WakeDispatchClaim = {
-    readonly type: 'acquired';
-    readonly leaseId: string;
-} | {
-    readonly type: 'busy';
-} | {
-    readonly type: 'ambiguous';
-    readonly lease: WakeDispatchLease;
-};
-export declare function wakeAttemptsPath(env?: NodeJS.ProcessEnv): string;
-export declare function wakeAttentionKey(attention: WakeAttention): Promise<string>;
-export declare function claimWakeDispatch(attention: WakeAttention, leaseId: string, leaseMs: number, env?: NodeJS.ProcessEnv, at?: number, session?: string): Promise<WakeDispatchClaim>;
-export declare function transitionWakeDispatch(attention: WakeAttention, leaseId: string, phase: WakeDispatchLease['phase'], leaseMs: number, routeKind: WakeRouteKind | undefined, attemptN: number | undefined, session: string | undefined, env?: NodeJS.ProcessEnv, at?: number): Promise<boolean>;
-export declare function releaseWakeDispatch(attention: WakeAttention, leaseId: string, env?: NodeJS.ProcessEnv, at?: number): Promise<void>;
-export declare function readWakeAttempts(opts?: {
-    attention?: WakeAttention;
-    sessionId?: string;
-    now?: number;
-    env?: NodeJS.ProcessEnv;
-}): Promise<WakeAttempt[]>;
+import type { WakeAttention } from './host-ledger.js';
+import { type WakeReleaseDiagnostic } from './wake-evidence.js';
 export declare function redactWakeDiagnostic(value: unknown, env?: NodeJS.ProcessEnv): unknown;
 export declare function readWakeReleaseDiagnostics(opts?: {
     location?: string;
@@ -54,11 +8,3 @@ export declare function readWakeReleaseDiagnostics(opts?: {
     now?: number;
     env?: NodeJS.ProcessEnv;
 }): Promise<WakeReleaseDiagnostic[]>;
-export declare function recordWakeAttempt(attempt: Omit<WakeAttempt, 'at'> & {
-    at?: number;
-}, env?: NodeJS.ProcessEnv): Promise<WakeAttempt>;
-export declare function recordRecoveredUnknown(attention: WakeAttention, lease: {
-    attemptN?: number;
-    routeKind?: WakeRouteKind;
-    session?: string;
-}, env?: NodeJS.ProcessEnv, at?: number): Promise<WakeAttempt | undefined>;

package/dist/wake-attempts.js

@@ -1,134 +1,39 @@
-import os from 'node:os';
 import { hostLedgerRoot } from './host-ledger-root.js';
-import path from 'node:path';
-import { isWakeRouteKind, nameKey } from './model.js';
-import { canonicalSquarePath } from './registry.js';
-import { formatActivityId, parseActivityId } from './square-core.js';
+import { nameKey } from './model.js';
+import { canonicalPath } from './canonical-path.js';
+import { formatActivityId } from './square-core.js';
 import { createHostLedgerPort } from './host-ledger-file-adapter.js';
-import { terminalWakeEvidence } from './square-projections.js';
 import { redactDiagnostic } from './diagnostic-redaction.js';
-export { hasAttemptableWakeRoute, isWakeRouteAttemptable, terminalWakeEvidence } from './square-projections.js';
-const VALID_OUTCOMES = new Set(['accepted', 'unknown', 'failed']);
-function ledger(env) {
-    return createHostLedgerPort({ rootPath: hostLedgerRoot(env) });
-}
-export function wakeAttemptsPath(env = process.env) {
-    return env.SQUARE_WAKE_ATTEMPTS || path.join(os.homedir(), '.square', 'wake-attempts.ndjsonl');
-}
-export async function wakeAttentionKey(attention) {
-    return JSON.stringify([await canonicalSquarePath(attention.squarePath), formatActivityId(attention.actIndex), nameKey(attention.recipient)]);
-}
-export async function claimWakeDispatch(attention, leaseId, leaseMs, env = process.env, at = Date.now(), session) {
-    return ledger(env).claimWakeDispatch({ attention, leaseId, leaseMs, at, session });
-}
-export async function transitionWakeDispatch(attention, leaseId, phase, leaseMs, routeKind, attemptN, session, env = process.env, at = Date.now()) {
-    return ledger(env).transitionWakeDispatch({ attention, leaseId, phase, leaseMs, routeKind, attemptN, session, at });
-}
-export async function releaseWakeDispatch(attention, leaseId, env = process.env, at = Date.now()) {
-    await ledger(env).releaseWakeDispatch({ attention, leaseId, at });
-}
-async function readRows(env, now) {
-    const records = await ledger(env).listWakeAttempts({ now });
-    return records.flatMap((record) => {
-        const actIndex = parseActivityId(record.activity);
-        if (actIndex === undefined || !isWakeRouteKind(record.routeKind) || !VALID_OUTCOMES.has(record.outcome) || typeof record.attemptN !== 'number')
-            return [];
-        return [{ at: record.at ?? now, attention: { squarePath: record.location, actIndex, recipient: record.participant }, routeKind: record.routeKind, outcome: record.outcome, attemptN: record.attemptN, ...(record.signature === undefined ? {} : { signature: record.signature }), ...(record.session === undefined ? {} : { session: record.session }), ...(record.message === undefined ? {} : { message: record.message }), ...(record.diagnostic === undefined ? {} : { diagnostic: record.diagnostic }) }];
-    });
-}
-export async function readWakeAttempts(opts = {}) {
-    const now = opts.now ?? Date.now();
-    const expected = opts.attention === undefined ? undefined : await wakeAttentionKey(opts.attention);
-    const attempts = await readRows(opts.env ?? process.env, now);
-    const scoped = opts.sessionId === undefined ? attempts : attempts.filter((attempt) => attempt.session === opts.sessionId);
-    if (expected === undefined)
-        return scoped;
-    const keys = await Promise.all(scoped.map((attempt) => wakeAttentionKey(attempt.attention)));
-    return scoped.filter((_, index) => keys[index] === expected);
-}
+import { decodeWakeEvidence } from './wake-evidence.js';
 export function redactWakeDiagnostic(value, env = process.env) {
     return redactDiagnostic(value, env.PASEO_PASSWORD);
 }
 export async function readWakeReleaseDiagnostics(opts = {}) {
     const now = opts.now ?? Date.now();
     const env = opts.env ?? process.env;
-    const rows = await ledger(env).listEvidence({
+    const rows = await createHostLedgerPort({ rootPath: hostLedgerRoot(env) }).listEvidence({
         kind: 'wake',
         location: opts.location ?? opts.attention?.squarePath,
         includeReleased: true,
         now,
     });
-    const expected = opts.attention === undefined ? undefined : await wakeAttentionKey(opts.attention);
+    const expected = opts.attention === undefined ? undefined : JSON.stringify([await canonicalPath(opts.attention.squarePath), formatActivityId(opts.attention.actIndex), nameKey(opts.attention.recipient)]);
     const releases = [];
     for (const row of rows) {
-        if (row.outcome !== 'released')
+        const decoded = decodeWakeEvidence(row, now);
+        if (decoded?.kind !== 'release')
             continue;
-        const actIndex = parseActivityId(row.activity);
-        if (actIndex === undefined || row.at === undefined)
+        const release = decoded.value;
+        if (opts.sessionId !== undefined && release.session !== opts.sessionId)
             continue;
-        if (opts.sessionId !== undefined && row.session !== opts.sessionId)
-            continue;
-        const attention = { squarePath: row.location, recipient: row.participant, actIndex };
-        if (expected !== undefined && JSON.stringify([row.location, formatActivityId(actIndex), nameKey(row.participant)]) !== expected)
+        const { attention } = release;
+        if (expected !== undefined && JSON.stringify([attention.squarePath, formatActivityId(attention.actIndex), nameKey(attention.recipient)]) !== expected)
             continue;
         releases.push({
-            at: row.at,
-            attention,
-            ...(row.routeKind === undefined ? {} : { routeKind: row.routeKind }),
-            ...(row.attemptN === undefined ? {} : { attemptN: row.attemptN }),
-            ...(row.session === undefined ? {} : { session: row.session }),
-            ...(row.signature === undefined ? {} : { signature: row.signature }),
-            ...(row.message === undefined ? {} : { message: redactWakeDiagnostic(row.message, env) }),
-            ...(row.diagnostic === undefined ? {} : { diagnostic: redactWakeDiagnostic(row.diagnostic, env) }),
+            ...release,
+            ...(release.message === undefined ? {} : { message: redactWakeDiagnostic(release.message, env) }),
+            ...(release.diagnostic === undefined ? {} : { diagnostic: redactWakeDiagnostic(release.diagnostic, env) }),
         });
     }
     return releases.sort((left, right) => right.at - left.at);
 }
-export async function recordWakeAttempt(attempt, env = process.env) {
-    const value = { ...attempt, at: attempt.at ?? Date.now() };
-    if (!isWakeRouteKind(value.routeKind))
-        throw new Error('Wake attempts require a real adapter route kind.');
-    if (value.outcome !== 'accepted' && !value.signature) {
-        throw new Error(`${value.outcome} wake attempts require a transport signature.`);
-    }
-    const safe = redactWakeDiagnostic(value, env);
-    const session = safe.session ?? safe.signature ?? `route:${safe.routeKind}`;
-    const claim = await ledger(env).claimEvidence({ location: safe.attention.squarePath, participant: safe.attention.recipient, session, activity: formatActivityId(safe.attention.actIndex), kind: 'wake', leaseMs: 5000 });
-    if (claim.status === 'acquired')
-        await ledger(env).appendWakeAttempt({ location: safe.attention.squarePath, participant: safe.attention.recipient, session, activity: formatActivityId(safe.attention.actIndex), kind: 'wake', outcome: safe.outcome, routeKind: safe.routeKind, signature: safe.signature, attemptN: safe.attemptN, message: safe.message, diagnostic: safe.diagnostic, at: safe.at, claimToken: claim.claimToken });
-    return value;
-}
-export async function recordRecoveredUnknown(attention, lease, env = process.env, at = Date.now()) {
-    const routeKind = lease.routeKind;
-    if (lease.attemptN === undefined || !isWakeRouteKind(routeKind))
-        return undefined;
-    const rows = await readRows(env, at);
-    {
-        const expected = await wakeAttentionKey(attention);
-        const attempts = [];
-        for (const attempt of rows) {
-            if (await wakeAttentionKey(attempt.attention) !== expected)
-                continue;
-            if (lease.session !== undefined && attempt.session !== lease.session)
-                continue;
-            attempts.push(attempt);
-        }
-        const terminal = terminalWakeEvidence(attempts);
-        if (terminal !== undefined)
-            return terminal;
-        const value = {
-            at,
-            attention,
-            routeKind,
-            outcome: 'unknown',
-            signature: 'worker_interrupted_during_dispatch',
-            attemptN: lease.attemptN,
-            message: 'The notification worker ended after dispatch began; transport acceptance is unknown.',
-        };
-        const session = lease.session ?? value.signature;
-        const claim = await ledger(env).claimEvidence({ location: attention.squarePath, participant: attention.recipient, session, activity: formatActivityId(attention.actIndex), kind: 'wake', leaseMs: 5000 });
-        if (claim.status === 'acquired')
-            await ledger(env).appendWakeAttempt({ location: attention.squarePath, participant: attention.recipient, session, activity: formatActivityId(attention.actIndex), kind: 'wake', outcome: 'unknown', routeKind, signature: value.signature, attemptN: value.attemptN, message: value.message, at, claimToken: claim.claimToken });
-        return value;
-    }
-}

package/dist/wake-eligibility.d.ts

@@ -0,0 +1,43 @@
+import { type SquareState, type WakeRoute } from './model.js';
+import { deriveDeliveryModel } from './delivery.js';
+import type { EvidenceRecord, PresenceRecord } from './host-ledger.js';
+import type { PresentationEvidenceProjection, WakeRequest } from './ports.js';
+import { type WakeAttempt } from './wake-evidence.js';
+export interface WakeSnapshot {
+    readonly state: SquareState;
+    /** Canonicalized by the caller; every identity in this snapshot is square-local. */
+    readonly location: string;
+    readonly owners: readonly PresenceRecord[];
+    readonly wakeRecords: readonly EvidenceRecord[];
+    readonly presentations: readonly PresentationEvidenceProjection[];
+    readonly now: number;
+    readonly delivery?: ReturnType<typeof deriveDeliveryModel>;
+}
+export interface OwnedWakeRoute {
+    readonly route: WakeRoute;
+    readonly owner: PresenceRecord;
+}
+export interface WakeCurrentness {
+    readonly current: boolean;
+    readonly activityPending: boolean;
+    readonly sessionBound: boolean;
+    readonly routePublished: boolean;
+    readonly selectedOwner: boolean;
+    readonly cancelled: boolean;
+    readonly presented: boolean;
+}
+export interface WakeEvidence {
+    readonly delivered: boolean;
+    /** All selected, uncancelled routes have session-local presentation evidence. */
+    readonly presented: boolean;
+    readonly attempts: readonly WakeAttempt[];
+    readonly terminal?: WakeAttempt;
+    readonly attemptableRoutes: readonly WakeRoute[];
+}
+export interface WakeEligibility {
+    evidence(recipient: string, actIndex: number): WakeEvidence;
+    currentness(request: WakeRequest): WakeCurrentness;
+}
+/** One strict ownership join, latest selection, and request fence over primary evidence only. */
+export declare function projectWakeEligibility(input: WakeSnapshot): WakeEligibility;
+export declare function wakeIsEligible(evidence: WakeEvidence): boolean;

package/dist/wake-eligibility.js

@@ -0,0 +1,106 @@
+import { nameKey } from './model.js';
+import { deriveDeliveryModel } from './delivery.js';
+import { formatActivityId, parseActivityId } from './square-core.js';
+import { decodeWakeEvidence } from './wake-evidence.js';
+function identity(...parts) { return JSON.stringify(parts); }
+/** One strict ownership join, latest selection, and request fence over primary evidence only. */
+export function projectWakeEligibility(input) {
+    const delivery = input.delivery ?? deriveDeliveryModel(input.state);
+    const ownersBySession = new Map();
+    for (const owner of input.owners) {
+        if (owner.location !== input.location)
+            continue;
+        const key = identity(nameKey(owner.participant), owner.session);
+        const rows = ownersBySession.get(key) ?? [];
+        rows.push(owner);
+        ownersBySession.set(key, rows);
+    }
+    const ownerFor = (route) => route.location !== input.location ? undefined
+        : ownersBySession.get(identity(nameKey(route.participant), route.sessionId))?.find((row) => route.epoch === undefined || row.epoch === route.epoch);
+    const ownedRoutes = [];
+    const latest = new Map();
+    for (const route of input.state.routes ?? []) {
+        const participant = nameKey(route.participant);
+        const owner = ownerFor(route);
+        if (owner === undefined)
+            continue;
+        ownedRoutes.push({ route, owner });
+        latest.set(participant, Math.max(latest.get(participant) ?? Number.NEGATIVE_INFINITY, route.updatedAt));
+    }
+    const selectedByRecipient = new Map();
+    for (const owned of ownedRoutes) {
+        const key = nameKey(owned.route.participant);
+        if (owned.route.updatedAt !== latest.get(key))
+            continue;
+        const rows = selectedByRecipient.get(key) ?? [];
+        rows.push(owned);
+        selectedByRecipient.set(key, rows);
+    }
+    const pending = new Set();
+    for (const recipient of delivery.joinedRecipients()) {
+        for (const notification of delivery.pendingFor(recipient))
+            pending.add(identity(nameKey(recipient), notification.item.index));
+    }
+    const attemptsByAttention = new Map();
+    for (const record of input.wakeRecords) {
+        if (record.location !== input.location)
+            continue;
+        const decoded = decodeWakeEvidence(record, input.now);
+        if (decoded?.kind !== 'attempt')
+            continue;
+        const attempt = decoded.value;
+        const key = identity(nameKey(attempt.attention.recipient), attempt.attention.actIndex);
+        const rows = attemptsByAttention.get(key) ?? [];
+        rows.push(attempt);
+        attemptsByAttention.set(key, rows);
+    }
+    const presentedSessions = new Set();
+    for (const row of input.presentations) {
+        if (row.location !== input.location || (row.outcome !== 'presented' && row.outcome !== 'clipped'))
+            continue;
+        presentedSessions.add(identity(nameKey(row.participant), row.activity, row.sessionId));
+    }
+    const isPresented = (route, actIndex) => presentedSessions.has(identity(nameKey(route.participant), formatActivityId(actIndex), route.sessionId));
+    const isCancelled = (owner, actIndex) => actIndex <= (owner.cancelledThrough ?? -1);
+    return {
+        evidence(recipient, actIndex) {
+            const key = nameKey(recipient);
+            // Accepted/unknown exclusion belongs to attention, not to a surviving owner or route kind.
+            const attempts = attemptsByAttention.get(identity(key, actIndex)) ?? [];
+            const terminal = attempts.findLast((attempt) => attempt.outcome === 'accepted')
+                ?? attempts.findLast((attempt) => attempt.outcome === 'unknown');
+            const routes = (selectedByRecipient.get(key) ?? []).filter(({ owner }) => !isCancelled(owner, actIndex));
+            const presented = routes.length > 0 && routes.every(({ route }) => isPresented(route, actIndex));
+            return {
+                delivered: delivery.isSeen(recipient, actIndex), presented, attempts,
+                ...(terminal === undefined ? {} : { terminal }),
+                attemptableRoutes: terminal === undefined && pending.has(identity(key, actIndex))
+                    ? routes.filter(({ route }) => !isPresented(route, actIndex)).map(({ route }) => route) : [],
+            };
+        },
+        currentness(request) {
+            const actIndex = parseActivityId(request.activity);
+            const route = request.route;
+            const sameRecipient = nameKey(request.participant) === nameKey(route.participant);
+            const sameLocation = request.location === input.location && route.location === input.location;
+            const activityPending = actIndex !== undefined && request.location === input.location
+                && pending.has(identity(nameKey(request.participant), actIndex));
+            const owner = sameLocation && sameRecipient ? ownerFor(route) : undefined;
+            const sessionBound = owner !== undefined;
+            const matchesRequest = (published) => published.location === route.location
+                && nameKey(published.participant) === nameKey(route.participant) && published.sessionId === route.sessionId
+                && published.kind === route.kind && published.epoch === route.epoch && Object.keys(published.address).length === Object.keys(route.address).length && Object.keys(published.address).every((key) => published.address[key] === route.address[key]);
+            const routePublished = sameLocation && sameRecipient && (input.state.routes ?? []).some(matchesRequest);
+            const selectedOwner = sameLocation && sameRecipient
+                && (selectedByRecipient.get(nameKey(route.participant)) ?? []).some(({ route: published }) => matchesRequest(published));
+            const cancelled = actIndex !== undefined && owner !== undefined && isCancelled(owner, actIndex);
+            const presented = actIndex !== undefined && sameLocation && sameRecipient && isPresented(route, actIndex);
+            // Dispatching evidence deliberately does not fence the request that owns the atomic claim.
+            return { current: activityPending && sessionBound && routePublished && selectedOwner && !cancelled && !presented,
+                activityPending, sessionBound, routePublished, selectedOwner, cancelled, presented };
+        },
+    };
+}
+export function wakeIsEligible(evidence) {
+    return !evidence.delivered && !evidence.presented && evidence.terminal === undefined && evidence.attemptableRoutes.length > 0;
+}

package/dist/wake-evidence.d.ts

@@ -1,9 +1,32 @@
-import type { SquareState } from './model.js';
-import { wakeIsEligible, type WakeEvidence, type WakeEvidenceProjection } from './square-projections.js';
-import type { DeliveryModel } from './delivery.js';
-export type { WakeEvidence, WakeEvidenceProjection };
-export { wakeIsEligible };
-/** Adapter entry: open the artifact, assemble host ports, and project wake evidence. */
-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): Promise<WakeEvidenceProjection>;
-export declare function wakeEvidence(squarePath: string, recipient: string, actIndex: number, now: number, env: NodeJS.ProcessEnv): Promise<WakeEvidence>;
+import type { EvidenceRecord, WakeAttention } from './host-ledger.js';
+import type { WakeRouteKind } from './model.js';
+export interface WakeAttempt {
+    readonly at: number;
+    readonly attention: WakeAttention;
+    readonly routeKind: WakeRouteKind;
+    readonly outcome: 'accepted' | 'unknown' | 'failed';
+    readonly signature?: string;
+    readonly attemptN: number;
+    readonly session?: string;
+    readonly message?: string;
+    readonly diagnostic?: unknown;
+}
+export interface WakeReleaseDiagnostic {
+    readonly at: number;
+    readonly attention: WakeAttention;
+    readonly routeKind?: WakeRouteKind;
+    readonly attemptN?: number;
+    readonly session?: string;
+    readonly signature?: string;
+    readonly message?: string;
+    readonly diagnostic?: unknown;
+}
+export type DecodedWakeEvidence = {
+    readonly kind: 'attempt';
+    readonly value: WakeAttempt;
+} | {
+    readonly kind: 'release';
+    readonly value: WakeReleaseDiagnostic;
+};
+/** Decode primary attempts and diagnostic-only releases without mixing their evidence. */
+export declare function decodeWakeEvidence(record: EvidenceRecord, now: number): DecodedWakeEvidence | undefined;

package/dist/wake-evidence.js

@@ -1,26 +1,31 @@
-import { hostLedgerRoot } from './host-ledger-root.js';
-import { createHostLedgerPort } from './host-ledger-file-adapter.js';
-import { openSquare } from './square-file-adapter.js';
-import { closeOpenSquare } from './open-square.js';
-import { projectWakeEvidenceFromState, wakeIsEligible, } from './square-projections.js';
-export { wakeIsEligible };
-function hostLedgerForEnv(env) {
-    return createHostLedgerPort({ rootPath: hostLedgerRoot(env) });
-}
-/** Adapter entry: open the artifact, assemble host ports, and project wake evidence. */
-export async function wakeEvidenceProjection(squarePath, now, env) {
-    const square = await openSquare(squarePath, { clock: () => now, hostLedger: hostLedgerForEnv(env), env });
-    try {
-        const { state } = await square.artifact.read();
-        return projectWakeEvidenceFromState({ location: squarePath, state, hostLedger: square.hostLedger, now });
-    }
-    finally {
-        await closeOpenSquare(square);
+import { parseActivityId } from './square-core.js';
+/** Decode primary attempts and diagnostic-only releases without mixing their evidence. */
+export function decodeWakeEvidence(record, now) {
+    if (record.kind !== 'wake')
+        return undefined;
+    const actIndex = parseActivityId(record.activity);
+    if (actIndex === undefined)
+        return undefined;
+    const value = {
+        at: record.at ?? now,
+        attention: { squarePath: record.location, recipient: record.participant, actIndex },
+        ...(record.session === undefined ? {} : { session: record.session }),
+        ...(record.signature === undefined ? {} : { signature: record.signature }),
+        ...(record.message === undefined ? {} : { message: record.message }),
+        ...(record.diagnostic === undefined ? {} : { diagnostic: record.diagnostic }),
+    };
+    if (record.outcome === 'released') {
+        if (record.at === undefined)
+            return undefined;
+        return { kind: 'release', value: {
+                ...value,
+                ...(record.routeKind === undefined ? {} : { routeKind: record.routeKind }),
+                ...(record.attemptN === undefined ? {} : { attemptN: record.attemptN }),
+            } };
     }
-}
-export function wakeEvidenceProjectionFromState(squarePath, state, now, env, delivery) {
-    return projectWakeEvidenceFromState({ location: squarePath, state, hostLedger: hostLedgerForEnv(env), now, delivery });
-}
-export async function wakeEvidence(squarePath, recipient, actIndex, now, env) {
-    return (await wakeEvidenceProjection(squarePath, now, env)).evidence(recipient, actIndex);
+    if (record.outcome !== 'accepted' && record.outcome !== 'unknown' && record.outcome !== 'failed')
+        return undefined;
+    if (record.routeKind === undefined || typeof record.attemptN !== 'number')
+        return undefined;
+    return { kind: 'attempt', value: { ...value, routeKind: record.routeKind, attemptN: record.attemptN, outcome: record.outcome } };
 }