@astrosheep/square 0.3.11 → 0.3.13

package/dist/notifications.js

@@ -3,28 +3,24 @@ import { randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { fileURLToPath } from 'node:url';
-import { loadSquare } from './artifact.js';
-import { deriveDeliveryModel, isDeliveryDelivered, isPendingNotification, leaseOwnsNotification, planActNotifications, } from './delivery.js';
+import { leaseOwnsNotification, planActNotifications, } from './delivery.js';
 import { sessionInbox } from './inbox.js';
 import { hasPresentedAttention } from './presented.js';
-import { nameKey, SquareError } from './model.js';
-import { SLEEP_MS, matchesMentionTarget, resolveRosterName, rosterNames } from './runtime.js';
+import { SquareError } from './model.js';
+import { SLEEP_MS, matchesMentionTarget } from './runtime.js';
+import { parseActivityId } from './square-core.js';
 import { PaseoAdapter } from './paseo-delivery.js';
-import { quoteShell } from './presentation.js';
+import { participantIdentity, quoteShell } from './presentation.js';
 import { lookupParticipant } from './registry.js';
-import { isCurrentlyJoined } from './runtime.js';
-import { execute } from './square-application.js';
+import { openSquare } from './square-file-adapter.js';
+import { closeOpenSquare } from './open-square.js';
+import { entryPresentation, notificationDelivered, notificationForAct, pendingDeliveries, resolveParticipant } from './views.js';
+import { claimNotificationLease, releaseNotificationLease, transitionNotificationLease } from './wakes.js';
 import { nextWakeAttemptNumber, recordRecoveredUnknown, recordWakeAttempt, } from './wake-attempts.js';
-import { joinedRecipients, wakeEvidence, wakeIsEligible } from './wake-evidence.js';
+import { wakeEvidence, wakeIsEligible } from './wake-evidence.js';
 import { WakePort } from './wake-port.js';
 const NOTIFY_LEASE_MS = 5 * 60 * 1000;
 export { planActNotifications, matchesMentionTarget };
-function known(doc, name) {
-    const value = resolveRosterName(doc, name);
-    if (value === undefined)
-        throw new SquareError('invalid_args', `Unknown participant "${name}". Expected one of: ${rosterNames(doc).join(', ')}.`);
-    return value;
-}
 export { notificationMessageId } from './delivery.js';
 export function wakeGraceMs(env = process.env) {
     const value = Number.parseInt(env.SQUARE_NOTIFY_DELIVERY_WAIT_MS ?? '5000', 10);
@@ -42,7 +38,7 @@ function renderWakePayload(request) {
         : request.squarePath;
     return [
         '<system-reminder source="square">',
-        `${request.route === 'bell' ? 'Bell' : request.route === 'beside' ? 'Beside' : 'Mention'} from @${request.actor} in \`${display}\``,
+        `${request.route === 'bell' ? 'Bell' : 'Mention'} from ${participantIdentity(request.actor)} in \`${display}\``,
         'The native adapter will present it at the next boundary. If no native wake is available, pull from the square yourself.',
         `\`${catchCommand(request.squarePath, request.recipient)}\``,
         '</system-reminder>',
@@ -51,23 +47,21 @@ function renderWakePayload(request) {
 async function waitForCatch(route, request, body) {
     const binding = lookupParticipant(request.squarePath, request.recipient)
         .find((item) => item.ownerId === route.ownerId);
-    const activeCatch = binding && sessionInbox(binding.sessionId)
+    const activeCatch = binding && (await sessionInbox(binding.sessionId))
         .find((item) => item.name === request.recipient)?.catchLease;
     if (!activeCatch || !leaseOwnsNotification(activeCatch, {
         actor: request.actor,
         body,
         route: request.route,
-        recipient: request.recipient,
     }))
         return false;
     const deadline = Date.now() + 180_000;
     while (Date.now() < deadline) {
-        const doc = loadSquare(request.squarePath);
-        if (isDeliveryDelivered(doc, request.recipient, request.actIndex))
+        if (await hasDeliveredNotification(request.squarePath, request.recipient, request.actIndex))
             return true;
         const currentBinding = lookupParticipant(request.squarePath, request.recipient)
             .find((item) => item.ownerId === route.ownerId);
-        const lease = currentBinding && sessionInbox(currentBinding.sessionId)
+        const lease = currentBinding && (await sessionInbox(currentBinding.sessionId))
             .find((item) => item.name === request.recipient)?.catchLease;
         if (!lease || lease.expiresAt <= Date.now())
             return false;
@@ -75,58 +69,53 @@ async function waitForCatch(route, request, body) {
     }
     return false;
 }
-export function hasDeliveredNotification(squarePath, name, ref) {
-    const doc = loadSquare(squarePath);
-    return isDeliveryDelivered(doc, known(doc, name), typeof ref === 'number' ? ref : Number(ref.slice(4)));
+function notificationIndex(ref) {
+    if (typeof ref === 'number')
+        return ref;
+    const index = parseActivityId(ref);
+    if (index === undefined)
+        throw new Error(`Invalid act ref: ${ref}`);
+    return index;
 }
-export function hasAttentionNotification(squarePath, name, ref, env = process.env) {
-    const doc = loadSquare(squarePath);
-    const recipient = known(doc, name);
-    const index = typeof ref === 'number' ? ref : Number(ref.slice(4));
-    return isDeliveryDelivered(doc, recipient, index) || hasPresentedAttention(squarePath, recipient, index, env);
+export async function hasDeliveredNotification(squarePath, name, ref) {
+    const square = await openSquare(squarePath);
+    try {
+        const recipient = (await resolveParticipant(square, name)).name;
+        return notificationDelivered(square, recipient, notificationIndex(ref));
+    }
+    finally {
+        await closeOpenSquare(square);
+    }
+}
+export async function hasAttentionNotification(squarePath, name, ref, env = process.env) {
+    const square = await openSquare(squarePath);
+    try {
+        const recipient = (await resolveParticipant(square, name)).name;
+        const index = notificationIndex(ref);
+        return await notificationDelivered(square, recipient, index) || hasPresentedAttention(squarePath, recipient, index, env);
+    }
+    finally {
+        await closeOpenSquare(square);
+    }
 }
 export async function waitForDeliveredNotification(squarePath, name, ref, opts = {}) {
     const deadline = Date.now() + (opts.timeoutMs ?? 30000);
     while (Date.now() <= deadline) {
-        if (hasDeliveredNotification(squarePath, name, ref))
+        if (await hasDeliveredNotification(squarePath, name, ref))
             return true;
         await sleep(Math.min(SLEEP_MS, Math.max(1, deadline - Date.now())));
     }
     return false;
 }
-function notifyLeaseKey(recipient, actIndex) {
-    return JSON.stringify([`act_${actIndex}`, nameKey(recipient)]);
-}
-async function claimNotifyLease(squarePath, recipient, actIndex) {
-    const at = Date.now();
-    const committed = await execute(squarePath, {
-        type: 'claim-notify',
-        key: notifyLeaseKey(recipient, actIndex),
-        leaseId: randomUUID(),
-        at,
-        expiresAt: at + NOTIFY_LEASE_MS,
-    });
-    return committed.result;
+async function claimNotifyLease(square, recipient, actIndex) {
+    const leaseId = randomUUID();
+    return claimNotificationLease(square, recipient, actIndex, leaseId, NOTIFY_LEASE_MS);
 }
-async function transitionNotifyLease(squarePath, recipient, actIndex, leaseId, phase, routeKind, attemptN) {
-    const at = Date.now();
-    const committed = await execute(squarePath, {
-        type: 'transition-notify',
-        key: notifyLeaseKey(recipient, actIndex),
-        leaseId,
-        expiresAt: at + NOTIFY_LEASE_MS,
-        phase,
-        ...(routeKind === undefined ? {} : { routeKind }),
-        ...(attemptN === undefined ? {} : { attemptN }),
-    });
-    return committed.result.updated;
+async function transitionNotifyLease(square, recipient, actIndex, leaseId, phase, routeKind, attemptN) {
+    return transitionNotificationLease(square, recipient, actIndex, leaseId, phase, NOTIFY_LEASE_MS, routeKind, attemptN);
 }
-function releaseNotifyLease(squarePath, recipient, actIndex, leaseId) {
-    return execute(squarePath, {
-        type: 'release-notify',
-        key: notifyLeaseKey(recipient, actIndex),
-        leaseId,
-    });
+async function releaseNotifyLease(square, recipient, actIndex, leaseId) {
+    await releaseNotificationLease(square, recipient, actIndex, leaseId);
 }
 async function processNotification(squarePath, notification, opts) {
     const env = opts.env ?? process.env;
@@ -137,23 +126,27 @@ async function processNotification(squarePath, notification, opts) {
         recipient: notification.recipient,
     };
     const initialAt = now();
-    if (!wakeIsEligible(wakeEvidence(squarePath, notification.recipient, notification.item.index, initialAt, env)))
+    if (!wakeIsEligible(await wakeEvidence(squarePath, notification.recipient, notification.item.index, initialAt, env)))
         return;
-    const claim = await claimNotifyLease(squarePath, notification.recipient, notification.item.index);
-    if (claim.type === 'busy')
+    const square = await openSquare(squarePath, { clock: now });
+    const claim = await claimNotifyLease(square, notification.recipient, notification.item.index);
+    if (claim.type === 'busy' || claim.type === 'delivered') {
+        await closeOpenSquare(square);
         return;
+    }
     if (claim.type === 'ambiguous') {
         const recovered = recordRecoveredUnknown(attention, claim.lease, env);
         if (recovered !== undefined) {
-            await releaseNotifyLease(squarePath, notification.recipient, notification.item.index, claim.lease.leaseId);
+            await releaseNotifyLease(square, notification.recipient, notification.item.index, claim.lease.leaseId);
         }
+        await closeOpenSquare(square);
         return;
     }
     const { leaseId } = claim;
     let releaseLease = true;
     try {
         const dispatchAt = now();
-        const evidence = wakeEvidence(squarePath, notification.recipient, notification.item.index, dispatchAt, env);
+        const evidence = await wakeEvidence(squarePath, notification.recipient, notification.item.index, dispatchAt, env);
         if (!wakeIsEligible(evidence))
             return;
         const port = new WakePort(opts.adapters ?? [new PaseoAdapter()]);
@@ -170,22 +163,21 @@ async function processNotification(squarePath, notification, opts) {
                 if (await waitForCatch(route, request, notification.item.body))
                     return false;
                 const currentAt = now();
-                const latest = loadSquare(squarePath);
-                if (!isCurrentlyJoined(latest.acts, notification.recipient))
+                if (!(await entryPresentation(square, notification.recipient)).joined)
                     return false;
-                const current = wakeEvidence(squarePath, notification.recipient, notification.item.index, currentAt, env);
+                const current = await wakeEvidence(squarePath, notification.recipient, notification.item.index, currentAt, env);
                 if (!wakeIsEligible(current))
                     return false;
                 if (!current.attemptableRoutes.some((candidate) => candidate.ownerId === route.ownerId && candidate.kind === route.kind && candidate.sessionId === route.sessionId))
                     return false;
-                const dispatching = await transitionNotifyLease(squarePath, notification.recipient, notification.item.index, leaseId, 'dispatching', route.kind, attemptN);
+                const dispatching = await transitionNotifyLease(square, notification.recipient, notification.item.index, leaseId, 'dispatching', route.kind, attemptN);
                 if (dispatching)
                     releaseLease = false;
                 return dispatching;
             },
             record: async (route, attemptN, outcome) => {
                 if (outcome.outcome === 'failed') {
-                    await transitionNotifyLease(squarePath, notification.recipient, notification.item.index, leaseId, 'claimed');
+                    await transitionNotifyLease(square, notification.recipient, notification.item.index, leaseId, 'claimed');
                     releaseLease = true;
                 }
                 recordWakeAttempt({
@@ -205,47 +197,47 @@ async function processNotification(squarePath, notification, opts) {
     }
     finally {
         if (releaseLease) {
-            await releaseNotifyLease(squarePath, notification.recipient, notification.item.index, leaseId);
+            await releaseNotifyLease(square, notification.recipient, notification.item.index, leaseId);
         }
+        await closeOpenSquare(square);
     }
 }
 export async function processActNotificationsOnce(squarePath, actIndex, opts = {}) {
-    const doc = loadSquare(squarePath);
-    const item = doc.acts.find((candidate) => candidate.index === actIndex);
-    if (item === undefined)
-        return;
-    const notifications = planActNotifications(doc, item).filter(isPendingNotification);
+    const square = await openSquare(squarePath);
+    const notifications = await notificationForAct(square, actIndex).finally(() => closeOpenSquare(square));
     await Promise.all(notifications.map((notification) => processNotification(squarePath, notification, opts)));
 }
 function launchWorker(workerPath, args) {
     const child = spawn(process.execPath, [workerPath, ...args], { detached: true, stdio: 'ignore', env: process.env });
     child.unref();
 }
-/** Start one detached worker only when this act contains directed attention. */
-export async function dispatchActNotifications(squarePath, item, opts = {}) {
-    const env = opts.env ?? process.env;
-    if (env.SQUARE_DISABLE_PASEO_WAKE === '1')
-        return;
-    const doc = loadSquare(squarePath);
-    if (!planActNotifications(doc, item).some(isPendingNotification))
-        return;
-    (opts.launchWorker ?? launchWorker)(fileURLToPath(new URL('./cmd/notify-once.js', import.meta.url)), ['--location', squarePath, '--act-index', String(item.index)]);
+export function wakeNotifierForSquare(squarePath, env = process.env) {
+    return {
+        wake(recipients, activity) {
+            if (env.SQUARE_DISABLE_PASEO_WAKE === '1' || recipients.length === 0)
+                return;
+            const actIndex = parseActivityId(activity.id);
+            if (actIndex === undefined)
+                return;
+            launchWorker(fileURLToPath(new URL('./cmd/notify-once.js', import.meta.url)), ['--location', squarePath, '--act-index', String(actIndex)]);
+        },
+    };
 }
 /** Reconsider old pending attention at a bounded action boundary using the existing worker. */
-export function sweepPendingNotifications(squarePath, opts = {}) {
+export async function sweepPendingNotifications(squarePath, opts = {}) {
     const env = opts.env ?? process.env;
     if (env.SQUARE_DISABLE_PASEO_WAKE === '1')
         return [];
     const now = opts.now ?? Date.now();
     const limit = opts.limit ?? 8;
-    const doc = loadSquare(squarePath);
-    const model = deriveDeliveryModel(doc);
+    const square = await openSquare(squarePath, { clock: () => now });
+    const pending = await pendingDeliveries(square).finally(() => closeOpenSquare(square));
     const indexes = new Set();
-    for (const recipient of joinedRecipients(doc)) {
-        for (const note of model.pendingFor(recipient)) {
+    for (const delivery of pending) {
+        for (const note of delivery.notifications) {
             if (now - note.item.at <= wakeGraceMs(env))
                 continue;
-            if (!wakeIsEligible(wakeEvidence(squarePath, recipient, note.item.index, now, env)))
+            if (!wakeIsEligible(await wakeEvidence(squarePath, delivery.recipient, note.item.index, now, env)))
                 continue;
             indexes.add(note.item.index);
         }

package/dist/open-square.d.ts

@@ -0,0 +1,11 @@
+import type { StateCell } from './state-cell.js';
+import type { WakeNotifier } from './square-facade.js';
+/** Private binding assembled by storage and consumed by the four concerns. */
+export interface OpenSquare {
+    readonly cell: StateCell;
+    readonly clock: () => number;
+    readonly notifier?: WakeNotifier;
+    readonly location: string;
+}
+/** Package-private lifecycle boundary for bound squares. */
+export declare function closeOpenSquare(square: OpenSquare): Promise<void>;

package/dist/open-square.js

@@ -0,0 +1,4 @@
+/** Package-private lifecycle boundary for bound squares. */
+export function closeOpenSquare(square) {
+    return square.cell.close();
+}

package/dist/participant-identity.d.ts

@@ -0,0 +1 @@
+export declare function participantIdentity(name: string): string;

package/dist/participant-identity.js

@@ -0,0 +1,3 @@
+export function participantIdentity(name) {
+    return `@${name}`;
+}

package/dist/paseo-connection.d.ts

@@ -0,0 +1,15 @@
+import { DaemonClient } from '@getpaseo/client/internal/daemon-client';
+export type PaseoDaemonTarget = {
+    type: 'tcp';
+    url: string;
+    password?: string;
+} | {
+    type: 'ipc';
+    url: string;
+    socketPath: string;
+    password?: string;
+};
+/** Match the host precedence used by the Paseo CLI for local daemon connections. */
+export declare function paseoDaemonHosts(env?: NodeJS.ProcessEnv): string[];
+export declare function resolvePaseoDaemonTarget(host: string, env?: NodeJS.ProcessEnv): PaseoDaemonTarget;
+export declare function connectPaseoDaemon(env?: NodeJS.ProcessEnv, connectTimeoutMs?: number): Promise<DaemonClient>;

package/dist/paseo-delivery.d.ts

@@ -0,0 +1,14 @@
+import { type WakeAdapter, type WakeDispatchResult } from './delivery.js';
+import { discoverPaseoAgents, waitForPaseoWakeBoundary } from './paseo-state.js';
+import { sendPaseoWake } from './wake-sink.js';
+export interface PaseoAdapterOptions {
+    discover?: typeof discoverPaseoAgents;
+    waitForBoundary?: typeof waitForPaseoWakeBoundary;
+    sendWake?: typeof sendPaseoWake;
+}
+export declare class PaseoAdapter implements WakeAdapter {
+    private readonly opts;
+    readonly kind: "paseo";
+    constructor(opts?: PaseoAdapterOptions);
+    dispatch(address: Readonly<Record<string, string>>, payload: string, beforeSend: () => Promise<boolean>): Promise<WakeDispatchResult>;
+}

package/dist/paseo-state.d.ts

@@ -0,0 +1,11 @@
+export interface PaseoAgent {
+    id: string;
+    name: string;
+    status: string;
+    cwd?: string;
+}
+export declare function discoverPaseoAgents(timeoutMs?: number): {
+    agents: PaseoAgent[];
+    error?: string;
+};
+export declare function waitForPaseoWakeBoundary(agent: Pick<PaseoAgent, 'id' | 'status'>): Promise<boolean>;

package/dist/paseo-timeline.d.ts

@@ -0,0 +1,16 @@
+export type PaseoToolStatus = 'running' | 'completed' | 'failed';
+export interface PaseoToolCallSnapshot {
+    callId: string;
+    status: PaseoToolStatus;
+}
+export interface PaseoTimelineSnapshot {
+    agentStatus: string;
+    toolCalls: PaseoToolCallSnapshot[];
+}
+export interface WaitForPaseoToolBoundaryOptions {
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+    readSnapshot?: (agentId: string) => Promise<PaseoTimelineSnapshot>;
+    delay?: (ms: number) => Promise<void>;
+}
+export declare function waitForPaseoToolBoundary(agentId: string, opts?: WaitForPaseoToolBoundaryOptions): Promise<boolean>;

package/dist/presence.d.ts

@@ -0,0 +1,3 @@
+import type { OpenSquare } from './open-square.js';
+import type { CatchOptions, CatchResult } from './square-facade.js';
+export declare function catchUp(square: OpenSquare, name: string, options?: CatchOptions): Promise<CatchResult>;

package/dist/presence.js

@@ -0,0 +1,42 @@
+import { extractMentions, formatActivityId, perceive } from './square-core.js';
+import { ackPeerDelta, deliveryDelta, filteredRoomChanges, matchesFeedFilter, peerPublicActs } from './activity-feed.js';
+import { markDeliveredNotifications } from './delivery.js';
+import { SquareError } from './model.js';
+import { resolveKnownName } from './decisions.js';
+import { readCursor } from './runtime.js';
+function expose(activity, viewer) {
+    if (activity.kind === 'read' || activity.actor === undefined)
+        throw new Error(`Cannot expose stored activity ${formatActivityId(activity.index)}`);
+    const perception = perceive(activity, viewer);
+    const result = { id: formatActivityId(activity.index), at: activity.at, kind: activity.kind, actor: activity.actor, mentions: activity.kind === 'say' ? extractMentions(activity.body) : [], ...('body' in activity && activity.body !== undefined ? { body: activity.body } : {}), ...(activity.kind === 'say' && activity.reply !== undefined ? { reply: formatActivityId(activity.reply) } : {}) };
+    if (perception === 'full' || !('body' in result))
+        return { ...result, perception };
+    const { body: _body, ...withoutBody } = result;
+    return { ...withoutBody, perception };
+}
+export async function catchUp(square, name, options = {}) {
+    const idle = options.idle ?? 0;
+    if (!Number.isFinite(idle) || idle < 0)
+        throw new SquareError('invalid_args', 'Catch idle duration must be a non-negative number');
+    const deadline = Date.now() + idle;
+    while (true) {
+        const attempt = await square.cell.transact((state, version) => {
+            const at = square.clock();
+            const viewer = resolveKnownName(state, name);
+            const delta = deliveryDelta(state, viewer);
+            const filter = { ...(options.from === undefined ? {} : { participants: [...options.from] }), ...(options.mention === true ? { mention: viewer } : {}) };
+            const delivered = [...peerPublicActs(delta, viewer).filter((activity) => matchesFeedFilter(activity, filter)), ...filteredRoomChanges(delta, viewer, filter)]
+                .filter((activity, index, activities) => activities.findIndex((candidate) => candidate.index === activity.index) === index)
+                .sort((left, right) => left.index - right.index);
+            const cursorChanged = ackPeerDelta(state, viewer, delta, at);
+            const receiptsChanged = markDeliveredNotifications(state, viewer, delivered, at);
+            const cursor = readCursor(state, viewer);
+            return { ...(cursorChanged || receiptsChanged ? { state } : {}), result: { version, caught: { activities: delivered.map((activity) => expose(activity, viewer)), consumedThrough: cursor < 0 ? null : formatActivityId(cursor), idleExpired: false } } };
+        });
+        if (attempt.caught.activities.length > 0 || idle === 0)
+            return attempt.caught;
+        const remaining = deadline - Date.now();
+        if (remaining <= 0 || !await square.cell.changed(attempt.version, remaining))
+            return { ...attempt.caught, idleExpired: true };
+    }
+}

package/dist/presentation.d.ts

@@ -0,0 +1,91 @@
+import { type StoredAct, type SquareState, type PublicAct, type RoomChangeAct } from './model.js';
+export { participantIdentity } from './participant-identity.js';
+import type { UnreadActivitySummary, ParticipantStatus } from './decisions.js';
+export type WatchStatus = 'stale' | 'empty-now' | 'quorum' | 'capped';
+interface HeaderOptions {
+    participantCount?: number;
+    held?: boolean;
+}
+interface ParticipantOutputOptions {
+    squarePath: string;
+    name: string;
+    participantCount?: number;
+    held?: boolean;
+}
+interface ActivityLimitOptions extends ParticipantOutputOptions {
+    count?: number;
+    hardCap?: number;
+    draftPath?: string;
+}
+interface ActivityBlockedOptions extends ParticipantOutputOptions {
+    forceCommand: string;
+    activitySummaries: UnreadActivitySummary[];
+    unreadRoomChanges: RoomChangeAct[];
+    draftPath?: string;
+}
+interface ExpressWaitingOptions {
+    reason: 'throttled' | 'held';
+    delayMs?: number;
+}
+interface ExpressNoWaitOptions extends ParticipantOutputOptions {
+    reason: 'throttled' | 'held';
+    delayMs?: number;
+    holdReason?: string;
+    draftPath?: string;
+}
+interface WatchStatusOptions extends ParticipantOutputOptions {
+    status: WatchStatus;
+    idleMs?: number;
+    presence?: {
+        participants: ParticipantStatus[];
+        now: number;
+    };
+    showCatchHint?: boolean;
+}
+export declare function displayPath(squarePath: string, cwd?: string): string;
+export declare function withPathOutput(squarePath: string, body?: string, opts?: HeaderOptions): string;
+export declare function quoteShell(value: string): string;
+export declare function commandPrefix(squarePath: string): string;
+export declare function participantCommandPrefix(squarePath: string, name: string): string;
+export declare function renderPresenceLines(participants: ParticipantStatus[], now: number, limit?: number): string[];
+export declare function expressHintLine(ownActivityCount: number): string | undefined;
+export declare function truncateChars(body: string, maxChars: number): {
+    text: string;
+    remaining: number;
+};
+export declare function previewActivityBody(body: string): string;
+export declare function renderRoomChangeText(event: RoomChangeAct): string;
+export declare function renderEventCli(event: StoredAct, opts?: {
+    now?: number;
+    preview?: number;
+    actNumber?: number;
+    mention?: string;
+}): string;
+export declare function renderAmbientEvent(event: StoredAct, viewer: string, opts?: {
+    now?: number;
+    preview?: number;
+    actNumber?: number;
+    mention?: string;
+}): string;
+export declare function renderPendingFeed(history: StoredAct[], publicItems: PublicAct[], roomChanges: RoomChangeAct[], viewer?: string): string;
+export declare function renderActivityBlocked(opts: ActivityBlockedOptions): string;
+export declare function renderExpressWaiting(opts: ExpressWaitingOptions): string;
+export declare function renderExpressNoWait(opts: ExpressNoWaitOptions): string;
+export declare function renderPublicTail(events: StoredAct[], lastN: number | null | undefined, now?: number, viewer?: string): string;
+export declare function renderActivitiesView(squareState: SquareState, visible: StoredAct[], lastN: number | null | undefined, full: boolean | undefined, squarePath: string, viewer?: string, mode?: 'ambient' | 'archive'): string;
+export declare function renderGrepActivitiesView(visible: StoredAct[], totalMatches: number, full: boolean | undefined, squarePath: string, pattern: string, fixed?: boolean): string;
+export declare function renderActivityLimit(opts: ActivityLimitOptions): string;
+export declare function renderWatchAlreadyActive(opts: ParticipantOutputOptions): string;
+export declare function renderWatchForceTakeover(_opts: ParticipantOutputOptions): string;
+export declare function renderWatchReplaced(_opts: ParticipantOutputOptions): string;
+export declare function renderWatchStatus(opts: WatchStatusOptions): string;
+export declare function renderDoctorClean(): string;
+export declare function renderDoctorUnfixable(reason: string): string;
+export declare function renderWatchOutput(history: StoredAct[], publicItems: PublicAct[], roomChanges: RoomChangeAct[], opts: {
+    squarePath: string;
+    stalePartial?: boolean;
+    idleMs?: number;
+    mention?: string;
+    viewer: string;
+    showCatchHint?: boolean;
+}): string;