@astrosheep/square 0.3.93 → 0.3.95

package/dist/square-tools.js

@@ -1,51 +1,22 @@
 import { z } from 'zod/v4';
 import { isSquareError } from './model.js';
-import { CATCH_DEFAULT_LIMIT } from './square-api.js';
+import { requireOwner, requireJoinName, selectOwnSeat, CATCH_DEFAULT_LIMIT } from './square-api.js';
 import { renderCatchOutcome, renderExpression, renderFailureLines, renderHistoryResult, renderJoinResult, renderLifecycleResult, renderListenerChange, renderStatusResult, } from './operation-presentation.js';
-const location = z.string().optional().describe('Which square: a .square file path, or a backend URI like stdio://name/key. Relative paths start from the working directory. Leave it out for the configured square.');
+const location = z.string().optional().describe('Which square: a .square file path. Relative paths start from the working directory. Leave it out for the configured square.');
 const participant = z.string().optional().describe('Your name in the square. Leave it out if you hold exactly one name here.');
 const activityId = z.string().regex(/^act\/(0|[1-9][0-9]*)$/);
 const stringArray = z.array(z.string());
-/** Keep the observation request internal: it is not an argument a caller decides. */
-function observation(control) {
-    return control.observe === true ? { observe: true } : {};
-}
-/** Tool receipts are plain JSON; each renderer re-declares the facts it reads. */
+/** Each renderer declares the operation facts it reads. */
 function rendering(render) {
     return (result, args) => render(result, args);
 }
-/**
- * Tool receipts are the one machine surface without activity metadata: a receipt copy drops every
- * property named `metadata` while domain activities keep theirs for SDK, CLI, stdio and stream readers.
- */
-function withoutActivityMetadata(value) {
-    if (Array.isArray(value))
-        return value.map(withoutActivityMetadata);
-    if (value === null || typeof value !== 'object')
-        return value;
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null)
-        return value;
-    return Object.fromEntries(Object.entries(value).filter(([key]) => key !== 'metadata')
-        .map(([key, item]) => [key, withoutActivityMetadata(item)]));
-}
-/**
- * Human text renders from the unfiltered receipt, so metadata-only says keep the placeholder the
- * CLI prints and every other sentence stays identical. Machines only ever receive the filtered copy.
- */
-const renderingReceipts = new WeakMap();
-function renderingReceipt(receipt) {
-    return (renderingReceipts.get(receipt) ?? receipt);
-}
 function tool(name, description, shape, run, render) {
     const inputSchema = z.object({ ...shape, location }).strict();
-    return { name, description, inputSchema, render: (receipt, args) => render(renderingReceipt(receipt), args),
-        run: async (square, args, control) => {
+    return { name, description, inputSchema,
+        run: async (square, args, control, identity) => {
             const { location: _location, ...operationArgs } = inputSchema.parse(args);
-            const receipt = await run(square, operationArgs, control);
-            const filtered = withoutActivityMetadata(receipt);
-            renderingReceipts.set(filtered, receipt);
-            return filtered;
+            const receipt = await run(square, operationArgs, control, identity);
+            return render(receipt, operationArgs) ?? '';
         } };
 }
 export const SQUARE_TOOL_INSTRUCTIONS = 'Join once. Then express to speak, and catch to take in what reached you. History looks back without taking anything in.';
@@ -53,10 +24,7 @@ const target = z.string().describe('The participant to turn toward or away from.
 export const SQUARE_TOOLS = [
     tool('join', 'Step into the square under your name. Do this once before you speak or catch. You arrive seeing what was said most recently.', {
         as: z.string().optional().describe('Your name in the square. Give it explicitly when joining.'), takeover: z.boolean().optional().describe('Claim this name even though another session holds it now. That session loses it.'),
-    }, async (square, { as, takeover }, control) => {
-        const { participant, ...receipt } = await square.join(as, { takeover, ...observation(control) }, control);
-        return { ...receipt, participant: participant.name };
-    }, rendering((result) => renderJoinResult(result))),
+    }, (square, { as, takeover }, control, identity) => square.join(requireJoinName(as), { ...identity, owner: requireOwner(identity.owner), takeover, observe: true }, control), rendering((result) => renderJoinResult(result))),
     tool('express', 'Speak or act in the square. Plain words, half-formed ideas and *actions* all belong here. Mention or reply to someone to be heard by them; ring the bell to be heard by everyone. Said to no one in particular, your words reach those who listen to you.', {
         as: participant,
         body: z.string().describe('What you say or do. Markdown works; *asterisks* mark an action.'),
@@ -65,11 +33,8 @@ export const SQUARE_TOOLS = [
         reply: activityId.optional().describe('The activity you are answering, like act/12. Its author hears you if still here.'),
         noMention: z.boolean().optional().describe('Leave @names in the body as plain text. Mentions and reply still reach people.'),
         force: z.boolean().optional().describe('Speak now, even if something reached you that you have not caught yet.'),
-        noWait: z.boolean().optional().describe('If a hand is raised or you are speaking too fast, return at once instead of waiting.'),
-    }, async (square, { body, as, ...options }, control) => {
-        const { delivery: _delivery, ...result } = await (await square.participant(as)).express(body, { ...options, ...observation(control) }, control);
-        return result;
-    }, rendering((result) => renderExpression(result.observation?.location ?? '', result))),
+        noWait: z.boolean().optional().describe('If you are speaking too fast, return at once instead of waiting.'),
+    }, async (square, { body, as, ...options }, control, identity) => (await selectOwnSeat(square, identity.owner, as)).express(body, { ...options, observe: true }, control), rendering((result) => renderExpression(result.observation?.location ?? '', result))),
     tool('catch', 'Take in what reached you since you last looked: mentions, replies, bells, and words from those you listen to. What you catch no longer waits for you; history lets you look back.', {
         as: participant,
         id: activityId.optional().describe('Take in this activity in full, like act/12, even if you caught it before. Do not combine with idle, from, mention or limit.'),
@@ -77,7 +42,7 @@ export const SQUARE_TOOLS = [
         from: stringArray.optional().describe('Only what these participants said.'),
         mention: z.boolean().optional().describe('Only what was addressed to you, and bells.'),
         limit: z.number().int().min(1).optional().describe('At most this many at once (default 10, up to 100). The rest keeps waiting.'),
-    }, async (square, { as, ...options }, control) => (await square.participant(as)).catch({ ...options, ...observation(control) }, control), rendering((result, args) => {
+    }, async (square, { as, ...options }, control, identity) => (await selectOwnSeat(square, identity.owner, as)).catch({ ...options, observe: true }, control), rendering((result, args) => {
         // The CLI always spells the default cap in its continuation, so the tool does too.
         const options = args;
         const renderOptions = options.id === undefined ? { ...options, limit: options.limit ?? CATCH_DEFAULT_LIMIT } : options;
@@ -92,25 +57,20 @@ export const SQUARE_TOOLS = [
         fixed: z.string().optional().describe('Only activities containing this exact text.'),
         from: stringArray.optional().describe('Only what these participants said.'),
         mention: z.string().optional().describe('Only what was addressed to this participant.'),
-    }, (square, args, control) => square.history({ ...args, ...observation(control) }, control), rendering((result, args) => renderHistoryResult(result.observation?.location ?? '', result, { query: args }))),
+    }, (square, args, control) => square.history({ ...args, observe: true }, control), rendering((result, args) => renderHistoryResult(result.observation?.location ?? '', result, { query: args }))),
     tool('attention', 'Turn toward someone or away from them, from now on. Listen: hear everything they say, even to others. Unlisten: stop listening without clearing an ignore; mentions and replies still reach you unless ignored. Ignore: hear nothing from them but bells. What was already said stays as it was.', {
         as: participant, action: z.enum(['listen', 'unlisten', 'ignore']).describe('"listen", "unlisten" or "ignore". Listening again ends an ignore.'), target,
-    }, async (square, { as, action, target }, control) => {
-        const self = await square.participant(as);
-        return self[action](target, observation(control), control);
+    }, async (square, { as, action, target }, control, identity) => {
+        const self = await selectOwnSeat(square, identity.owner, as);
+        return self[action](target, { observe: true }, control);
     }, rendering((result, args) => renderListenerChange(result.observation?.location ?? '', args.action, result))),
-    tool('hold', 'Raise a hand to pause the conversation; lower it with release. While a hand is up, new words wait to land.', {
-        as: participant,
-        reason: z.string().optional().describe('Why you are pausing. Everyone sees it.'),
-        release: z.boolean().optional().describe('true lowers the raised hand so the conversation goes on.'),
-    }, async (square, { as, reason, release }, control) => {
-        const self = await square.participant(as);
-        return release === true ? self.resume(observation(control), control) : self.hold(reason, observation(control), control);
-    }, rendering((result, args) => renderLifecycleResult(result.observation?.location ?? '', args.release === true ? 'resume' : 'hold', result))),
-    tool('done', 'Step out of the square. Everyone sees you leave, and you stop listening to anyone. Leaving carries no words, so say goodbye with express first. Stay instead if someone may still need you; you can join again later.', { as: participant }, async (square, { as }, control) => (await square.participant(as)).done(undefined, observation(control), control), rendering((result) => renderLifecycleResult(result.observation?.location ?? '', 'done', result))),
-    tool('status', 'Look around the square: who is here, whether a hand is raised, the latest activity, and who you listen to.', {
+    tool('done', 'Step out of the square. Everyone sees you leave, and you stop listening to anyone. Leaving carries no words, so say goodbye with express first. Stay instead if someone may still need you; you can join again later.', { as: participant }, async (square, { as }, control, identity) => (await selectOwnSeat(square, identity.owner, as)).done(undefined, { observe: true }, control), rendering((result) => renderLifecycleResult(result.observation?.location ?? '', result))),
+    tool('status', 'Look around the square: who is here, the latest activity, and who you listen to.', {
         as: z.string().optional().describe('Whose listening to show. Leave it out if you hold exactly one name here.'),
-    }, (square, { as }, control) => square.status({ viewer: as, ...observation(control) }, control), rendering((result) => renderStatusResult(result.observation?.location ?? '', result))),
+    }, async (square, { as }, control, identity) => {
+        const viewer = (await selectOwnSeat(square, identity.owner, as, { optional: true }))?.name;
+        return square.status({ viewer, observe: true }, control);
+    }, rendering((result) => renderStatusResult(result.observation?.location ?? '', result))),
 ];
 export function squareToolFailure(error, signal) {
     const normalized = signal?.aborted

package/dist/stream.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import { SquareError } from './model.js';
 import { createArtifactPort, observeSquareRevision } from './artifact.js';
-import { streamProjection, streamTailProjection } from './views.js';
+import { parseRequiredActivityId, streamProjection, streamTailProjection } from './views.js';
 /** Pull-based observation; return interrupts an outstanding pull before awaiting its cleanup. */
 export function streamSquare(squarePath, options = {}, control, borrowed) {
     return {
@@ -28,7 +28,7 @@ export function streamSquare(squarePath, options = {}, control, borrowed) {
                     }
                     signal.throwIfAborted();
                     const start = options.start ?? { kind: 'tail', last: 10 };
-                    let cursor = start.kind === 'after' ? start.after : -1;
+                    let cursor = start.kind === 'after' ? parseRequiredActivityId(start.after) : -1;
                     let initial = start.kind === 'tail' ? start : undefined;
                     const observer = await observeSquareRevision(squarePath);
                     const close = () => observer.close();
@@ -60,10 +60,9 @@ export function streamSquare(squarePath, options = {}, control, borrowed) {
                                 await observer.hinted(generation, Infinity, signal);
                                 continue;
                             }
-                            for (const item of projection.activities) {
+                            for (const activity of projection.activities) {
                                 signal.throwIfAborted();
-                                yield { seq: item.activity.index, square: squarePath, ...item.activity,
-                                    ...(item.route === undefined ? {} : { route: item.route }) };
+                                yield activity;
                             }
                             cursor = projection.cursor;
                             initial = undefined;

package/dist/views.d.ts

@@ -1,13 +1,13 @@
 import { type ActivityId } from './square-core.js';
 import { type StoredAct } from './model.js';
 import type { ActivityFilter, SquareRead } from './ports.js';
-import type { Activity, ArchiveRecord, HistoryQuery, HistoryContinuation, ParticipantsResult, SquareSnapshot, EntryPresentation, ListPresentation, StatusResult, SquareObservation, CatchPresence, StreamProjection } from './square-facade.js';
-export type { EntryPresentation, ListPresentation, CatchPresence, StreamProjection } from './square-facade.js';
+import type { Activity, ArchiveRecord, PerceivedActivity, HistoryQuery, HistoryContinuation, ParticipantsResult, SquareSnapshot, EntryPresentation, StatusResult, SquareObservation, CatchPresence } from './square-facade.js';
 export declare const HISTORY_DEFAULT_LIMIT = 10;
 export declare const HISTORY_MAX_LIMIT = 100;
-export declare const NON_READ: readonly ["join", "done", "say", "hold", "resume", "listen", "ignore", "unlisten"];
-/** The one StoredAct-to-public-Activity field mapping. Rejects read and actorless acts. */
+export declare const NON_READ: readonly ["join", "done", "say", "listen", "ignore", "unlisten"];
+/** The one StoredAct-to-public-Activity field mapping. Rejects read bookkeeping. */
 export declare function toPublicActivity(stored: StoredAct): Activity;
+export declare function toPerceivedActivity(facts: SquareRead, stored: StoredAct, viewer: string): PerceivedActivity;
 export declare function parseRequiredActivityId(id: ActivityId): number;
 /** Compile the public query directly to typed selectors; only search hydrates unselected bodies. */
 export declare function selectHistory(facts: SquareRead, query: HistoryQuery, limit: number | null, kinds: ActivityFilter['kinds'], presentation?: boolean): {
@@ -19,20 +19,30 @@ export declare function selectHistory(facts: SquareRead, query: HistoryQuery, li
 export declare function publicActivities(activities: readonly ArchiveRecord[]): Activity[];
 export declare function snapshot(facts: SquareRead, now: number): SquareSnapshot;
 export declare function recoveryObservation(facts: SquareRead, name: string, now: number): {
-    ownActivityCount: number;
-    hardCap: import("./model.js").HardCap;
-    holdReason?: string | undefined;
     participant: string;
-    roster: string[];
     activitySummaries: import("./square-facade.js").UnreadActivitySummary[];
     standingCount: number;
-    held: boolean;
+    ownActivityCount: number;
+    hardCap: import("./model.js").HardCap;
 };
 export declare function entryPresentation(facts: SquareRead, name: string, lastN?: number | null): EntryPresentation;
-type ParticipantQueryContext = Pick<SquareObservation, 'location' | 'now' | 'automaticDeliveryAvailable'>;
+type ParticipantQueryContext = Pick<SquareObservation, 'location' | 'now'>;
 export declare function queryParticipants(facts: SquareRead, context: ParticipantQueryContext, observe?: boolean): ParticipantsResult;
-export declare function listPresentation(facts: SquareRead): ListPresentation;
+export declare function listPresentation(facts: SquareRead): {
+    context: readonly string[];
+    participants: string[];
+    activities: number;
+};
 export declare function queryStatus(facts: SquareRead, context: ParticipantQueryContext, viewer?: string, observe?: boolean): StatusResult;
 export declare function catchPresence(facts: SquareRead, now: number): CatchPresence;
-export declare function streamProjection(facts: SquareRead, cursor: number, recipient?: string): StreamProjection;
-export declare function streamTailProjection(facts: SquareRead, last?: number, recipient?: string): StreamProjection;
+export declare function streamProjection(facts: SquareRead, cursor: number, recipient?: string): {
+    activities: Activity[];
+    cursor: number;
+    hasMore: boolean;
+};
+export declare function streamTailProjection(facts: SquareRead, last?: number, recipient?: string): {
+    activities: Activity[];
+    cursor: number;
+    hasMore: boolean;
+};
+export {};

package/dist/views.js

@@ -1,7 +1,7 @@
 import { formatActivityId, parseActivityId } from './square-core.js';
 import { compareParticipantActivity, coreParticipants, resolveKnownName, unreadActivitySummaries } from './decisions.js';
 import { SquareError, nameKey } from './model.js';
-import { inSquareCount, readCursor, rosterNames } from './runtime.js';
+import { inSquareCount } from './runtime.js';
 import { perceiveActivity } from './perception-projection.js';
 import { compileSearchPattern } from './search.js';
 const PAGE_SIZE = 100;
@@ -9,11 +9,11 @@ export const HISTORY_DEFAULT_LIMIT = 10;
 export const HISTORY_MAX_LIMIT = 100;
 const STATUS_HERE_WINDOW_MS = 30 * 60_000;
 const PRESENCE_WINDOW_MS = 8 * 60 * 60_000;
-export const NON_READ = ['join', 'done', 'say', 'hold', 'resume', 'listen', 'ignore', 'unlisten'];
-const ARCHIVE = new Set(['join', 'done', 'say', 'hold', 'resume']);
-/** The one StoredAct-to-public-Activity field mapping. Rejects read and actorless acts. */
+export const NON_READ = ['join', 'done', 'say', 'listen', 'ignore', 'unlisten'];
+const ARCHIVE = new Set(['join', 'done', 'say']);
+/** The one StoredAct-to-public-Activity field mapping. Rejects read bookkeeping. */
 export function toPublicActivity(stored) {
-    if (stored.kind === 'read' || stored.actor === undefined)
+    if (stored.kind === 'read')
         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 } : {}),
@@ -22,6 +22,11 @@ export function toPublicActivity(stored) {
         mentions: stored.kind === 'say' ? stored.mentions ?? [] : [], ...('target' in stored ? { target: stored.target } : {}),
         ...(stored.kind === 'say' && stored.reply !== undefined ? { reply: formatActivityId(stored.reply) } : {}) };
 }
+export function toPerceivedActivity(facts, stored, viewer) {
+    const via = facts.directedAt(viewer, stored.index)?.route;
+    return { ...toPublicActivity(stored), perception: perceiveActivity(facts, stored, viewer),
+        ...(via === undefined ? {} : { via }) };
+}
 export function parseRequiredActivityId(id) {
     const index = parseActivityId(id);
     if (index === undefined)
@@ -103,50 +108,44 @@ export function selectHistory(facts, query, limit, kinds, presentation = true) {
     return { activities, visibleActivities, totalMatches, ...(continuation === undefined ? {} : { continuation }) };
 }
 export function publicActivities(activities) {
-    return activities.flatMap((activity) => activity.kind === 'read' || activity.actor === undefined ? [] : [toPublicActivity(activity)]);
-}
-function statuses(facts, now) {
-    return coreParticipants(facts, now).filter((p) => p.state !== 'not joined').map((p) => {
-        const cursor = readCursor(facts, p.name);
-        return { name: p.name, state: p.state === 'done' ? 'done' : 'joined', consumedThrough: cursor < 0 ? null : formatActivityId(cursor), watching: p.presence === 'watching', listening: p.listening };
-    });
+    return activities.flatMap((activity) => activity.kind === 'read' ? [] : [toPublicActivity(activity)]);
 }
 export function snapshot(facts, now) {
-    const header = facts.header(), hold = facts.hold();
+    const header = facts.header();
     const names = new Map(facts.roster().map((p) => [nameKey(p.name), p.name]));
     const receipts = new Set(facts.receiptAssignments().map((r) => JSON.stringify([r.owner, r.index])));
     return { context: [...header.preamble, ...header.warmup].join('\n'), actCount: facts.activityCount({ kinds: NON_READ }), hardCap: header.hardCap,
         ...(header.throttlePerMinute === undefined ? {} : { throttlePerMinute: header.throttlePerMinute }),
-        held: hold.active && hold.actor !== undefined ? { by: hold.actor, ...(hold.reason === undefined ? {} : { reason: hold.reason }) } : null,
-        participants: statuses(facts, now), delivered(name, id) { return receipts.has(JSON.stringify([names.get(nameKey(name)) ?? name, parseRequiredActivityId(id)])); } };
+        participants: coreParticipants(facts, now).filter((p) => p.presence !== 'never-joined').map(({ name, presence, listening }) => ({ name, presence, listening })),
+        delivered(name, id) { return receipts.has(JSON.stringify([names.get(nameKey(name)) ?? name, parseRequiredActivityId(id)])); } };
 }
 export function recoveryObservation(facts, name, now) {
-    const known = resolveKnownName(facts, name), hold = facts.hold();
-    return { participant: known, roster: rosterNames(facts), activitySummaries: unreadActivitySummaries(facts, known, now), standingCount: inSquareCount(facts), held: hold.active,
-        ...(hold.reason === undefined ? {} : { holdReason: hold.reason }), ownActivityCount: facts.participant(known).sayCount, hardCap: facts.header().hardCap };
+    const known = resolveKnownName(facts, name);
+    return { participant: known, activitySummaries: unreadActivitySummaries(facts, known, now), standingCount: inSquareCount(facts),
+        ownActivityCount: facts.participant(known).sayCount, hardCap: facts.header().hardCap };
 }
 export function entryPresentation(facts, name, lastN = HISTORY_DEFAULT_LIMIT) {
     const header = facts.header();
     const recentActivities = selectHistory(facts, {}, lastN, ['say', 'done']).activities;
     return { joinedBefore: facts.activityCount({ kinds: ['join'], actors: [name] }) > 1,
         scene: header.warmup.join('\n').trim(),
-        joinContext: (header.preamble.at(-1) === '---' ? header.preamble.slice(0, -1) : header.preamble).join('\n').trim(), recentActivities,
-        perceptions: Object.fromEntries(recentActivities.map((a) => [a.index, perceiveActivity(facts, a, name)])),
-        sayNumbers: facts.sayOrdinals(recentActivities.map((a) => a.index)) };
+        joinContext: (header.preamble.at(-1) === '---' ? header.preamble.slice(0, -1) : header.preamble).join('\n').trim(),
+        recentActivities: recentActivities.map((activity) => ({ ...toPublicActivity(activity), perception: perceiveActivity(facts, activity, name) })) };
 }
 function classifyPresence(participants, now) {
-    const here = participants.filter((participant) => participant.state === 'active' && (participant.presence === 'watching'
+    const standing = (participant) => participant.presence === 'active' || participant.presence === 'watching';
+    const here = participants.filter((participant) => standing(participant) && (participant.presence === 'watching'
         || (participant.lastActiveAt !== undefined && now - participant.lastActiveAt <= STATUS_HERE_WINDOW_MS)));
     const hereNames = new Set(here.map((participant) => participant.name));
     return { orderedHereNames: [...here.filter((participant) => participant.presence === 'watching'), ...here.filter((participant) => participant.presence !== 'watching')].map((participant) => participant.name),
-        lingeringCount: participants.filter((participant) => participant.state === 'active' && !hereNames.has(participant.name)).length,
-        classificationByName: Object.fromEntries(participants.map((participant) => [participant.name, participant.state === 'done' ? 'done'
-                : participant.state === 'not joined' ? 'not-joined' : hereNames.has(participant.name) ? 'here' : 'lingering'])) };
+        lingeringCount: participants.filter((participant) => standing(participant) && !hereNames.has(participant.name)).length,
+        classificationByName: Object.fromEntries(participants.map((participant) => [participant.name, participant.presence === 'done' ? 'done'
+                : participant.presence === 'never-joined' ? 'not-joined' : participant.presence === 'away' ? 'away' : hereNames.has(participant.name) ? 'here' : 'lingering'])) };
 }
 export function queryParticipants(facts, context, observe = false) {
     const participants = coreParticipants(facts, context.now);
     return { participants, ...(!observe ? {} : { observation: { ...context, ...classifyPresence(participants, context.now),
-                standingCount: inSquareCount(facts), held: facts.hold().active } }) };
+                standingCount: inSquareCount(facts) } }) };
 }
 export function listPresentation(facts) {
     const participants = facts.roster().filter((p) => p.joined).map((p) => {
@@ -157,62 +156,57 @@ export function listPresentation(facts) {
 }
 export function queryStatus(facts, context, viewer = '', observe = false) {
     const participants = coreParticipants(facts, context.now);
-    const header = facts.header(), hold = facts.hold(), standingCount = inSquareCount(facts);
-    const listener = participants.find((p) => p.state !== 'not joined' && nameKey(p.name) === nameKey(viewer));
+    const header = facts.header(), standingCount = inSquareCount(facts);
+    const listener = participants.find((p) => p.presence !== 'never-joined' && nameKey(p.name) === nameKey(viewer));
     const latest = facts.activityHeads({ kinds: ['say', 'done'] }, { edge: 'newest', limit: 1 }).items[0];
     const latestAct = latest === undefined ? undefined : facts.activity(latest.index);
     const data = {
         hardCap: header.hardCap,
         ...(header.throttlePerMinute === undefined ? {} : { throttlePerMinute: header.throttlePerMinute }),
-        activeCount: standingCount, doneCount: participants.filter((p) => p.state === 'done').length,
-        hold: hold.active ? {
-            ...(hold.actor === undefined ? {} : { by: hold.actor }),
-            ...(hold.reason === undefined ? {} : { reason: hold.reason }),
-            ...(hold.at === undefined ? {} : { at: hold.at }),
-        } : null,
         ...(listener === undefined ? {} : { listening: listener.listening }),
-        participants: participants.filter((p) => p.state !== 'not joined'), now: context.now,
-        ...(latestAct === undefined || latestAct.actor === undefined || latestAct.kind === 'read' ? {} : { latestActivity: toPublicActivity(latestAct) }),
+        participants: participants.filter((p) => p.presence !== 'never-joined'), now: context.now,
+        ...(latestAct === undefined || latestAct.kind === 'read' ? {} : { latestActivity: toPublicActivity(latestAct) }),
     };
     if (!observe)
         return data;
     const afterIndex = latestAct?.index ?? -1;
-    const joins = facts.activities(facts.activityHeads({ kinds: ['join'], afterIndex }, { edge: 'newest', limit: 3 }).items.map((h) => h.index)).map((activity) => ({ activity,
-        rejoined: facts.activityCount({ kinds: ['done'], actors: [activity.actor], actorMatch: 'exact', beforeIndex: activity.index }) > 0 }));
+    const joins = facts.activities(facts.activityHeads({ kinds: ['join'], afterIndex }, { edge: 'newest', limit: 3 }).items.map((h) => h.index)).map((activity) => ({
+        rejoined: facts.activityCount({ kinds: ['done'], actors: [activity.actor], actorMatch: 'exact', beforeIndex: activity.index }) > 0,
+        activity: toPublicActivity(activity)
+    }));
     const canonicalViewer = facts.participant(viewer)?.name ?? viewer;
     return {
         ...data,
         observation: {
-            ...context, ...classifyPresence(participants, context.now), standingCount, held: hold.active,
+            location: context.location,
+            ...classifyPresence(participants, context.now), standingCount,
             knownParticipantCount: participants.length, viewer: canonicalViewer,
             ...(canonicalViewer === '' ? {} : { participant: canonicalViewer }),
             joins, joinCount: facts.activityCount({ kinds: ['join'], afterIndex }),
             attentionNames: participants.filter((p) => canonicalViewer === '' || nameKey(p.name) === nameKey(canonicalViewer)).map((p) => p.name),
             ...(latestAct === undefined ? {} : { latestPerception: perceiveActivity(facts, latestAct, canonicalViewer) }),
-            ...(latestAct?.kind === 'say' ? { latestActNumber: facts.sayOrdinals([latestAct.index])[latestAct.index] } : {}),
         },
     };
 }
 export function catchPresence(facts, now) {
-    const participants = coreParticipants(facts, now).filter((participant) => participant.state === 'done' || participant.presence === 'watching'
+    const participants = coreParticipants(facts, now).filter((participant) => participant.presence === 'done' || participant.presence === 'away' || participant.presence === 'watching'
         || (participant.lastActiveAt !== undefined && now - participant.lastActiveAt <= PRESENCE_WINDOW_MS));
     return { participants, now };
 }
 export function streamProjection(facts, cursor, recipient) {
-    const page = facts.activityHeads({ afterIndex: cursor }, { edge: 'oldest', limit: PAGE_SIZE });
-    const heads = page.items.flatMap((head) => {
-        const route = recipient === undefined ? undefined : facts.directedAt(recipient, head.index)?.route;
-        return recipient !== undefined && route === undefined ? [] : [{ index: head.index, route }];
-    });
-    return { activities: facts.activities(heads.map((h) => h.index)).map((activity) => {
-            const route = heads.find((h) => h.index === activity.index).route;
-            return { activity, ...(route === undefined ? {} : { route }) };
-        }), cursor: page.items.at(-1)?.index ?? cursor, hasMore: page.hasMore };
+    const page = facts.activityHeads({ afterIndex: cursor, kinds: NON_READ }, { edge: 'oldest', limit: PAGE_SIZE });
+    const heads = recipient === undefined ? page.items : page.items.filter((head) => facts.directedAt(recipient, head.index) !== undefined);
+    const activities = facts.activities(heads.map((head) => head.index)).map((activity) => recipient === undefined
+        ? toPublicActivity(activity) : toPerceivedActivity(facts, activity, recipient));
+    return { activities, cursor: page.items.at(-1)?.index ?? cursor, hasMore: page.hasMore };
 }
 export function streamTailProjection(facts, last = HISTORY_DEFAULT_LIMIT, recipient) {
     if (!Number.isSafeInteger(last) || last < 0 || last > PAGE_SIZE)
         throw new SquareError('invalid_args', `Invalid stream tail: expected a non-negative safe integer no greater than ${PAGE_SIZE}.`);
-    const heads = last === 0 ? [] : recipient === undefined ? facts.activityHeads({}, { edge: 'newest', limit: last }).items : facts.directed(recipient, {}, { edge: 'newest', limit: last }).items;
-    return { activities: facts.activities(heads.map((h) => h.index)).map((activity) => ({ activity,
-            ...(recipient === undefined ? {} : { route: facts.directedAt(recipient, activity.index).route }) })), cursor: facts.header().lastActIndex, hasMore: false };
+    const heads = last === 0 ? [] : recipient === undefined
+        ? facts.activityHeads({ kinds: NON_READ }, { edge: 'newest', limit: last }).items
+        : facts.directed(recipient, {}, { edge: 'newest', limit: last }).items;
+    const activities = facts.activities(heads.map((head) => head.index)).map((activity) => recipient === undefined
+        ? toPublicActivity(activity) : toPerceivedActivity(facts, activity, recipient));
+    return { activities, cursor: facts.header().lastActIndex, hasMore: false };
 }

package/dist/wakes.d.ts

@@ -1,4 +1,4 @@
-import { type WatchLease, type WatchOptions } from './model.js';
+import { type WatchOptions } from './model.js';
 import type { SquareArtifactPort } from './ports.js';
 import type { Seat } from './model.js';
 export type WatchLeaseStart = {
@@ -8,13 +8,9 @@ export type WatchLeaseStart = {
     readonly heartbeatAt: number;
 } | {
     readonly type: 'active';
-    readonly lease: WatchLease;
 };
 export type WatchLeasePulse = {
     readonly type: 'replaced';
-} | {
-    readonly type: 'held';
-    readonly heartbeatAt?: number;
 } | {
     readonly type: 'terminal';
     readonly status: 'capped' | 'quorum';

package/dist/wakes.js

@@ -9,7 +9,7 @@ export async function acquireWatchLease(artifact, seat, at, leaseId, options, si
     const { value } = await artifact.transactAs({ kind: 'participant', seat }, facts => {
         const known = resolveKnownName(facts, name), existing = freshWatchLease(facts, known, at);
         if (existing !== undefined && !options.replace)
-            return { type: 'active', lease: existing };
+            return { type: 'active' };
         facts.putLease(known, newLease(leaseId, at, options), seat.generation);
         return { type: 'started', leaseId, replaced: existing !== undefined, heartbeatAt: at };
     }, signal);
@@ -21,15 +21,13 @@ export async function pulseWatchLease(artifact, seat, at, leaseId, options, hear
         const known = resolveKnownName(facts, name), lease = freshWatchLease(facts, known, at);
         if (lease?.leaseId !== leaseId)
             return { type: 'replaced' };
-        const held = facts.hold().active;
-        const terminal = held ? undefined : watchTerminalStatus(facts, known);
+        const terminal = watchTerminalStatus(facts, known);
         if (terminal !== undefined)
             return { type: 'terminal', status: terminal };
-        const type = held ? 'held' : 'sleep';
         if (!heartbeatDue)
-            return { type };
+            return { type: 'sleep' };
         facts.putLease(known, newLease(leaseId, at, options), seat.generation);
-        return { type, heartbeatAt: at };
+        return { type: 'sleep', heartbeatAt: at };
     }, signal);
     return value;
 }