@astrosheep/square 0.3.63 → 0.3.65

package/dist/square-storage.js

@@ -1,23 +1,7 @@
-import fs from 'node:fs';
-import path from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
-import { createSquareFile, createSquareState, diagnoseSquareFile as diagnoseArtifactFile, loadSquare, probeSquare, observeSquareRevision, readSquareSnapshot, transactSquareSnapshot, writeSquareFile, } from './artifact.js';
+import { createSquareFile, createSquareState, diagnoseSquareFile as diagnoseArtifactFile, probeSquare, observeSquareRevision, readSquareSnapshot, transactSquareSnapshot, writeSquareFile, } from './artifact.js';
+import { canonicalPath } from './canonical-path.js';
 export { createSquareState };
-async function canonicalPath(squarePath) {
-    const absolute = path.resolve(squarePath);
-    try {
-        return await fs.promises.realpath(absolute);
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT')
-            throw error;
-        const parent = await fs.promises.realpath(path.dirname(absolute)).catch(() => path.dirname(absolute));
-        return path.join(parent, path.basename(absolute));
-    }
-}
-export async function readSquareFile(squarePath) {
-    return loadSquare(await canonicalPath(squarePath));
-}
 export async function probeSquareFile(squarePath) {
     if (!squarePath.endsWith('.square'))
         return undefined;
@@ -39,7 +23,7 @@ function cloneState(squareState) {
 }
 function assertCellOpen(closed) {
     if (closed)
-        throw new Error('StateCell is closed');
+        throw new Error('Square artifact is closed');
 }
 function isThenable(value) {
     return (typeof value === 'object' || typeof value === 'function') && value !== null
@@ -48,7 +32,7 @@ function isThenable(value) {
 function discardThenable(value) {
     void Promise.resolve(value).catch(() => undefined);
 }
-/** In-process cell for fast behavior tests and embedded consumers. */
+/** In-process artifact for fast behavior tests and embedded consumers. */
 export function createMemoryCell(initial) {
     let state = cloneState(initial);
     let version = 0;
@@ -69,11 +53,11 @@ export function createMemoryCell(initial) {
         transact(fn, signal) {
             assertCellOpen(closed);
             if (signal?.aborted)
-                throw signal.reason ?? new Error('StateCell operation aborted');
+                throw signal.reason ?? new Error('Square artifact operation aborted');
             const operation = tail.then(() => {
                 assertCellOpen(closed);
                 if (signal?.aborted)
-                    throw signal.reason ?? new Error('StateCell operation aborted');
+                    throw signal.reason ?? new Error('Square artifact operation aborted');
                 const current = cloneState(state);
                 const outcome = fn(current, version);
                 if (isThenable(outcome)) {
@@ -96,27 +80,27 @@ export function createMemoryCell(initial) {
         async read(signal) {
             assertCellOpen(closed);
             if (signal?.aborted)
-                throw signal.reason ?? new Error('StateCell operation aborted');
+                throw signal.reason ?? new Error('Square artifact operation aborted');
             await tail;
             assertCellOpen(closed);
             if (signal?.aborted)
-                throw signal.reason ?? new Error('StateCell operation aborted');
+                throw signal.reason ?? new Error('Square artifact operation aborted');
             return { state: cloneState(state), version };
         },
         changed(sinceVersion, timeoutMs, signal) {
             assertCellOpen(closed);
             if (signal?.aborted)
-                return Promise.reject(signal.reason ?? new Error("StateCell operation aborted"));
+                return Promise.reject(signal.reason ?? new Error("Square artifact operation aborted"));
             if (version > sinceVersion)
                 return Promise.resolve(true);
             if (timeoutMs <= 0)
                 return Promise.resolve(false);
             return new Promise((resolve, reject) => {
                 if (signal?.aborted) {
-                    reject(signal.reason ?? new Error("StateCell operation aborted"));
+                    reject(signal.reason ?? new Error("Square artifact operation aborted"));
                     return;
                 }
-                const abort = () => { waiters.delete(waiter); clearTimeout(waiter.timer); signal?.removeEventListener("abort", abort); reject(signal?.reason ?? new Error("StateCell operation aborted")); };
+                const abort = () => { waiters.delete(waiter); clearTimeout(waiter.timer); signal?.removeEventListener("abort", abort); reject(signal?.reason ?? new Error("Square artifact operation aborted")); };
                 const waiter = {
                     since: sinceVersion,
                     resolve,
@@ -142,7 +126,7 @@ export function createMemoryCell(initial) {
         },
     };
 }
-/** SQLite-backed cell. Revisions are read from the authoritative database, not file metadata. */
+/** SQLite-backed artifact. Revisions are read from the authoritative database, not file metadata. */
 export function createFileCell(squarePath, externalSignal) {
     let closed = false;
     let storage;
@@ -152,9 +136,6 @@ export function createFileCell(squarePath, externalSignal) {
         storage ??= canonicalPath(squarePath);
         return storage;
     }
-    function abortError() {
-        return new Error('StateCell is closed');
-    }
     /** Close wins over every operation; a per-call deadline bounds busy retries alongside it. */
     function operationSignal(signal) {
         if (signal === undefined && externalSignal === undefined)
@@ -200,12 +181,8 @@ export function createFileCell(squarePath, externalSignal) {
             if (closed)
                 return;
             closed = true;
-            cancel.abort(abortError());
+            cancel.abort(new Error('Square artifact is closed'));
             await tail;
         },
     };
 }
-/** Consumer-facing file cell factory; keeps SQLite framing behind this module. */
-export function openSquareCell(squarePath, signal) {
-    return createFileCell(squarePath, signal);
-}

package/dist/square-wiring.d.ts

@@ -5,7 +5,7 @@ export declare class Square {
     private readonly square;
     private readonly context;
     private constructor();
-    static at(input: SquareAtInput): Promise<Square>;
+    static at(input: SquareAtInput, control?: OperationControl): Promise<Square>;
     static build(input: SquareBuildInput): Promise<Square>;
     static inMemory(input: Omit<SquareBuildInput, 'path'>): Square;
     join(name: string, control?: OperationControl): Promise<Participant>;
@@ -24,15 +24,10 @@ export declare class Square {
         readonly participant?: Participant;
     }>;
     participants(): Promise<ParticipantStatus[]>;
-    snapshot(): Promise<SquareSnapshot>;
+    snapshot(control?: OperationControl): Promise<SquareSnapshot>;
     history(query?: HistoryQuery, control?: OperationControl): Promise<Activity[]>;
     recognize(env: NodeJS.ProcessEnv): Promise<Participant | null>;
     close(): Promise<void>;
     endOwnedSession(name: string, sessionId: string, expectedEpoch?: number): Promise<ExpressResult | null>;
     retireEndedSessionRoutes(sessionId: string): 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,10 +1,10 @@
 import { closeOpenSquare } from './open-square.js';
 import { buildMemorySquare, buildSquare, openSquare } from './square-file-adapter.js';
 import { catchUp, done, endOwnedSession, express, hold, ignore, implicitJoin, join, takeover, listen, listening, resume, retireEndedSessionRoutes, } from './square-actions.js';
-import { markBoundarySeen as recordBoundarySeen } from './presence.js';
-import { history, participantHistory, participants, resolveParticipant, snapshot } from './views.js';
+import { history, participantHistory, participants, snapshot } from './views.js';
 import { currentParticipant } from './views.js';
 import { projectSessionBindings } from './square-projections.js';
+import { sessionIdsFromEnvironment } from './participant-identity.js';
 class ParticipantHandle {
     name;
     square;
@@ -51,8 +51,8 @@ export class Square {
         this.square = square;
         this.context = { ...square, location };
     }
-    static async at(input) {
-        return new Square(input.path, await openSquare(input.path, input));
+    static async at(input, control) {
+        return new Square(input.path, await openSquare(input.path, input, control));
     }
     static async build(input) {
         return new Square(input.path, await buildSquare(input.path, input));
@@ -85,13 +85,12 @@ export class Square {
             : { state: joined.state, participant: new ParticipantHandle(joined.name, this.square, this.context) };
     }
     participants() { return participants(this.square); }
-    snapshot() { return snapshot(this.square); }
+    snapshot(control) { return snapshot(this.square, control); }
     history(query, control) { return history(this.square, query, control); }
     async recognize(env) {
         if (this.square.hostLedger === undefined)
             return null;
-        const sessions = [env.CLAUDE_CODE_SESSION_ID, env.CODEX_THREAD_ID, env.OPENCODE_SESSION_ID, env.PI_SESSION_ID, env.PASEO_AGENT_ID]
-            .map((value) => value?.trim()).filter((value) => Boolean(value));
+        const sessions = sessionIdsFromEnvironment(env);
         if (sessions.length === 0)
             return null;
         const candidates = (await Promise.all(sessions.map((sessionId) => projectSessionBindings({
@@ -108,20 +107,3 @@ export class Square {
     endOwnedSession(name, sessionId, expectedEpoch) { return endOwnedSession(this.context, name, sessionId, expectedEpoch); }
     retireEndedSessionRoutes(sessionId) { return retireEndedSessionRoutes(this.context, sessionId); }
 }
-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, square),
-            close: () => closeOpenSquare(square),
-        };
-    }
-    catch (error) {
-        await closeOpenSquare(square);
-        throw error;
-    }
-}

package/dist/stream.js

@@ -5,10 +5,6 @@ import { quoteShell } from './presentation.js';
 import { openSquare, observeSquareChanges } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
 import { streamProjection, streamTailProjection } from './views.js';
-async function writeNdjson(value) {
-    if (!process.stdout.write(`${JSON.stringify(value)}\n`))
-        await once(process.stdout, 'drain');
-}
 /** Machine-readable tailing stays available; interactive terminal rendering was retired. */
 export async function cmdStreamNdjson(squarePath, recipient, start = { kind: 'tail', last: 10 }) {
     if (!fs.existsSync(squarePath)) {
@@ -31,8 +27,10 @@ export async function cmdStreamNdjson(squarePath, recipient, start = { kind: 'ta
                         ? await streamProjection(square, cursor, recipient)
                         : await streamTailProjection(square, initial.last, recipient);
                     for (const item of projection.activities) {
-                        await writeNdjson({ seq: item.activity.index, square: squarePath, ...item.activity,
-                            ...(item.route === undefined ? {} : { route: item.route }) });
+                        const line = { seq: item.activity.index, square: squarePath, ...item.activity,
+                            ...(item.route === undefined ? {} : { route: item.route }) };
+                        if (!process.stdout.write(`${JSON.stringify(line)}\n`))
+                            await once(process.stdout, 'drain');
                     }
                     cursor = projection.cursor;
                     initial = undefined;

package/dist/time.js

@@ -1,12 +1,6 @@
 function pad(value, length = 2) {
     return String(value).padStart(length, '0');
 }
-function formatOffset(date) {
-    const offsetMinutes = -date.getTimezoneOffset();
-    const sign = offsetMinutes >= 0 ? '+' : '-';
-    const abs = Math.abs(offsetMinutes);
-    return `${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
-}
 export function formatTimestamp(at) {
     const date = new Date(at);
     const time = date.getMilliseconds() !== 0
@@ -14,10 +8,11 @@ export function formatTimestamp(at) {
         : date.getSeconds() !== 0
             ? `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`
             : `${pad(date.getHours())}:${pad(date.getMinutes())}`;
+    const offsetMinutes = -date.getTimezoneOffset();
     return [
         `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`,
         time,
-        formatOffset(date),
+        `${offsetMinutes >= 0 ? '+' : '-'}${pad(Math.floor(Math.abs(offsetMinutes) / 60))}:${pad(Math.abs(offsetMinutes) % 60)}`,
     ].join(' ');
 }
 export function formatDuration(ms) {

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,15 +64,18 @@ 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<{
+export declare function resolveParticipant(square: OpenSquare, name: string, control?: OperationControl): Promise<{
     readonly name: string;
     readonly roster: readonly string[];
 }>;
 export declare function currentParticipant(square: OpenSquare, name: string): Promise<string | undefined>;
 export declare function participants(square: OpenSquare): Promise<ParticipantStatus[]>;
-export declare function snapshot(square: OpenSquare): Promise<SquareSnapshot>;
+export declare function snapshot(square: OpenSquare, control?: OperationControl): Promise<SquareSnapshot>;
 export declare function activityPresentation(square: OpenSquare, name: string): Promise<ActivityPresentation>;
 export declare function entryPresentation(square: OpenSquare, name: string, lastN?: number | null): Promise<EntryPresentation>;
 export declare function historyPresentation(square: OpenSquare, options: ActivitiesOptions): Promise<HistoryPresentation>;
@@ -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 resolveParticipant(square, name) { const { state } = await square.artifact.read(); return { name: resolveKnownName(state, name), roster: rosterNames(state) }; }
+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, control) { const { state } = await square.artifact.read(control?.signal); 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 snapshot(square, control) { const { state } = await square.artifact.read(control?.signal); 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), 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;
-    }
-}