@astrosheep/square 0.3.69 → 0.3.71

package/dist/square-storage.js

@@ -1,188 +0,0 @@
-import { isDeepStrictEqual } from 'node:util';
-import { createSquareFile, createSquareState, diagnoseSquareFile as diagnoseArtifactFile, probeSquare, observeSquareRevision, readSquareSnapshot, transactSquareSnapshot, writeSquareFile, } from './artifact.js';
-import { canonicalPath } from './canonical-path.js';
-export { createSquareState };
-export async function probeSquareFile(squarePath) {
-    if (!squarePath.endsWith('.square'))
-        return undefined;
-    return probeSquare(await canonicalPath(squarePath));
-}
-export async function diagnoseSquareFile(squarePath) {
-    return diagnoseArtifactFile(await canonicalPath(squarePath));
-}
-/** Test-helper snapshot replacement backed by one SQLite artifact. */
-export async function writeSquareSnapshot(squarePath, squareState) {
-    await writeSquareFile(await canonicalPath(squarePath), squareState);
-}
-/** Race-safe non-force creation for the file adapter. */
-export async function createSquareSnapshot(squarePath, squareState) {
-    return createSquareFile(await canonicalPath(squarePath), squareState);
-}
-function cloneState(squareState) {
-    return structuredClone(squareState);
-}
-function assertCellOpen(closed) {
-    if (closed)
-        throw new Error('Square artifact is closed');
-}
-function isThenable(value) {
-    return (typeof value === 'object' || typeof value === 'function') && value !== null
-        && typeof value.then === 'function';
-}
-function discardThenable(value) {
-    void Promise.resolve(value).catch(() => undefined);
-}
-/** In-process artifact for fast behavior tests and embedded consumers. */
-export function createMemoryCell(initial) {
-    let state = cloneState(initial);
-    let version = 0;
-    let closed = false;
-    let tail = Promise.resolve();
-    const waiters = new Set();
-    function publish() {
-        for (const waiter of [...waiters]) {
-            if (version <= waiter.since)
-                continue;
-            clearTimeout(waiter.timer);
-            waiters.delete(waiter);
-            waiter.signal?.removeEventListener("abort", waiter.onAbort);
-            waiter.resolve(true);
-        }
-    }
-    return {
-        transact(fn, signal) {
-            assertCellOpen(closed);
-            if (signal?.aborted)
-                throw signal.reason ?? new Error('Square artifact operation aborted');
-            const operation = tail.then(() => {
-                assertCellOpen(closed);
-                if (signal?.aborted)
-                    throw signal.reason ?? new Error('Square artifact operation aborted');
-                const current = cloneState(state);
-                const outcome = fn(current, version);
-                if (isThenable(outcome)) {
-                    discardThenable(outcome);
-                    throw new TypeError('Square artifact transitions must be synchronous.');
-                }
-                if (typeof outcome !== 'object' || outcome === null || !Object.hasOwn(outcome, 'result')) {
-                    throw new TypeError('Square artifact transition must return { state?, result }.');
-                }
-                if (outcome.state !== undefined && !isDeepStrictEqual(outcome.state, state)) {
-                    state = cloneState(outcome.state);
-                    version += 1;
-                    publish();
-                }
-                return outcome.result;
-            });
-            tail = operation.then(() => undefined, () => undefined);
-            return operation;
-        },
-        async read(signal) {
-            assertCellOpen(closed);
-            if (signal?.aborted)
-                throw signal.reason ?? new Error('Square artifact operation aborted');
-            await tail;
-            assertCellOpen(closed);
-            if (signal?.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("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("Square artifact operation aborted"));
-                    return;
-                }
-                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,
-                    timer: setTimeout(() => { waiters.delete(waiter); signal?.removeEventListener("abort", abort); resolve(false); }, timeoutMs),
-                    onAbort: abort,
-                    signal,
-                };
-                waiters.add(waiter);
-                signal?.addEventListener("abort", abort, { once: true });
-            });
-        },
-        async close() {
-            if (closed)
-                return;
-            closed = true;
-            await tail;
-            for (const waiter of [...waiters]) {
-                clearTimeout(waiter.timer);
-                waiters.delete(waiter);
-                waiter.signal?.removeEventListener("abort", waiter.onAbort);
-                waiter.resolve(false);
-            }
-        },
-    };
-}
-/** SQLite-backed artifact. Revisions are read from the authoritative database, not file metadata. */
-export function createFileCell(squarePath, externalSignal) {
-    let closed = false;
-    let storage;
-    let tail = Promise.resolve();
-    const cancel = new AbortController();
-    function storagePath() {
-        storage ??= canonicalPath(squarePath);
-        return storage;
-    }
-    /** Close wins over every operation; a per-call deadline bounds busy retries alongside it. */
-    function operationSignal(signal) {
-        if (signal === undefined && externalSignal === undefined)
-            return cancel.signal;
-        return AbortSignal.any([cancel.signal, ...(externalSignal === undefined ? [] : [externalSignal]), ...(signal === undefined ? [] : [signal])]);
-    }
-    return {
-        transact(fn, signal) {
-            assertCellOpen(closed);
-            const opSignal = operationSignal(signal);
-            const operation = tail.then(async () => {
-                assertCellOpen(closed);
-                const result = await transactSquareSnapshot(await storagePath(), fn, opSignal);
-                return result.result;
-            });
-            tail = operation.then(() => undefined, () => undefined);
-            return operation;
-        },
-        async read(signal) {
-            assertCellOpen(closed);
-            await tail;
-            assertCellOpen(closed);
-            const snapshot = await readSquareSnapshot(await storagePath(), operationSignal(signal));
-            return { state: cloneState(snapshot.state), version: snapshot.revision };
-        },
-        async changed(sinceVersion, timeoutMs, signal) {
-            assertCellOpen(closed);
-            const deadline = Date.now() + Math.max(0, timeoutMs);
-            const observer = await observeSquareRevision(await storagePath());
-            try {
-                return await observer.changed(sinceVersion, Math.max(0, deadline - Date.now()), operationSignal(signal));
-            }
-            catch (error) {
-                if (closed || cancel.signal.aborted)
-                    return false;
-                throw error;
-            }
-            finally {
-                observer.close();
-            }
-        },
-        async close() {
-            if (closed)
-                return;
-            closed = true;
-            cancel.abort(new Error('Square artifact is closed'));
-            await tail;
-        },
-    };
-}

package/dist/square-wiring.d.ts

@@ -1,33 +0,0 @@
-import type { Activity, ExpressResult, HistoryQuery, ParticipantStatus, SquareSnapshot } from './square-facade.js';
-import type { Participant, OperationControl, SquareAtInput, SquareBuildInput } from './square-facade.js';
-export declare class Square {
-    readonly location: string;
-    private readonly square;
-    private readonly context;
-    private constructor();
-    static at(input: SquareAtInput, control?: OperationControl): Promise<Square>;
-    static build(input: SquareBuildInput): Promise<Square>;
-    static inMemory(input: Omit<SquareBuildInput, 'path'>): Square;
-    join(name: string, control?: OperationControl): Promise<Participant>;
-    joinWithActivity(name: string, control?: OperationControl): Promise<{
-        readonly participant: Participant;
-        readonly activity: Activity | null;
-    }>;
-    takeoverWithActivity(name: string, control?: OperationControl): Promise<{
-        readonly participant: Participant;
-        readonly activities: readonly Activity[];
-    }>;
-    takeover(name: string, control?: OperationControl): Promise<Participant>;
-    doneOwnedSession(name: string, body: string, expectedEpoch: number, control?: OperationControl): Promise<ExpressResult>;
-    implicitJoin(name: string, control?: OperationControl): Promise<{
-        readonly state: 'joined' | 'active' | 'done';
-        readonly participant?: Participant;
-    }>;
-    participants(): Promise<ParticipantStatus[]>;
-    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>;
-}

package/dist/square-wiring.js

@@ -1,109 +0,0 @@
-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 { 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;
-    context;
-    constructor(name, square, context) {
-        this.name = name;
-        this.square = square;
-        this.context = context;
-    }
-    express(body, options, control) {
-        return express(this.context, this.name, body, options, control);
-    }
-    listen(target, control) {
-        return listen(this.context, this.name, target, control);
-    }
-    ignore(target, control) {
-        return ignore(this.context, this.name, target, control);
-    }
-    listening(control) {
-        return listening(this.context, this.name, control);
-    }
-    catch(options, control) {
-        return catchUp(this.context, this.name, options, undefined, control);
-    }
-    history(query, control) {
-        return participantHistory(this.square, this.name, query, control);
-    }
-    hold(reason, control) {
-        return hold(this.context, this.name, reason, control);
-    }
-    resume(control) {
-        return resume(this.context, this.name, control);
-    }
-    done(body, control) {
-        return done(this.context, this.name, body, {}, control);
-    }
-}
-export class Square {
-    location;
-    square;
-    context;
-    constructor(location, square) {
-        this.location = location;
-        this.square = square;
-        this.context = { ...square, location };
-    }
-    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));
-    }
-    static inMemory(input) {
-        return new Square('memory', buildMemorySquare(input));
-    }
-    async join(name, control) {
-        const joined = await join(this.context, name, control);
-        return new ParticipantHandle(joined.name, this.square, this.context);
-    }
-    async joinWithActivity(name, control) {
-        const joined = await join(this.context, name, control);
-        return { participant: new ParticipantHandle(joined.name, this.square, this.context), activity: joined.activity };
-    }
-    async takeoverWithActivity(name, control) {
-        const result = await takeover(this.context, name, [], control);
-        return { participant: new ParticipantHandle(result.name, this.square, this.context), activities: result.activities };
-    }
-    async takeover(name, control) {
-        return (await this.takeoverWithActivity(name, control)).participant;
-    }
-    doneOwnedSession(name, body, expectedEpoch, control) {
-        return done(this.context, name, body, { expectedEpoch }, control);
-    }
-    async implicitJoin(name, control) {
-        const joined = await implicitJoin(this.context, name, control);
-        return joined.state === 'done'
-            ? { state: joined.state }
-            : { state: joined.state, participant: new ParticipantHandle(joined.name, this.square, this.context) };
-    }
-    participants() { return participants(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 = sessionIdsFromEnvironment(env);
-        if (sessions.length === 0)
-            return null;
-        const candidates = (await Promise.all(sessions.map((sessionId) => projectSessionBindings({
-            hostLedger: this.square.hostLedger,
-            location: this.square.location,
-            sessionId,
-        })))).flat();
-        if (candidates.length !== 1)
-            return null;
-        const canonicalName = await currentParticipant(this.square, candidates[0].participant);
-        return canonicalName === undefined ? null : new ParticipantHandle(canonicalName, this.square, this.context);
-    }
-    close() { return closeOpenSquare(this.square); }
-    endOwnedSession(name, sessionId, expectedEpoch) { return endOwnedSession(this.context, name, sessionId, expectedEpoch); }
-    retireEndedSessionRoutes(sessionId) { return retireEndedSessionRoutes(this.context, sessionId); }
-}

package/dist/watch.d.ts

@@ -1,8 +0,0 @@
-import { type WatchOptions } from './model.js';
-interface WatchCallerContext {
-    readonly cwd: string;
-    readonly env: NodeJS.ProcessEnv;
-}
-/** `false` is reserved for a quiet --now; idle completion preserves its existing sweep boundary. */
-export declare function cmdWatch(squarePath: string, name: string, opts: WatchOptions, caller?: WatchCallerContext): Promise<boolean | undefined>;
-export {};

package/dist/watch.js

@@ -1,252 +0,0 @@
-import { isSquareError, } from './model.js';
-import { STALE_MS, WATCH_HEARTBEAT_MS, countSays, inSquareCount, nowMs, } from './runtime.js';
-import { openSquare } from './square-file-adapter.js';
-import { closeOpenSquare } from './open-square.js';
-import { createSquareApplication } from './square-application.js';
-import { resolveParticipant, watchPresentation } from './views.js';
-import { acquireWatchLease, ownsWatchLease, pulseWatchLease, releaseWatchLease } from './wakes.js';
-import { renderWatchForceTakeover, renderWatchAlreadyActive, renderWatchReplaceMissing, renderWatchOutput, renderWatchReplaced, renderWatchStatus, formatRefusal, participantCommandPrefix, joinRecoveryCommand, participantsRecoveryCommand, withPathOutput, } from './presentation.js';
-import { hasAutomaticDeliveryIdentity } from './registry.js';
-import { parseActivityId } from './square-core.js';
-function watchStatusExitCode(status) {
-    return status === 'capped' ? 1 : 0;
-}
-function leaseId() {
-    return `watch_${process.pid}_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-}
-function watchOutputResult(squarePath, presentation, name, caught, opts = {}) {
-    const delivered = caught.activities.flatMap((activity) => {
-        const index = parseActivityId(activity.id);
-        const stored = index === undefined ? undefined : presentation.activities.find((item) => item.index === index);
-        return stored === undefined ? [] : [{ activity: stored, perception: activity.perception }];
-    });
-    // Catch delivers only directed say activities, so there is no lifecycle list to split off.
-    const publicItems = delivered.map(({ activity }) => activity).filter((item) => item.kind === 'say' || item.kind === 'done');
-    const perceptions = new Map(delivered.map(({ activity, perception }) => [activity.index, perception]));
-    return {
-        type: 'output',
-        stdout: renderWatchOutput([...presentation.activities], publicItems, {
-            ...opts,
-            viewer: name,
-            perceptions,
-        }) + (caught.remaining > 0
-            ? `\n○ ${caught.remaining} matching ${caught.remaining === 1 ? 'activity remains' : 'activities remain'}\n${catchContinuationCommand(squarePath, name, opts)}`
-            : ''),
-        remaining: caught.remaining,
-        ...(opts.status ? { status: opts.status } : {}),
-    };
-}
-function catchContinuationCommand(squarePath, name, opts) {
-    const args = ['--now'];
-    if (opts.participants !== undefined && opts.participants.length > 0)
-        args.push('--from', opts.participants.join(','));
-    if (opts.mention !== undefined)
-        args.push('--mention');
-    if (opts.limit !== undefined)
-        args.push('--limit', String(opts.limit));
-    return `${participantCommandPrefix(squarePath, name)} catch ${args.join(' ')}`;
-}
-function writeWatchOutput(squarePath, name, presentation, stdout, remaining, status, idleMs) {
-    const headerOpts = { participantCount: presentation.participantCount };
-    const showCatchHint = !hasAutomaticDeliveryIdentity();
-    if (status) {
-        process.stdout.write(withPathOutput(squarePath, [renderWatchStatus({ status, squarePath, name, idleMs, presence: presentation.presence, showCatchHint }), stdout.trimEnd()].filter(Boolean).join('\n\n').trimEnd(), headerOpts));
-        return;
-    }
-    const fallback = showCatchHint && remaining === 0
-        ? `${participantCommandPrefix(squarePath, name)} catch --idle 30m\n  stay available for new activity`
-        : '';
-    process.stdout.write(withPathOutput(squarePath, [stdout.trimEnd(), fallback].filter(Boolean).join('\n\n').trimEnd(), headerOpts));
-}
-function writeWatchTerminal(squarePath, name, presentation, status, idleMs) {
-    process.stdout.write(withPathOutput(squarePath, renderWatchStatus({
-        status,
-        squarePath,
-        name,
-        ...(idleMs === undefined ? {} : { idleMs }),
-        presence: presentation.presence,
-        showCatchHint: !hasAutomaticDeliveryIdentity(),
-        ownActivityCount: countSays(presentation.state.acts, name),
-        hardCap: presentation.state.hardCap,
-    }), { participantCount: presentation.participantCount }));
-}
-function writeWatchReplaced(squarePath, name, presentation) {
-    process.stdout.write(withPathOutput(squarePath, renderWatchReplaced({ squarePath, name }), { participantCount: presentation.participantCount }));
-}
-async function finishWatchResult(square, squarePath, name, result, leaseId, idleMs) {
-    if (result.type === 'output') {
-        await endWatch(square, name, leaseId);
-        writeWatchOutput(squarePath, name, await watchPresentation(square, name), result.stdout, result.remaining, result.status);
-        process.exitCode = watchStatusExitCode(result.status);
-        return true;
-    }
-    if (result.type === 'terminal') {
-        await endWatch(square, name, leaseId);
-        writeWatchTerminal(squarePath, name, await watchPresentation(square, name), result.status, idleMs);
-        process.exitCode = watchStatusExitCode(result.status);
-        return true;
-    }
-    if (result.type === 'replaced') {
-        writeWatchReplaced(squarePath, name, await watchPresentation(square, name));
-        process.exitCode = 0;
-        return true;
-    }
-    return false;
-}
-async function beginWatch(square, squarePath, name, opts) {
-    const id = leaseId();
-    return acquireWatchLease(square, name, id, opts);
-}
-async function endWatch(square, name, id) {
-    await releaseWatchLease(square, name, id);
-}
-function installWatchInterruptHandler(square, squarePath, name, currentLeaseId) {
-    const onInterrupt = () => {
-        void (async () => {
-            await endWatch(square, name, currentLeaseId());
-            process.stdout.write(withPathOutput(squarePath, '○ you step back — catch stopped'));
-            process.exit(130);
-        })().catch((error) => {
-            process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-            process.exit(130);
-        });
-    };
-    process.once('SIGINT', onInterrupt);
-    return () => {
-        process.off('SIGINT', onInterrupt);
-    };
-}
-async function cmdWatchNow(squarePath, name, opts, caller) {
-    const square = await openSquare(squarePath, { clock: nowMs, env: caller.env });
-    const application = createSquareApplication({ cwd: caller.cwd, env: caller.env, squarePath, participant: name, clock: nowMs });
-    try {
-        const caught = await application.catch({
-            ...(opts.id === undefined ? {} : { id: opts.id }),
-            ...(opts.participants === undefined ? {} : { from: opts.participants }),
-            ...(opts.mention === undefined ? {} : { mention: true }),
-            ...(opts.limit === undefined ? {} : { limit: opts.limit }),
-        });
-        const presentation = await watchPresentation(square, name);
-        const status = presentation.terminalStatus;
-        const result = caught.activities.length > 0
-            ? watchOutputResult(squarePath, presentation, name, caught, { mention: opts.mention, participants: opts.participants, limit: opts.limit, ...(status ? { status } : {}) })
-            : { type: 'terminal', status: status ?? 'empty-now' };
-        await finishWatchResult(square, squarePath, name, result, undefined);
-        return caught.activities.length > 0;
-    }
-    finally {
-        await closeOpenSquare(square);
-    }
-}
-/** `false` is reserved for a quiet --now; idle completion preserves its existing sweep boundary. */
-export async function cmdWatch(squarePath, name, opts, caller = { cwd: process.cwd(), env: { ...process.env } }) {
-    let square;
-    let participantCount;
-    try {
-        square = await openSquare(squarePath, { clock: nowMs, env: caller.env });
-        participantCount = inSquareCount((await square.artifact.read()).state);
-        name = (await resolveParticipant(square, name)).name;
-    }
-    catch (err) {
-        if (isSquareError(err)) {
-            const bodyLines = [err.message];
-            // The caller's own name has never joined; only a join admits it.
-            if (err.facts?.reason === 'never_joined')
-                bodyLines.push(joinRecoveryCommand(squarePath, name));
-            process.stderr.write(formatRefusal(squarePath, bodyLines, participantCount === undefined ? {} : { participantCount }));
-            process.exit(err.code === 'not_found' ? 1 : 2);
-        }
-        throw err;
-    }
-    try {
-        if (opts.mention !== undefined)
-            opts = { ...opts, mention: (await resolveParticipant(square, opts.mention)).name };
-        if (opts.participants !== undefined && opts.participants.length > 0) {
-            opts = { ...opts, participants: await Promise.all(opts.participants.map(async (participant) => (await resolveParticipant(square, participant)).name)) };
-        }
-    }
-    catch (err) {
-        let participantCount;
-        try {
-            participantCount = inSquareCount((await square.artifact.read()).state);
-        }
-        catch { /* the header count is best effort */ }
-        await closeOpenSquare(square).catch(() => undefined);
-        if (isSquareError(err)) {
-            const bodyLines = [err.message];
-            // A filter target is unknown, not the caller; the roster is the useful next read.
-            if (err.facts?.reason === 'never_joined' || err.facts?.reason === 'not_standing')
-                bodyLines.push(participantsRecoveryCommand(squarePath));
-            process.stderr.write(formatRefusal(squarePath, bodyLines, participantCount === undefined ? {} : { participantCount }));
-            process.exit(err.code === 'not_found' ? 1 : 2);
-        }
-        throw err;
-    }
-    if (opts.now) {
-        await closeOpenSquare(square);
-        return cmdWatchNow(squarePath, name, opts, caller);
-    }
-    const start = await beginWatch(square, squarePath, name, opts);
-    if (start.type === 'active') {
-        const presentation = await watchPresentation(square, name);
-        process.stdout.write(withPathOutput(squarePath, renderWatchAlreadyActive({ squarePath, name }), { participantCount: presentation.participantCount }));
-        await closeOpenSquare(square);
-        process.exit(1);
-    }
-    let staleSince = nowMs();
-    let wasHeld = false;
-    let currentLeaseId = start.leaseId;
-    let nextHeartbeatAt = start.heartbeatAt + WATCH_HEARTBEAT_MS;
-    if (opts.replace) {
-        const presentation = await watchPresentation(square, name);
-        process.stdout.write(withPathOutput(squarePath, start.replaced
-            ? renderWatchForceTakeover({ squarePath, name })
-            : renderWatchReplaceMissing({ squarePath, name }), { participantCount: presentation.participantCount }));
-    }
-    const idleMs = opts.idleMs ?? STALE_MS;
-    const removeInterruptHandler = installWatchInterruptHandler(square, squarePath, name, () => currentLeaseId);
-    const application = createSquareApplication({ cwd: caller.cwd, env: caller.env, squarePath, participant: name, clock: nowMs });
-    try {
-        while (true) {
-            // Capture before evaluation: changes during catch/lease checks must not be lost.
-            const baseline = (await square.artifact.read()).version;
-            const leaseState = await pulseWatchLease(square, name, currentLeaseId, opts, nowMs() >= nextHeartbeatAt);
-            if ((leaseState.type === 'sleep' || leaseState.type === 'held') && leaseState.heartbeatAt !== undefined) {
-                nextHeartbeatAt = leaseState.heartbeatAt + WATCH_HEARTBEAT_MS;
-            }
-            let result = leaseState;
-            if (result.type === 'sleep') {
-                const caught = await application.catch({
-                    ...(opts.participants === undefined ? {} : { from: opts.participants }),
-                    ...(opts.mention === undefined ? {} : { mention: true }),
-                    ...(opts.limit === undefined ? {} : { limit: opts.limit }),
-                });
-                if (caught.activities.length > 0) {
-                    result = watchOutputResult(squarePath, await watchPresentation(square, name), name, caught, { mention: opts.mention, participants: opts.participants, limit: opts.limit });
-                }
-            }
-            if (await finishWatchResult(square, squarePath, name, result, currentLeaseId)) {
-                currentLeaseId = undefined;
-                return;
-            }
-            if (result.type === 'held' || wasHeld)
-                staleSince = nowMs();
-            wasHeld = result.type === 'held';
-            if (!wasHeld && nowMs() - staleSince >= idleMs) {
-                const result = !await ownsWatchLease(square, name, currentLeaseId)
-                    ? { type: 'replaced' }
-                    : { type: 'terminal', status: 'stale' };
-                if (await finishWatchResult(square, squarePath, name, result, currentLeaseId, idleMs)) {
-                    currentLeaseId = undefined;
-                    return;
-                }
-            }
-            const nextDeadline = Math.min(nextHeartbeatAt, wasHeld ? Infinity : staleSince + idleMs);
-            await square.artifact.changed(baseline, Math.max(0, nextDeadline - nowMs()));
-        }
-    }
-    finally {
-        await closeOpenSquare(square);
-        removeInterruptHandler();
-    }
-}