@astrosheep/square 0.3.30 → 0.3.31

package/dist/square-projections.d.ts

@@ -0,0 +1,68 @@
+import { type SquareState } from './model.js';
+import type { HostLedgerPort, SquareArtifactPort, PresentationEvidenceProjection, PresentationProjection, SessionBindingProjection } from './ports.js';
+import { deriveDeliveryModel } from './delivery.js';
+import type { WakeRoute, WakeRouteKind } from './model.js';
+export declare function projectSessionBindings(input: {
+    readonly hostLedger: HostLedgerPort;
+    readonly sessionId: string;
+    readonly location?: string;
+    readonly scopes?: readonly import('./host-ledger.js').HostLedgerScope[];
+    readonly now?: number;
+}): Promise<readonly SessionBindingProjection[]>;
+export declare function sessionIdsFromEnvironment(env?: NodeJS.ProcessEnv): readonly string[];
+export declare function projectLocalParticipantBinding(input: {
+    readonly hostLedger: HostLedgerPort;
+    readonly location: string;
+    readonly participant: string;
+    readonly sessionIds: readonly string[];
+    readonly now?: number;
+}): Promise<SessionBindingProjection | undefined>;
+export declare function projectPresentation(input: {
+    readonly artifact: SquareArtifactPort;
+    readonly binding: SessionBindingProjection;
+    readonly now?: number;
+}): Promise<PresentationProjection>;
+export declare function projectPresentationEvidence(input: {
+    readonly hostLedger: HostLedgerPort;
+    readonly location?: string;
+    readonly participant?: string;
+    readonly sessionId?: string;
+    readonly activity?: string;
+    readonly now?: number;
+}): Promise<readonly PresentationEvidenceProjection[]>;
+export interface WakeAttempt {
+    readonly at: number;
+    readonly attention: {
+        readonly squarePath: string;
+        readonly actIndex: number;
+        readonly recipient: string;
+    };
+    readonly routeKind: WakeRouteKind;
+    readonly outcome: 'accepted' | 'unknown' | 'failed';
+    readonly signature?: string;
+    readonly attemptN: number;
+    readonly session?: string;
+    readonly message?: string;
+    readonly diagnostic?: unknown;
+}
+export declare function terminalWakeEvidence(attempts: readonly WakeAttempt[]): WakeAttempt | undefined;
+export declare function isWakeRouteAttemptable(route: Pick<WakeRoute, 'kind' | 'updatedAt'>, attempts: readonly WakeAttempt[]): boolean;
+export declare function hasAttemptableWakeRoute(routes: readonly Pick<WakeRoute, 'kind' | 'updatedAt'>[], attempts: readonly WakeAttempt[]): boolean;
+export interface WakeEvidence {
+    readonly delivered: boolean;
+    readonly presented: boolean;
+    readonly attempts: readonly WakeAttempt[];
+    readonly terminal?: WakeAttempt;
+    readonly attemptableRoutes: readonly WakeRoute[];
+}
+export interface WakeEvidenceProjection {
+    evidence(recipient: string, actIndex: number): WakeEvidence;
+}
+export declare function projectWakeEvidenceFromState(input: {
+    readonly location: string;
+    readonly state: SquareState;
+    readonly hostLedger: HostLedgerPort;
+    readonly now: number;
+    readonly delivery?: ReturnType<typeof deriveDeliveryModel>;
+}): Promise<WakeEvidenceProjection>;
+export declare function wakeIsEligible(evidence: WakeEvidence): boolean;

package/dist/square-projections.js

@@ -0,0 +1,87 @@
+import { formatActivityId, parseActivityId } from './square-core.js';
+import { nameKey } from './model.js';
+import { deriveDeliveryModel } from './delivery.js';
+import { freshWatchLease } from './runtime.js';
+function bindingProjection(record) {
+    return {
+        location: record.location,
+        participant: record.participant,
+        sessionId: record.session,
+        channel: record.channel,
+        ...(record.route === undefined ? {} : {
+            route: {
+                location: record.location,
+                participant: record.participant,
+                sessionId: record.session,
+                channel: record.channel,
+                kind: record.route.kind,
+                address: { ...record.route.address },
+                updatedAt: record.updatedAt ?? 0,
+            },
+        }),
+        updatedAt: record.updatedAt ?? 0,
+    };
+}
+export async function projectSessionBindings(input) {
+    const rows = await input.hostLedger.listPresence({ location: input.location, session: input.sessionId, scopes: input.scopes ?? ['user', 'local'], now: input.now });
+    return rows.map(bindingProjection);
+}
+export function sessionIdsFromEnvironment(env = process.env) {
+    return [env.CLAUDE_CODE_SESSION_ID, env.CODEX_THREAD_ID, env.OPENCODE_SESSION_ID, env.SQUARE_PI_SESSION_ID, env.PASEO_AGENT_ID]
+        .map((value) => value?.trim()).filter((value) => Boolean(value));
+}
+export async function projectLocalParticipantBinding(input) {
+    const bindings = (await Promise.all(input.sessionIds.map((sessionId) => projectSessionBindings({ hostLedger: input.hostLedger, location: input.location, sessionId, scopes: ['user', 'local'], now: input.now })))).flat();
+    return bindings.find((binding) => binding.participant.toLocaleLowerCase() === input.participant.toLocaleLowerCase());
+}
+export async function projectPresentation(input) {
+    const { state } = await input.artifact.read();
+    const delivery = deriveDeliveryModel(state);
+    const known = delivery.knownParticipant(input.binding.participant);
+    if (known === undefined || !delivery.joinedRecipients().some((recipient) => recipient.toLocaleLowerCase() === known.toLocaleLowerCase()))
+        return { binding: input.binding, joined: false, notifications: [] };
+    const binding = input.binding.participant === known ? input.binding : { ...input.binding, participant: known };
+    const notifications = delivery.pendingFor(known).map(({ item, route }) => ({ actIndex: item.index, actor: item.actor, at: item.at, route, body: item.body }));
+    const lease = freshWatchLease(state, known, input.now ?? Date.now());
+    return { binding, joined: true, notifications, ...(lease === undefined ? {} : { catchLease: lease }) };
+}
+export async function projectPresentationEvidence(input) {
+    const rows = await input.hostLedger.listEvidence({ kind: 'presentation', location: input.location, participant: input.participant, session: input.sessionId, activity: input.activity, now: input.now });
+    return rows.map((row) => ({ location: row.location, participant: row.participant, sessionId: row.session, activity: row.activity, outcome: row.outcome, ...(row.at === undefined ? {} : { at: row.at }) }));
+}
+export function terminalWakeEvidence(attempts) { return attempts.findLast((attempt) => attempt.outcome === 'accepted'); }
+export function isWakeRouteAttemptable(route, attempts) {
+    if (terminalWakeEvidence(attempts) !== undefined)
+        return false;
+    const failed = attempts.findLast((attempt) => attempt.routeKind === route.kind && attempt.outcome === 'failed');
+    return failed === undefined || route.updatedAt > failed.at;
+}
+export function hasAttemptableWakeRoute(routes, attempts) { return routes.some((route) => isWakeRouteAttemptable(route, attempts)); }
+export async function projectWakeEvidenceFromState(input) {
+    const delivery = input.delivery ?? deriveDeliveryModel(input.state);
+    const bindings = (await input.hostLedger.listPresence({ location: input.location, scopes: ['user'], now: input.now })).map(bindingProjection);
+    const wakeRecords = await input.hostLedger.listEvidence({ location: input.location, kind: 'wake', now: input.now });
+    const attemptsByBinding = new Map();
+    for (const record of wakeRecords) {
+        const actIndex = parseActivityId(record.activity);
+        if (actIndex === undefined || record.routeKind === undefined || typeof record.attemptN !== 'number')
+            continue;
+        const attempt = { attention: { squarePath: record.location, recipient: record.participant, actIndex }, outcome: record.outcome, at: record.at ?? input.now, routeKind: record.routeKind, 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 }) };
+        const key = JSON.stringify([nameKey(record.participant), actIndex, record.session]);
+        const existing = attemptsByBinding.get(key) ?? [];
+        existing.push(attempt);
+        attemptsByBinding.set(key, existing);
+    }
+    const presentedRows = await projectPresentationEvidence({ hostLedger: input.hostLedger, location: input.location, now: input.now });
+    return {
+        evidence(recipient, actIndex) {
+            const recipientBindings = bindings.filter((binding) => nameKey(binding.participant) === nameKey(recipient));
+            const routes = recipientBindings.flatMap((binding) => binding.route === undefined ? [] : [binding.route]);
+            const attempts = recipientBindings.flatMap((binding) => attemptsByBinding.get(JSON.stringify([nameKey(recipient), actIndex, binding.sessionId])) ?? []);
+            const terminal = terminalWakeEvidence(attempts);
+            const presented = presentedRows.some((row) => row.activity === formatActivityId(actIndex) && row.participant.toLocaleLowerCase() === recipient.toLocaleLowerCase() && recipientBindings.some((binding) => binding.sessionId === row.sessionId));
+            return { delivered: delivery.isSeen(recipient, actIndex), presented, attempts, ...(terminal === undefined ? {} : { terminal }), attemptableRoutes: terminal === undefined ? routes.filter((route) => isWakeRouteAttemptable(route, attempts)) : [] };
+        },
+    };
+}
+export function wakeIsEligible(evidence) { return !evidence.delivered && evidence.terminal === undefined && evidence.attemptableRoutes.length > 0; }

package/dist/square-storage.d.ts

@@ -12,9 +12,9 @@ export declare function probeSquareFile(squarePath: string): Promise<SquareState
 export declare function diagnoseSquareFile(squarePath: string): ReturnType<typeof diagnoseArtifactFile>;
 export declare function writeSquareSnapshot(squarePath: string, squareState: SquareState): Promise<void>;
 export declare function withSquareFileLock<T>(squarePath: string, fn: () => T | Promise<T>): Promise<T>;
-/** In-process cell for fast application tests and embedded consumers. */
+/** In-process cell for fast behavior tests and embedded consumers. */
 export declare function createMemoryCell(initial: SquareState): StateCell;
 /** File-backed cell retaining the existing .square codec and lock boundary. */
 export declare function createFileCell(squarePath: string): StateCell;
-/** Application-facing file cell factory; keeps storage choice behind this module. */
+/** Consumer-facing file cell factory; keeps storage choice behind this module. */
 export declare function openSquareCell(squarePath: string): StateCell;

package/dist/square-storage.js

@@ -33,7 +33,7 @@ function assertCellOpen(closed) {
     if (closed)
         throw new Error('StateCell is closed');
 }
-/** In-process cell for fast application tests and embedded consumers. */
+/** In-process cell for fast behavior tests and embedded consumers. */
 export function createMemoryCell(initial) {
     let state = cloneState(initial);
     let version = 0;
@@ -182,7 +182,7 @@ export function createFileCell(squarePath) {
         },
     };
 }
-/** Application-facing file cell factory; keeps storage choice behind this module. */
+/** Consumer-facing file cell factory; keeps storage choice behind this module. */
 export function openSquareCell(squarePath) {
     return createFileCell(squarePath);
 }

package/dist/square-wiring.d.ts

@@ -1,9 +1,9 @@
-import { type OpenSquare } from './open-square.js';
 import type { Activity, HistoryQuery, ParticipantStatus, SquareSnapshot } from './square-facade.js';
 import type { Participant, SquareAtInput, SquareBuildInput } from './square-facade.js';
 export declare class Square {
     readonly location: string;
     private readonly square;
+    private readonly context;
     private constructor();
     static at(input: SquareAtInput): Promise<Square>;
     static build(input: SquareBuildInput): Promise<Square>;
@@ -22,9 +22,9 @@ export declare class Square {
     history(query?: HistoryQuery): Promise<Activity[]>;
     recognize(env: NodeJS.ProcessEnv): Promise<Participant | null>;
     close(): Promise<void>;
+    reconcileBinding(): Promise<import("./host-ledger.js").ReconcileBindingResult>;
 }
-export declare function markBoundarySeen(squarePath: string, name: string, ownerId: string | undefined, actIndexes: readonly number[], at?: number): Promise<void>;
-export declare function markNotificationNotified(square: OpenSquare, name: string, actIndex: number, ownerId: string | undefined, at?: number): Promise<void>;
+export declare function markBoundarySeen(squarePath: string, name: string, actIndexes: readonly number[], at?: number): Promise<void>;
 export declare function openParticipant(input: SquareAtInput, name: string): Promise<{
     readonly participant: Participant;
     close(): Promise<void>;

package/dist/square-wiring.js

@@ -1,50 +1,56 @@
 import { closeOpenSquare } from './open-square.js';
 import { buildMemorySquare, buildSquare, openSquare } from './square-file-adapter.js';
-import { done, express, hold, ignore, implicitJoin, join, listen, listening, resume } from './landing.js';
-import { catchUp, markBoundarySeen as recordBoundarySeen, markNotificationNotified as recordNotificationNotified } from './presence.js';
-import { currentParticipant, history, participantHistory, participants, resolveParticipant, snapshot } from './views.js';
-import { localParticipantName } from './registry.js';
+import { catchUp, done, express, hold, ignore, implicitJoin, join, listen, listening, resume, } from './square-actions.js';
+import { markBoundarySeen as recordBoundarySeen } from './presence.js';
+import { history, participantHistory, participants, resolveParticipant, snapshot } from './views.js';
+import { currentParticipant } from './views.js';
+import { projectSessionBindings } from './square-projections.js';
+import { reconcileBinding as reconcileBindingOperation } from './delivery-operations.js';
 class ParticipantHandle {
     name;
     square;
-    constructor(name, square) {
+    context;
+    constructor(name, square, context) {
         this.name = name;
         this.square = square;
+        this.context = context;
     }
     express(body, options) {
-        return express(this.square, this.name, body, options);
+        return express(this.context, this.name, body, options);
     }
     listen(target) {
-        return listen(this.square, this.name, target);
+        return listen(this.context, this.name, target);
     }
     ignore(target) {
-        return ignore(this.square, this.name, target);
+        return ignore(this.context, this.name, target);
     }
     listening() {
-        return listening(this.square, this.name);
+        return listening(this.context, this.name);
     }
     catch(options) {
-        return catchUp(this.square, this.name, options);
+        return catchUp(this.context, this.name, options);
     }
     history(query) {
         return participantHistory(this.square, this.name, query);
     }
     hold(reason) {
-        return hold(this.square, this.name, reason);
+        return hold(this.context, this.name, reason);
     }
     resume() {
-        return resume(this.square, this.name);
+        return resume(this.context, this.name);
     }
     done(body) {
-        return done(this.square, this.name, body);
+        return done(this.context, this.name, body);
     }
 }
 export class Square {
     location;
     square;
+    context;
     constructor(location, square) {
         this.location = location;
         this.square = square;
+        this.context = { ...square, location };
     }
     static async at(input) {
         return new Square(input.path, await openSquare(input.path, input));
@@ -56,43 +62,52 @@ export class Square {
         return new Square('memory', buildMemorySquare(input));
     }
     async join(name) {
-        const joined = await join(this.square, name);
-        return new ParticipantHandle(joined.name, this.square);
+        const joined = await join(this.context, name);
+        return new ParticipantHandle(joined.name, this.square, this.context);
     }
     async joinWithActivity(name) {
-        const joined = await join(this.square, name);
-        return { participant: new ParticipantHandle(joined.name, this.square), activity: joined.activity };
+        const joined = await join(this.context, name);
+        return { participant: new ParticipantHandle(joined.name, this.square, this.context), activity: joined.activity };
     }
     async implicitJoin(name) {
-        const joined = await implicitJoin(this.square, name);
+        const joined = await implicitJoin(this.context, name);
         return joined.state === 'done'
             ? { state: joined.state }
-            : { state: joined.state, participant: new ParticipantHandle(joined.name, this.square) };
+            : { state: joined.state, participant: new ParticipantHandle(joined.name, this.square, this.context) };
     }
     participants() { return participants(this.square); }
     snapshot() { return snapshot(this.square); }
     history(query) { return history(this.square, query); }
     async recognize(env) {
-        const registered = await localParticipantName(this.square.location, env);
-        if (registered === undefined)
+        if (this.square.hostLedger === undefined)
             return null;
-        const canonicalName = await currentParticipant(this.square, registered);
-        return canonicalName === undefined ? null : new ParticipantHandle(canonicalName, this.square);
+        const sessions = [env.CLAUDE_CODE_SESSION_ID, env.CODEX_THREAD_ID, env.OPENCODE_SESSION_ID, env.SQUARE_PI_SESSION_ID, env.PASEO_AGENT_ID]
+            .map((value) => value?.trim()).filter((value) => Boolean(value));
+        if (sessions.length === 0)
+            return null;
+        const candidates = (await Promise.all(sessions.map((sessionId) => projectSessionBindings({
+            hostLedger: this.square.hostLedger,
+            location: this.square.location,
+            sessionId,
+            scopes: ['user', 'local'],
+        })))).flat();
+        if (candidates.length !== 1)
+            return null;
+        const canonicalName = await currentParticipant(this.square, candidates[0].participant);
+        return canonicalName === undefined ? null : new ParticipantHandle(canonicalName, this.square, this.context);
     }
     close() { return closeOpenSquare(this.square); }
+    reconcileBinding() { return reconcileBindingOperation({ artifact: this.square.artifact, hostLedger: this.square.hostLedger, location: this.location }); }
 }
-export function markBoundarySeen(squarePath, name, ownerId, actIndexes, at) {
-    return recordBoundarySeen(squarePath, name, ownerId, actIndexes, at);
-}
-export function markNotificationNotified(square, name, actIndex, ownerId, at) {
-    return recordNotificationNotified(square, name, actIndex, ownerId, at);
+export function markBoundarySeen(squarePath, name, actIndexes, at) {
+    return recordBoundarySeen(squarePath, name, actIndexes, at);
 }
 export async function openParticipant(input, name) {
     const square = await openSquare(input.path, input);
     try {
         const known = await resolveParticipant(square, name);
         return {
-            participant: new ParticipantHandle(known.name, square),
+            participant: new ParticipantHandle(known.name, square, square),
             close: () => closeOpenSquare(square),
         };
     }

package/dist/views.d.ts

@@ -93,8 +93,14 @@ 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, ownerId: string): Promise<InboxProjection>;
-export declare function streamProjection(square: OpenSquare, cursor: number, recipient?: string): Promise<StreamProjection>;
+export declare function inboxProjection(square: OpenSquare, name: string, _sessionId?: string): Promise<InboxProjection>;
+export declare function streamProjection(square: OpenSquare | {
+    readonly cell: {
+        read(): Promise<{
+            state: SquareState;
+        }>;
+    };
+}, 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[]>;

package/dist/views.js

@@ -24,14 +24,18 @@ function parseRequiredActivityId(id) {
     return index;
 }
 function historyOptions(query, viewer) {
-    return { ...(query.from === undefined ? {} : { participants: [...query.from] }), ...(query.grep === undefined ? {} : { grep: query.grep }), ...(query.mention === true && viewer !== undefined ? { mention: viewer } : {}), order: 'asc' };
+    if (query.before !== undefined && query.after !== undefined)
+        throw new SquareError('invalid_args', 'History cannot combine before and after cursors');
+    const afterIndex = query.after === undefined ? undefined : parseRequiredActivityId(query.after);
+    const beforeIndex = query.before === undefined ? undefined : parseRequiredActivityId(query.before);
+    return { ...(query.from === undefined ? {} : { participants: [...query.from] }), ...(query.grep === undefined ? {} : { grep: query.grep }), ...(query.mention === true && viewer !== undefined ? { mention: viewer } : {}), ...(afterIndex === undefined ? {} : { afterIndex }), ...(beforeIndex === undefined ? {} : { beforeIndex }), order: 'asc' };
 }
 function selectHistory(stored, query) {
     let selected = stored.filter((activity) => activity.kind !== 'read');
-    if (query.all !== true && query.limit !== undefined) {
+    if (query.limit !== undefined) {
         if (!Number.isSafeInteger(query.limit) || query.limit < 1)
             throw new SquareError('invalid_args', 'History limit must be a positive integer');
-        selected = selected.slice(-query.limit);
+        selected = query.after === undefined ? selected.slice(-query.limit) : selected.slice(0, query.limit);
     }
     return query.order === 'desc' ? selected.reverse() : selected;
 }
@@ -62,27 +66,27 @@ 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 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 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(); 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 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)
+export async function history(square, query = {}) { const { state } = await square.artifact.read(); return selectHistory(coreActivities(state, historyOptions(query)), query).map(expose); }
+export async function participantHistory(square, name, query = {}) { const { state } = await square.artifact.read(); const viewer = resolveKnownName(state, name); const delivery = deriveDeliveryModel(state); const effective = 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.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 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).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.artifact.read(); const delivery = deriveDeliveryModel(state); return coreParticipants(state, square.clock(), delivery); }
+export async function listPresentation(square) { const { state } = await square.artifact.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.artifact.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.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.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)
+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 }) }; }
+export async function streamProjection(square, cursor, recipient) { const artifact = 'artifact' in square ? square.artifact : square.cell; const { state } = await artifact.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 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.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); }
+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,39 +1,46 @@
-import { type NotifyLease, type WakeRoute, type WakeRouteKind } from './model.js';
+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 WakeAttempt {
-    at: number;
-    attention: WakeAttention;
-    routeKind: WakeRouteKind;
-    outcome: WakeOutcome;
-    signature?: string;
-    attemptN: number;
-    message?: string;
-    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[]>;
-export declare function terminalWakeEvidence(attempts: readonly WakeAttempt[]): WakeAttempt | undefined;
-export declare function terminalWakeAttempt(attention: WakeAttention, opts?: {
-    now?: number;
-    env?: NodeJS.ProcessEnv;
-}): Promise<WakeAttempt | undefined>;
-export declare function isWakeRouteAttemptable(route: Pick<WakeRoute, 'kind' | 'updatedAt'>, attempts: readonly WakeAttempt[]): boolean;
-export declare function hasAttemptableWakeRoute(routes: readonly Pick<WakeRoute, 'kind' | 'updatedAt'>[], attempts: readonly WakeAttempt[]): boolean;
-export declare function nextWakeAttemptNumber(attention: WakeAttention, opts?: {
-    now?: number;
-    env?: NodeJS.ProcessEnv;
-}): Promise<number>;
 export declare function recordWakeAttempt(attempt: Omit<WakeAttempt, 'at'> & {
     at?: number;
 }, env?: NodeJS.ProcessEnv): Promise<WakeAttempt>;
-export declare function recordRecoveredUnknown(attention: WakeAttention, lease: Pick<NotifyLease, 'attemptN' | 'routeKind'>, env?: NodeJS.ProcessEnv, at?: number): Promise<WakeAttempt | undefined>;
+export declare function recordRecoveredUnknown(attention: WakeAttention, lease: {
+    attemptN?: number;
+    routeKind?: WakeRouteKind;
+    session?: string;
+}, env?: NodeJS.ProcessEnv, at?: number): Promise<WakeAttempt | undefined>;