@astrosheep/square 0.3.33 → 0.3.35

package/dist/paseo-state.js

@@ -1,8 +1,8 @@
 import { execFileSync } from 'node:child_process';
 import { waitForPaseoToolBoundary } from './paseo-timeline.js';
-export function discoverPaseoAgents(timeoutMs = 5000) {
+export function discoverPaseoAgents(timeoutMs = 5000, opts = {}) {
     try {
-        const raw = execFileSync(process.env.SQUARE_PASEO_BIN || 'paseo', ['ls', '--global', '--json'], {
+        const raw = execFileSync(opts.bin ?? process.env.SQUARE_PASEO_BIN ?? 'paseo', [...(opts.args ?? []), 'ls', '--global', '--json'], {
             encoding: 'utf8',
             timeout: timeoutMs,
             stdio: ['ignore', 'pipe', 'pipe'],

package/dist/presentation.d.ts

@@ -30,6 +30,7 @@ interface ExpressWaitingOptions {
 }
 interface ExpressNoWaitOptions extends ParticipantOutputOptions {
     reason: 'throttled' | 'held';
+    forceCommand: string;
     delayMs?: number;
     holdReason?: string;
     draftPath?: string;
@@ -54,6 +55,7 @@ export declare function truncateChars(body: string, maxChars: number): {
     text: string;
     remaining: number;
 };
+export declare function truncateExternalDiagnostic(diagnostic: string): string;
 export declare function previewActivityBody(body: string): string;
 export declare function renderRoomChangeText(event: RoomChangeAct): string;
 export declare function renderEventCli(event: StoredAct, opts?: {
@@ -65,6 +67,7 @@ export declare function renderEventCli(event: StoredAct, opts?: {
 export declare function renderAmbientEvent(event: StoredAct, viewer: string, opts?: {
     now?: number;
     preview?: number;
+    presencePreview?: number;
     actNumber?: number;
     mention?: string;
     squareState?: SquareState;
@@ -81,6 +84,7 @@ export declare function renderGrepActivitiesView(visible: StoredAct[], totalMatc
 export declare function renderActivityLimit(opts: ActivityLimitOptions): string;
 export declare function renderWatchAlreadyActive(opts: ParticipantOutputOptions): string;
 export declare function renderWatchForceTakeover(_opts: ParticipantOutputOptions): string;
+export declare function renderWatchReplaceMissing(_opts: ParticipantOutputOptions): string;
 export declare function renderWatchReplaced(_opts: ParticipantOutputOptions): string;
 export declare function renderWatchStatus(opts: WatchStatusOptions): string;
 export declare function renderDoctorClean(): string;

package/dist/presentation.js

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { participantIdentity } from './participant-identity.js';
 export { participantIdentity } from './participant-identity.js';
-import { audienceIncludes, audienceOf } from './square-core.js';
+import { audienceIncludes, audienceOf, MAX_IDENTITY_SET_SIZE } from './square-core.js';
 import { perceiveActivity } from './delivery.js';
 import { actId, publicActs, readCursor, rosterNames, sayNumberFor } from './runtime.js';
 import { formatDuration, formatRelativeTime, formatTimestamp } from './time.js';
@@ -15,7 +15,7 @@ function headerLine(squarePath, opts = {}) {
 }
 export function displayPath(squarePath, cwd = process.cwd()) {
     if (!path.isAbsolute(squarePath))
-        return squarePath;
+        return squarePath.split(path.sep).join('/');
     const comparableCwd = fs.realpathSync.native(cwd);
     let comparableSquarePath = squarePath;
     try {
@@ -25,7 +25,8 @@ export function displayPath(squarePath, cwd = process.cwd()) {
         // Some error outputs name a path before it exists; lexical comparison remains useful there.
     }
     const relative = path.relative(comparableCwd, comparableSquarePath);
-    return relative !== '' && relative !== '..' && !relative.startsWith(`..${path.sep}`) ? relative : squarePath;
+    const displayed = relative !== '' && relative !== '..' && !relative.startsWith(`..${path.sep}`) ? relative : squarePath;
+    return displayed.split(path.sep).join('/');
 }
 export function withPathOutput(squarePath, body = '', opts = {}) {
     return [headerLine(squarePath, opts), ...(body === '' ? [] : ['', body])].join('\n') + '\n';
@@ -105,6 +106,12 @@ export function truncateChars(body, maxChars) {
         return { text: body, remaining: 0 };
     return { text: chars.slice(0, maxChars).join('').trimEnd(), remaining: chars.length - maxChars };
 }
+const EXTERNAL_DIAGNOSTIC_MAX_CHARS = 160;
+export function truncateExternalDiagnostic(diagnostic) {
+    if (truncateChars(diagnostic, EXTERNAL_DIAGNOSTIC_MAX_CHARS).remaining === 0)
+        return diagnostic;
+    return `${truncateChars(diagnostic, EXTERNAL_DIAGNOSTIC_MAX_CHARS - 1).text}…`;
+}
 function previewBody(body, maxLen = BODY_PREVIEW_LENGTH) {
     const preview = truncateChars(body, maxLen);
     return preview.remaining === 0 ? preview.text : `${preview.text}\n… ${preview.remaining} more chars`;
@@ -181,7 +188,12 @@ function renderPresenceOnlySay(event, opts = {}) {
     if (targets.length === 0) {
         return `● ${participantIdentity(event.actor)} #${opts.actNumber ?? 1} · ${actId(event)} · ${formatRelativeTime(event.at, opts.now)}`;
     }
-    const dest = ` ${targets.map((name) => participantIdentity(name)).join(' and ')}`;
+    const visibleTargets = targets.slice(0, MAX_IDENTITY_SET_SIZE).map((name) => participantIdentity(name));
+    const remainingTargets = targets.length - visibleTargets.length;
+    const dest = ` ${[
+        ...visibleTargets,
+        ...(remainingTargets === 0 ? [] : [`${remainingTargets} ${remainingTargets === 1 ? 'other' : 'others'}`]),
+    ].join(' and ')}`;
     return `● ${participantIdentity(event.actor)} #${opts.actNumber ?? 1} · ${actId(event)} · ${formatRelativeTime(event.at, opts.now)}\n  talked to${dest}`;
 }
 export function renderAmbientEvent(event, viewer, opts = {}) {
@@ -191,8 +203,11 @@ export function renderAmbientEvent(event, viewer, opts = {}) {
         throw new Error('Ambient say rendering requires a settled perception or SquareState');
     }
     const seen = opts.perception ?? perceiveActivity(opts.squareState, event, viewer);
-    if (seen === 'presence')
-        return renderPresenceOnlySay(event, opts);
+    if (seen === 'presence') {
+        const presence = renderPresenceOnlySay(event, opts);
+        const body = opts.presencePreview === undefined ? '' : renderedBody(event.body, opts.presencePreview);
+        return `${presence}${bodySuffix(body)}`;
+    }
     return renderEventCli(event, opts);
 }
 function draftSavedLines(draftPath) {
@@ -202,8 +217,10 @@ function withDraftInput(command, draftPath) {
     return draftPath === undefined ? command : `${command} < ${quoteShell(draftPath)}`;
 }
 function renderUnreadSummary(opts) {
+    const visibleSummaries = opts.activitySummaries.slice(0, MAX_IDENTITY_SET_SIZE);
+    const remainingSummaries = opts.activitySummaries.length - visibleSummaries.length;
     return [
-        ...opts.activitySummaries.flatMap((item) => [
+        ...visibleSummaries.flatMap((item) => [
             ...item.previews.slice(-1).map((preview) => {
                 const rendered = renderAmbientEvent(preview.act, opts.viewer, { actNumber: preview.number, perception: preview.perception });
                 if (rendered === '')
@@ -214,6 +231,7 @@ function renderUnreadSummary(opts) {
                 return `  · ${participantIdentity(item.name)} spoke — ${formatAge(item.latestActivityAgeMs)} ago · "${previewActivityBody(preview.act.body)}"`;
             }),
         ]),
+        ...(remainingSummaries === 0 ? [] : [`  · ${remainingSummaries} more participants have unread activity`]),
         ...opts.roomChanges.map((act) => `  · ${renderRoomChangeText(act)}`),
     ];
 }
@@ -254,7 +272,7 @@ export function renderExpressWaiting(opts) {
     return ["✕ your activity doesn't land — a hand is raised", '  · your activity is waiting'].join('\n');
 }
 export function renderExpressNoWait(opts) {
-    const retryCommand = `${participantCommandPrefix(opts.squarePath, opts.name)} express -`;
+    const retryCommand = opts.forceCommand;
     const lines = opts.reason === 'throttled'
         ? [
             '✕ the square is packed',
@@ -292,8 +310,11 @@ function lastPresenceAnchor(squareState, name) {
     return -1;
 }
 export function renderPresenceAnchor(names) {
-    const participants = names.map((name) => participantIdentity(name)).join(', ');
-    return names.length === 1 ? `→ ${participants} was here` : `→ ${participants} were here`;
+    const visibleNames = names.slice(0, MAX_IDENTITY_SET_SIZE);
+    const participants = visibleNames.map((name) => participantIdentity(name)).join(', ');
+    const remaining = names.length - visibleNames.length;
+    const suffix = remaining === 0 ? '' : ` and ${remaining} more`;
+    return names.length === 1 ? `→ ${participants} was here` : `→ ${participants}${suffix} were here`;
 }
 export function renderActivitiesView(squareState, visible, lastN, noTruncate, squarePath, viewer = '', mode = 'ambient') {
     const publicVisible = visible.filter((act) => act.kind === 'say' || act.kind === 'done');
@@ -389,11 +410,19 @@ export function renderActivityLimit(opts) {
     return withPathOutput(opts.squarePath, renderActivityLimitBody(opts), { participantCount: opts.participantCount, held: opts.held });
 }
 export function renderWatchAlreadyActive(opts) {
-    return ['✕ you are already catching', `» ${participantCommandPrefix(opts.squarePath, opts.name)} catch --idle 30m --replace`].join('\n');
+    return [
+        '✕ you are already catching',
+        `  · an active catch is already running for ${participantIdentity(opts.name)}`,
+        '  · wait for it to finish before starting another catch',
+        `» ${commandPrefix(opts.squarePath)} participants`,
+    ].join('\n');
 }
 export function renderWatchForceTakeover(_opts) {
     return '✓ your new catch takes over';
 }
+export function renderWatchReplaceMissing(_opts) {
+    return '⚠ nothing to replace — no active catch was running; your catch started normally';
+}
 export function renderWatchReplaced(_opts) {
     return '✕ a newer catch took over';
 }
@@ -434,7 +463,7 @@ export function renderDoctorClean() {
     return '✓ no problems found';
 }
 export function renderDoctorUnfixable(reason) {
-    return ['✕ unreadable artifact', `  · ${reason}`].join('\n');
+    return ['✕ unreadable artifact', `  · ${truncateExternalDiagnostic(reason)}`].join('\n');
 }
 export function renderWatchOutput(history, publicItems, roomChanges, opts) {
     const sections = [];

package/dist/runtime.d.ts

@@ -12,6 +12,7 @@ export declare function nowMs(): number;
 /** Pure directed-activity filter. Bell matches every viewer; mentions match by audience. */
 export declare function matchesMentionTarget(act: {
     body: string;
+    mentions?: readonly string[];
     reach?: Reach;
 }, mention: string | true): boolean;
 export declare function foldedState(squareState: SquareState): import("./square-core.js").FoldedSquareState;

package/dist/square-actions.d.ts

@@ -16,6 +16,11 @@ export declare function join(square: OperationContext, name: string): Promise<{
     readonly name: string;
     readonly activity: Activity | null;
 }>;
+/** End the standing participant and immediately let the caller reclaim the name. */
+export declare function takeover(square: OperationContext, name: string, oldSessionIds?: readonly string[]): Promise<{
+    readonly name: string;
+    readonly activities: readonly Activity[];
+}>;
 export declare function implicitJoin(square: OperationContext, name: string): Promise<{
     readonly name: string;
     readonly state: 'joined' | 'active' | 'done';

package/dist/square-actions.js

@@ -1,6 +1,6 @@
-import { extractMentions, formatActivityId, parseActivityId } from './square-core.js';
-import { coreDone, coreHold, coreIgnore, coreListen, coreListening, coreResume, decideAct, decideImplicitJoin, decideJoin } from './decisions.js';
-import { SquareError } from './model.js';
+import { formatActivityId, parseActivityId } from './square-core.js';
+import { coreDone, coreHold, coreIgnore, coreListen, coreListening, coreResume, decideAct, decideImplicitJoin, decideJoin, resolveKnownName } from './decisions.js';
+import { nameKey, SquareError } from './model.js';
 import { participantIdentity } from './participant-identity.js';
 import { deliverPending } from './delivery-operations.js';
 import { decideCatch } from './catch-decisions.js';
@@ -48,7 +48,7 @@ function exposeCaught(activity, perception) {
         throw new Error(`Cannot expose stored activity ${formatActivityId(activity.index)}`);
     const result = {
         id: formatActivityId(activity.index), at: activity.at, kind: activity.kind, actor: activity.actor,
-        mentions: activity.kind === 'say' ? extractMentions(activity.body) : [],
+        mentions: activity.kind === 'say' ? activity.mentions ?? [] : [],
         ...('body' in activity && activity.body !== undefined ? { body: activity.body } : {}),
         ...('target' in activity ? { target: activity.target } : {}),
         ...(activity.kind === 'say' && activity.reply !== undefined ? { reply: formatActivityId(activity.reply) } : {}),
@@ -75,11 +75,12 @@ export async function catchUp(square, name, options = {}, project) {
                 activities: attempt.decision.delivered.map((activity) => exposeCaught(activity, attempt.decision.perceptions.get(activity.index) ?? 'full')),
                 consumedThrough: attempt.decision.consumedThrough,
                 idleExpired: false,
+                remaining: attempt.decision.remaining,
             };
         }
         const remaining = deadline - Date.now();
         if (remaining <= 0 || !await square.artifact.changed(attempt.version, remaining)) {
-            return { activities: [], consumedThrough: attempt.decision.consumedThrough, idleExpired: true };
+            return { activities: [], consumedThrough: attempt.decision.consumedThrough, idleExpired: true, remaining: 0 };
         }
     }
 }
@@ -105,7 +106,7 @@ function exposeActivity(stored) {
     return {
         id: formatActivityId(stored.index), at: stored.at, kind: stored.kind, actor: stored.actor,
         ...('body' in stored && stored.body !== undefined ? { body: stored.body } : {}),
-        mentions: stored.kind === 'say' ? extractMentions(stored.body) : [],
+        mentions: stored.kind === 'say' ? stored.mentions ?? [] : [],
         ...('target' in stored ? { target: stored.target } : {}),
         ...(stored.kind === 'say' && stored.reply !== undefined ? { reply: formatActivityId(stored.reply) } : {}),
     };
@@ -128,6 +129,29 @@ export async function join(square, name) {
     await publishIdentityRoute(square, committed.name);
     return { name: committed.name, activity: committed.stored === null ? null : exposeActivity(committed.stored) };
 }
+/** End the standing participant and immediately let the caller reclaim the name. */
+export async function takeover(square, name, oldSessionIds = []) {
+    const now = square.clock();
+    const oldSessions = new Set(oldSessionIds);
+    const committed = await square.artifact.transact((state) => {
+        const joinedName = resolveKnownName(state, name);
+        const done = coreDone(state, joinedName, '', now);
+        const storedDone = committedActivity(storeActs(state, [done]), 'kick');
+        const decision = decideJoin(state, joinedName, now);
+        if (decision.joinAct === undefined)
+            throw new SquareError('already_joined', `${participantIdentity(joinedName)} could not be reclaimed`);
+        const storedJoin = committedActivity(storeActs(state, [decision.joinAct]), 'join');
+        const participantSessions = new Set([
+            ...oldSessions,
+            ...(state.routes ?? []).filter((route) => nameKey(route.participant) === nameKey(joinedName)).map((route) => route.sessionId),
+        ]);
+        state.routes = (state.routes ?? []).filter((route) => nameKey(route.participant) !== nameKey(joinedName) && !participantSessions.has(route.sessionId));
+        return { state, result: { name: joinedName, stored: [storedDone, storedJoin] } };
+    });
+    await ensureLocalPresence(square, committed.name);
+    await publishIdentityRoute(square, committed.name);
+    return { name: committed.name, activities: committed.stored.map(exposeActivity) };
+}
 export async function implicitJoin(square, name) {
     const now = square.clock();
     const committed = await square.artifact.transact((state) => {
@@ -147,7 +171,7 @@ export async function express(square, name, body, options = {}) {
     const now = square.clock();
     const reply = options.reply === undefined ? undefined : parseRequiredActivityId(options.reply);
     const committed = await square.artifact.transact((state) => {
-        const decision = decideAct(state, { name, body, force: options.force ?? false, now, ...(options.reach === undefined ? {} : { reach: options.reach }), ...(reply === undefined ? {} : { reply }) });
+        const decision = decideAct(state, { name, body, force: options.force ?? false, now, mentions: options.mentions, ...(options.reach === undefined ? {} : { reach: options.reach }), ...(reply === undefined ? {} : { reply }) });
         if (decision.type === 'blocked') {
             const pending = decision.activitySummaries.reduce((count, summary) => count + summary.count, 0) + decision.unreadRoomChanges.length;
             throw new SquareError('behind', `${participantIdentity(name)} has pending activity`, { pending });

package/dist/square-core.d.ts

@@ -7,6 +7,7 @@ export type Audience = {
     readonly names: readonly string[];
 };
 export type ActivityId = `act/${number}`;
+export declare const MAX_IDENTITY_SET_SIZE = 10;
 export declare function formatActivityId(index: number): ActivityId;
 export declare function parseActivityId(value: string): number | undefined;
 export interface Hold {
@@ -29,6 +30,7 @@ export type Act = {
     actor: Participant;
     at?: number;
     body: string;
+    mentions: readonly Participant[];
     reach?: Reach;
     reply?: number;
 } | {
@@ -119,10 +121,18 @@ export type ValidationResult = {
     ok: false;
     reason: 'bell_quota';
     nextAt: number;
+} | {
+    ok: false;
+    reason: 'mention_limit';
+    limit: number;
+} | {
+    ok: false;
+    reason: 'listening_limit';
+    limit: number;
 };
-export declare function extractMentions(body: string): string[];
 export declare function audienceOf(say: {
     body: string;
+    mentions?: readonly Participant[];
     reach?: Reach;
 }): Audience;
 export declare function audienceIncludes(audience: Audience, name: string): boolean;

package/dist/square-core.js

@@ -1,3 +1,4 @@
+export const MAX_IDENTITY_SET_SIZE = 10;
 export function formatActivityId(index) {
     if (!Number.isSafeInteger(index) || index < 0) {
         throw new Error(`Invalid activity index: ${index}`);
@@ -18,14 +19,6 @@ function nameKey(name) {
 function sameName(a, b) {
     return nameKey(a) === nameKey(b);
 }
-export function extractMentions(body) {
-    const matches = [];
-    const re = /@([\p{L}\p{N}_-]+(?:\/[\p{L}\p{N}_-]+)*)/gu;
-    let match;
-    while ((match = re.exec(body)) !== null)
-        matches.push(match[1]);
-    return matches;
-}
 function uniqueMentionNames(names) {
     const unique = [];
     for (const name of names) {
@@ -38,7 +31,7 @@ function uniqueMentionNames(names) {
 export function audienceOf(say) {
     if (say.reach === 'bell')
         return { kind: 'bell' };
-    return { kind: 'mentions', names: uniqueMentionNames(extractMentions(say.body)) };
+    return { kind: 'mentions', names: uniqueMentionNames(say.mentions ?? []) };
 }
 export function audienceIncludes(audience, name) {
     if (audience.kind === 'bell')
@@ -300,12 +293,22 @@ export function validate(state, act, options = {}) {
                 return { ok: false, reason: 'done' };
             if (current?.joined !== true)
                 return { ok: false, reason: 'not_joined' };
+            if (act.kind === 'listen'
+                && !isListening(state, act.actor, act.target)
+                && listeningTo(state, act.actor).length >= MAX_IDENTITY_SET_SIZE) {
+                return { ok: false, reason: 'listening_limit', limit: MAX_IDENTITY_SET_SIZE };
+            }
             return { ok: true };
         case 'say': {
             if (current?.done)
                 return { ok: false, reason: 'done' };
             if (current?.joined !== true)
                 return { ok: false, reason: 'not_joined' };
+            const audience = audienceOf(act);
+            const mentionCount = audience.kind === 'mentions' ? audience.names.length : 0;
+            if (mentionCount > MAX_IDENTITY_SET_SIZE) {
+                return { ok: false, reason: 'mention_limit', limit: MAX_IDENTITY_SET_SIZE };
+            }
             if (state.hold.active)
                 return { ok: false, reason: 'held', hold: state.hold };
             const activityCount = current?.activityCount ?? 0;

package/dist/square-facade.d.ts

@@ -15,6 +15,7 @@ export interface PerceivedActivity extends Activity {
 }
 export interface ExpressOptions {
     readonly force?: boolean;
+    readonly mentions?: readonly string[];
     readonly reach?: Reach;
     readonly reply?: ActivityId;
 }
@@ -29,11 +30,13 @@ export interface CatchOptions {
     readonly idle?: number;
     readonly from?: readonly string[];
     readonly mention?: boolean;
+    readonly limit?: number;
 }
 export interface CatchResult {
     readonly activities: readonly PerceivedActivity[];
     readonly consumedThrough: ActivityId | null;
     readonly idleExpired: boolean;
+    readonly remaining: number;
 }
 export interface HistoryQuery {
     readonly limit?: number;
@@ -42,7 +45,7 @@ export interface HistoryQuery {
     readonly after?: ActivityId;
     readonly grep?: string;
     readonly from?: readonly string[];
-    readonly mention?: boolean;
+    readonly mention?: string;
 }
 export interface ParticipantStatus {
     readonly name: string;
@@ -90,7 +93,7 @@ export interface Participant {
     ignore(target: string): Promise<ListenerChangeResult>;
     listening(): Promise<readonly string[]>;
     catch(options?: CatchOptions): Promise<CatchResult>;
-    history(query?: HistoryQuery): Promise<PerceivedActivity[]>;
+    history(query?: HistoryQuery): Promise<Activity[]>;
     hold(reason?: string): Promise<ExpressResult>;
     resume(): Promise<ExpressResult>;
     done(body?: string): Promise<ExpressResult>;

package/dist/square-file-adapter.d.ts

@@ -27,4 +27,4 @@ export type SquareChangeWaitResult<T> = {
 } | {
     status: 'expired';
 };
-export declare function waitForSquareChanges<T>(squarePaths: readonly string[], timeoutMs: number, signal?: AbortSignal, afterReady?: () => Promise<T | undefined>): Promise<SquareChangeWaitResult<T>>;
+export declare function waitForSquareChanges<T>(squarePaths: readonly string[], timeoutMs: number, signal?: AbortSignal, afterReady?: () => Promise<T | undefined>, onArmed?: (armed: boolean) => void): Promise<SquareChangeWaitResult<T>>;

package/dist/square-file-adapter.js

@@ -83,9 +83,11 @@ export function buildMemorySquare(options) {
 function memoryArtifact(cell) {
     return { read: () => cell.read(), transact: (fn) => cell.transact(fn), changed: (since, timeout) => cell.changed(since, timeout), close: () => cell.close() };
 }
-export async function waitForSquareChanges(squarePaths, timeoutMs, signal, afterReady) {
-    if (timeoutMs <= 0 || signal?.aborted || squarePaths.length === 0)
+export async function waitForSquareChanges(squarePaths, timeoutMs, signal, afterReady, onArmed) {
+    if (timeoutMs <= 0 || signal?.aborted || squarePaths.length === 0) {
+        onArmed?.(false);
         return { status: 'expired' };
+    }
     const squares = [];
     try {
         for (const squarePath of [...new Set(squarePaths)]) {
@@ -94,21 +96,26 @@ export async function waitForSquareChanges(squarePaths, timeoutMs, signal, after
             }
             catch { /* stale binding */ }
         }
-        if (squares.length === 0)
+        if (squares.length === 0) {
+            onArmed?.(false);
             return { status: 'expired' };
+        }
         const baselines = await Promise.all(squares.map(async (square) => ({
             square,
             version: (await square.artifact.read()).version,
         })));
         const ready = await afterReady?.();
-        if (ready !== undefined)
+        if (ready !== undefined) {
+            onArmed?.(false);
             return { status: 'ready', value: ready };
+        }
         const waits = baselines.map(async ({ square, version }) => {
             const changed = await square.artifact.changed(version, timeoutMs).catch(() => false);
             if (changed)
                 return true;
             throw new Error('square wait expired');
         });
+        onArmed?.(true);
         let abortWait;
         const abort = new Promise((resolve) => {
             abortWait = () => resolve(false);

package/dist/square-wiring.d.ts

@@ -13,6 +13,7 @@ export declare class Square {
         readonly participant: Participant;
         readonly activity: Activity | null;
     }>;
+    takeover(name: string, oldSessionIds?: readonly string[]): Promise<Participant>;
     implicitJoin(name: string): Promise<{
         readonly state: 'joined' | 'active' | 'done';
         readonly participant?: Participant;

package/dist/square-wiring.js

@@ -1,6 +1,6 @@
 import { closeOpenSquare } from './open-square.js';
 import { buildMemorySquare, buildSquare, openSquare } from './square-file-adapter.js';
-import { catchUp, done, express, hold, ignore, implicitJoin, join, listen, listening, resume, } from './square-actions.js';
+import { catchUp, done, express, hold, ignore, implicitJoin, join, takeover, 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';
@@ -69,6 +69,10 @@ export class Square {
         const joined = await join(this.context, name);
         return { participant: new ParticipantHandle(joined.name, this.square, this.context), activity: joined.activity };
     }
+    async takeover(name, oldSessionIds = []) {
+        const result = await takeover(this.context, name, oldSessionIds);
+        return new ParticipantHandle(result.name, this.square, this.context);
+    }
     async implicitJoin(name) {
         const joined = await implicitJoin(this.context, name);
         return joined.state === 'done'

package/dist/stream.d.ts

@@ -1,3 +1,10 @@
+export type StreamStart = {
+    readonly kind: 'tail';
+    readonly last: number;
+} | {
+    readonly kind: 'after';
+    readonly after: number;
+};
 /** Machine-readable tailing stays available; interactive terminal rendering was retired. */
-export declare function cmdStreamNdjson(squarePath: string, recipient?: string): Promise<void>;
+export declare function cmdStreamNdjson(squarePath: string, recipient?: string, start?: StreamStart): Promise<void>;
 export declare function cmdStream(squarePath: string): Promise<void>;

package/dist/stream.js

@@ -1,33 +1,44 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { once } from 'node:events';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { quoteShell } from './presentation.js';
 import { SLEEP_MS } from './runtime.js';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
-import { streamProjection } from './views.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) {
+export async function cmdStreamNdjson(squarePath, recipient, start = { kind: 'tail', last: 10 }) {
     if (!fs.existsSync(squarePath)) {
         process.stderr.write(`square not found: ${squarePath}\n`);
         process.exitCode = 2;
         return;
     }
-    let cursor = -1;
+    let cursor = start.kind === 'after' ? start.after : -1;
+    let initial = start.kind === 'tail' ? start : undefined;
     while (true) {
         try {
             const square = await openSquare(squarePath);
             try {
-                const projection = await streamProjection(square, cursor, recipient);
+                const projection = initial === undefined
+                    ? await streamProjection(square, cursor, recipient)
+                    : await streamTailProjection(square, initial.last, recipient);
                 for (const item of projection.activities) {
-                    process.stdout.write(`${JSON.stringify({
+                    await writeNdjson({
                         seq: item.activity.index,
                         square: squarePath,
                         ...item.activity,
                         ...(item.route === undefined ? {} : { route: item.route }),
-                    })}\n`);
+                    });
                 }
                 cursor = projection.cursor;
+                initial = undefined;
+                if (projection.hasMore)
+                    continue;
             }
             finally {
                 await closeOpenSquare(square);

package/dist/views.d.ts

@@ -3,7 +3,7 @@ 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 { OpenSquare } from './open-square.js';
-import type { Activity, HistoryQuery, ParticipantStatus, PerceivedActivity, SquareSnapshot } from './square-facade.js';
+import type { Activity, HistoryQuery, ParticipantStatus, SquareSnapshot } from './square-facade.js';
 export interface ActivityPresentation {
     readonly name: string;
     readonly roster: readonly string[];
@@ -28,9 +28,7 @@ export interface EntryPresentation {
     readonly participantCount: number;
 }
 export interface HistoryPresentation {
-    readonly activities: readonly (StoredAct & {
-        readonly perception: 'full' | 'presence';
-    })[];
+    readonly activities: readonly StoredAct[];
     readonly sayNumbers: Readonly<Record<number, number>>;
     readonly presenceAnchors: Readonly<Record<number, readonly string[]>>;
     readonly participantCount: number;
@@ -67,13 +65,14 @@ export interface StreamProjection {
         readonly route?: string;
     }[];
     readonly cursor: number;
+    readonly hasMore: boolean;
 }
 export interface PendingDeliveryProjection {
     readonly recipient: string;
     readonly notifications: readonly PlannedNotification[];
 }
 export declare function history(square: OpenSquare, query?: HistoryQuery): Promise<Activity[]>;
-export declare function participantHistory(square: OpenSquare, name: string, query?: HistoryQuery): Promise<PerceivedActivity[]>;
+export declare function participantHistory(square: OpenSquare, _name: string, query?: HistoryQuery): Promise<Activity[]>;
 export declare function resolveParticipant(square: OpenSquare, name: string): Promise<{
     readonly name: string;
     readonly roster: readonly string[];
@@ -101,6 +100,13 @@ export declare function streamProjection(square: OpenSquare | {
         }>;
     };
 }, cursor: number, recipient?: string): Promise<StreamProjection>;
+export declare function streamTailProjection(square: OpenSquare | {
+    readonly cell: {
+        read(): Promise<{
+            state: SquareState;
+        }>;
+    };
+}, 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[]>;