@astrosheep/square 0.3.70 → 0.3.71

package/dist/plugins/opencode/delivery.js

@@ -1,9 +1,9 @@
 import { nameKey } from '../../model.js';
-import { observeSessionPending, sessionInbox } from '../../inbox.js';
+import { nativePendingPreview, observeSessionPending, sessionInbox } from '../../inbox.js';
 import { hostLedgerForEnv } from '../../registry.js';
-import { openSquare } from '../../square-file-adapter.js';
+import { openSquare } from '../../open-square.js';
 import { closeOpenSquare } from '../../open-square.js';
-import { nativePendingPreview, presentationSuppressesWake, projectPresentationEvidence } from '../../square-projections.js';
+import { presentationSuppressesWake, projectPresentationEvidence } from '../../square-projections.js';
 import { presentPending } from '../../presentation-operations.js';
 import { deliverPending } from '../../delivery-operations.js';
 import { createWakeTransport } from '../../notifications.js';
@@ -13,8 +13,8 @@ import { createNativeInputId, sendNativeText } from '../../packages/agent-delive
 const routeKind = 'opencode-server';
 const key = (location, participant, index) => `${location}\0${nameKey(participant)}\0${index}`;
 /** The one native pending preview: the audience/catch/epoch fence before send and inside presentation. */
-function preview(state, owner, index) {
-    return nativePendingPreview(state, { location: owner.location, routeKind, sessionId: owner.session, participant: owner.participant, actIndex: index, epoch: owner.epoch, address: { sessionId: owner.session }, cancelledThrough: owner.cancelledThrough, now: Date.now() });
+function preview(facts, owner, index) {
+    return nativePendingPreview(facts, { location: owner.location, routeKind, sessionId: owner.session, participant: owner.participant, actIndex: index, epoch: owner.epoch, address: { sessionId: owner.session }, cancelledThrough: owner.cancelledThrough, now: Date.now() });
 }
 function createOpenCodeWakeTransport(target, env, lifetime) {
     const ledger = hostLedgerForEnv(env);
@@ -36,14 +36,14 @@ function createOpenCodeWakeTransport(target, env, lifetime) {
                     return undefined;
                 const square = await openSquare(owner.location, { hostLedger: ledger, env, signal });
                 try {
-                    const prepared = preview((await square.artifact.read(signal)).state, owner, index);
+                    const { value: prepared } = await square.artifact.read((facts) => preview(facts, owner, index), signal);
                     if (!prepared)
                         return undefined;
                     const row = { location: owner.location, participant: owner.participant, session: target.sessionId,
                         activity: request.activity, kind: 'wake', outcome: 'dispatching', routeKind, attemptN: request.attemptN, claimToken: request.claimToken,
                         nativeDelivery: { harness: 'opencode', epoch: owner.epoch ?? 0, inputId: createNativeInputId(), payload: prepared.payload } };
                     if (!await ledger.prepareNativeWake(row) || !await (beforeSend?.() ?? Promise.resolve(true)) || signal.aborted
-                        || preview((await square.artifact.read(signal)).state, owner, index)?.payload !== prepared.payload)
+                        || (await square.artifact.read((facts) => preview(facts, owner, index)?.payload, signal)).value !== prepared.payload)
                         return undefined;
                     return { sending: sendNativeText(target, prepared.payload, { inputId: row.nativeDelivery.inputId, delivery: 'steer',
                             timeoutMs: Math.max(1, deadline - Date.now()), signal }) };
@@ -82,7 +82,7 @@ export async function observeOpenCodeContext(sessionId, messages, env, signal) {
                 continue;
             const square = await openSquare(row.location, { hostLedger: ledger, env, signal });
             try {
-                const prepared = preview((await square.artifact.read(signal)).state, owner, index);
+                const { value: prepared } = await square.artifact.read((facts) => preview(facts, owner, index), signal);
                 if (!prepared || prepared.payload !== row.nativeDelivery.payload)
                     continue;
                 const prior = await projectPresentationEvidence({ hostLedger: ledger, location: row.location, participant: row.participant, sessionId, activity: row.activity });
@@ -90,7 +90,7 @@ export async function observeOpenCodeContext(sessionId, messages, env, signal) {
                     continue;
                 await presentPending({ artifact: square.artifact, hostLedger: ledger, location: row.location, participant: row.participant, session: sessionId,
                     activity: row.activity, sink: { present() { } }, markSeen: !prepared.clipped, signal,
-                    current: (state) => !signal.aborted && preview(state, owner, index)?.payload === row.nativeDelivery.payload });
+                    current: (facts) => !signal.aborted && preview(facts, owner, index)?.payload === row.nativeDelivery.payload });
             }
             finally {
                 await closeOpenSquare(square);

package/dist/plugins/opencode/index.js

@@ -1,9 +1,9 @@
 import { automaticSessionStart, operationEnv } from '../../automatic-session.js';
 import { hostLedgerForEnv } from '../../registry.js';
 import { canonicalPath } from '../../canonical-path.js';
-import { openSquare } from '../../square-file-adapter.js';
+import { openSquare } from '../../open-square.js';
 import { closeOpenSquare } from '../../open-square.js';
-import { Square } from '../../square-wiring.js';
+import { Square } from '../../square-application.js';
 import { connectNative } from '../../packages/agent-delivery/src/opencode-native.js';
 import { observeOpenCodeContext, publishOpenCodeRoutes, receiveOpenCodePending } from './delivery.js';
 /** Actual OpenCode 2.0.20 server plugin. Harness identity belongs to ctx, never process.env. */
@@ -81,7 +81,7 @@ export default {
                 for (const owner of (await ledger.listPresence({ session: sessionId })).filter((binding) => binding.channel === 'opencode')) {
                     const square = await openSquare(owner.location, { hostLedger: ledger, env, signal: lifetime.signal });
                     try {
-                        await ledger.suppressPresence(owner, (await square.artifact.read(lifetime.signal)).state.runtime.nextActIndex - 1);
+                        await ledger.suppressPresence(owner, (await square.artifact.read((facts) => facts.header().nextActIndex - 1, lifetime.signal)).value);
                     }
                     finally {
                         await closeOpenSquare(square);

package/dist/ports.d.ts

@@ -1,16 +1,161 @@
-import type { InboxNotification, SquareState, StoredAct, WakeRoute, WatchLease } from './model.js';
+import type { Act, HardCap, InboxNotification, StoredAct, WakeRoute, WakeRouteKind, WatchLease } from './model.js';
 export type { ClaimResult, EvidenceClaim, EvidenceRelease, EvidenceGc, EvidenceLookup, EvidenceRecord, HostLedgerPort, PresenceKey, PresenceLookup, PresenceRecord, PresenceClaimResult, PresenceChannel, PresenceResult, } from './host-ledger.js';
 import type { HostLedgerPort } from './host-ledger.js';
-/** Atomic artifact access. Never exposes framing, compression, locks, or storage schema. */
+export type ActivityIndex = number;
+export interface SquareHeader {
+    readonly revision: number;
+    readonly nextActIndex: number;
+    readonly lastActIndex: number;
+    readonly hardCap: HardCap;
+    readonly throttlePerMinute?: number;
+    readonly preamble: readonly string[];
+    readonly warmup: readonly string[];
+}
+export interface ParticipantFact {
+    readonly name: string;
+    readonly firstIndex: number;
+    readonly joined: boolean;
+    readonly done: boolean;
+    readonly sayCount: number;
+    readonly lastActiveAt?: number;
+    readonly lastJoinIndex?: number;
+}
+export interface AttentionFact {
+    readonly listener: string;
+    readonly target: string;
+    readonly kind: 'listen' | 'ignore';
+    readonly sinceIndex: number;
+}
+export interface ActivityHead {
+    readonly index: ActivityIndex;
+    readonly at: number;
+    readonly kind: StoredAct['kind'];
+    readonly actor?: string;
+    readonly reach?: 'bell';
+    readonly reply?: ActivityIndex;
+}
+export interface ActivityFilter {
+    readonly afterIndex?: number;
+    readonly beforeIndex?: number;
+    readonly throughIndex?: number;
+    readonly indexes?: readonly ActivityIndex[];
+    readonly kinds?: readonly StoredAct['kind'][];
+    readonly actors?: readonly string[];
+    readonly actorMatch?: 'identity' | 'exact';
+    readonly actorRequired?: true;
+    readonly afterAt?: number;
+}
+export interface IndexPage {
+    readonly edge: 'oldest' | 'newest';
+    readonly limit: number;
+}
+export interface FactPage<T> {
+    readonly items: readonly T[];
+    readonly hasMore: boolean;
+}
+export interface DirectedFilter {
+    readonly afterIndex?: number;
+    readonly beforeIndex?: number;
+    readonly throughIndex?: number;
+    readonly unseenOnly?: true;
+    readonly senders?: readonly string[];
+    readonly attentionOnly?: true;
+}
+export interface DirectedHead {
+    readonly index: ActivityIndex;
+    readonly at: number;
+    readonly actor: string;
+    readonly recipient: string;
+    readonly route: 'mention' | 'reply' | 'attention' | 'bell';
+}
+export interface LandedRecipient {
+    readonly recipient: string;
+    readonly route: DirectedHead['route'];
+}
+export interface ReceiptFacts {
+    readonly latestAt?: number;
+    readonly latestActorActivityIndex?: number;
+}
+export interface ReceiptAssignment {
+    readonly owner: string;
+    readonly index: ActivityIndex;
+}
+export type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+export interface RouteFact {
+    readonly location: string;
+    readonly participant: string;
+    readonly sessionId: string;
+    readonly channel: string;
+    readonly kind: WakeRouteKind;
+    readonly address: Readonly<Record<string, string>>;
+    readonly updatedAt: number;
+    readonly epoch?: JsonValue;
+    readonly extra: Readonly<Record<string, JsonValue>>;
+}
+/** Domain facts exist only during a synchronous artifact callback. Values are detached. */
+export interface SquareRead {
+    header(): SquareHeader;
+    participant(requestedName: string): ParticipantFact | undefined;
+    roster(): readonly ParticipantFact[];
+    attention(listener: string): readonly AttentionFact[];
+    incomingAttention(sender: string): readonly AttentionFact[];
+    hold(): {
+        readonly active: boolean;
+        readonly at?: number;
+        readonly reason?: string;
+        readonly actor?: string;
+    };
+    activity(index: ActivityIndex): StoredAct | undefined;
+    activityHeads(filter: ActivityFilter, page: IndexPage): FactPage<ActivityHead>;
+    activities(indexes: readonly ActivityIndex[]): readonly StoredAct[];
+    activityCount(filter: ActivityFilter): number;
+    contextIndexes(centers: readonly ActivityIndex[], before: number, after: number): readonly ActivityIndex[];
+    sayOrdinals(indexes: readonly ActivityIndex[]): Readonly<Record<number, number>>;
+    recentSayTimes(afterExclusive: number, takeLatest: number, actor?: string, bellOnly?: true): readonly number[];
+    audience(index: ActivityIndex): readonly LandedRecipient[];
+    directed(recipient: string, filter: DirectedFilter, page: IndexPage): FactPage<DirectedHead>;
+    directedAt(recipient: string, index: ActivityIndex): DirectedHead | undefined;
+    directedCount(recipient: string, filter: DirectedFilter): number;
+    pendingAudience(afterExclusive: number, throughInclusive: number, activityLimit: number): {
+        readonly groups: readonly {
+            readonly index: ActivityIndex;
+            readonly at: number;
+            readonly actor: string;
+            readonly recipients: readonly LandedRecipient[];
+        }[];
+        readonly hasMore: boolean;
+    };
+    receipt(requestedName: string, index: ActivityIndex): {
+        readonly at: number;
+    } | undefined;
+    receiptFacts(requestedName: string, afterIndex: number): ReceiptFacts;
+    receiptAssignments(): readonly ReceiptAssignment[];
+    lease(requestedName: string): WatchLease | undefined;
+    routes(): readonly RouteFact[];
+}
+export interface SquareWrite extends SquareRead {
+    land(activity: Act & {
+        readonly at: number;
+    }): StoredAct;
+    markSeen(requestedName: string, indexes: readonly ActivityIndex[], at: number): number;
+    putLease(requestedName: string, lease: WatchLease): boolean;
+    removeLease(requestedName: string, expectedLeaseId: string): boolean;
+    replaceRoutes(routes: readonly RouteFact[]): boolean;
+}
+export interface SquareReadResult<R> {
+    readonly value: R;
+    readonly version: number;
+}
+export interface SquareCommitResult<R> extends SquareReadResult<R> {
+    readonly changed: boolean;
+}
+/** Atomic artifact access; no framing, SQL or lazy transaction capability escapes. */
 export interface SquareArtifactPort {
-    read(signal?: AbortSignal): Promise<{
-        state: SquareState;
-        version: number;
-    }>;
-    transact<R>(fn: (state: SquareState, version: number) => {
-        state?: SquareState;
-        result: R;
-    }, signal?: AbortSignal): Promise<R>;
+    read<R>(select: (facts: SquareRead) => R, signal?: AbortSignal): Promise<SquareReadResult<R>>;
+    transact<R>(change: (facts: SquareWrite) => R, signal?: AbortSignal): Promise<SquareCommitResult<R>>;
+    revision(signal?: AbortSignal): Promise<number>;
     changed(sinceVersion: number, timeoutMs: number, signal?: AbortSignal): Promise<boolean>;
     close(): Promise<void>;
 }
@@ -121,5 +266,5 @@ export interface PresentPendingInput {
     /** Boundary previews that were clipped remain pending for a later full presentation. */
     readonly markSeen?: boolean;
     /** Receiver-specific fences checked inside the artifact observation transaction. */
-    readonly current?: (state: SquareState) => boolean;
+    readonly current?: (facts: SquareRead) => boolean;
 }

package/dist/presentation-operations.d.ts

@@ -1,3 +1,3 @@
 import type { PresentationResult, PresentPendingInput } from './ports.js';
-/** Present one pending activity; artifact seen remains the authoritative receipt. */
+/** Presentation evidence is not a receipt; only the fenced receipt transaction marks seen. */
 export declare function presentPending(input: PresentPendingInput): Promise<PresentationResult>;

package/dist/presentation-operations.js

@@ -1,65 +1,56 @@
 import { formatActivityId, parseActivityId } from './square-core.js';
-import { deriveDeliveryModel } from './delivery.js';
-import { recordObservation } from './runtime.js';
-/** Present one pending activity; artifact seen remains the authoritative receipt. */
+import { pendingHead, sameJoin } from './delivery.js';
+/** Presentation evidence is not a receipt; only the fenced receipt transaction marks seen. */
 export async function presentPending(input) {
     const index = typeof input.activity === 'number' ? input.activity : parseActivityId(input.activity);
     if (index === undefined)
         return { presented: false };
-    let before;
-    try {
-        before = await input.artifact.read(input.signal);
-    }
-    catch {
-        return { presented: false };
-    }
-    const delivery = deriveDeliveryModel(before.state);
-    const item = before.state.acts.find((activity) => activity.index === index);
-    if (input.current?.(before.state) === false || item === undefined || delivery.isSeen(input.participant, index) || !delivery.pendingFor(input.participant).some((notification) => notification.item.index === index))
+    const before = await input.artifact.read((facts) => {
+        if (input.current?.(facts) === false || !pendingHead(facts, input.participant, index))
+            return undefined;
+        return { item: facts.activity(index), participant: facts.participant(input.participant) };
+    }, input.signal).catch(() => undefined);
+    if (before?.value === undefined)
         return { presented: false };
+    const { item, participant } = before.value;
+    const current = (facts) => sameJoin(facts, participant) && input.current?.(facts) !== false
+        && pendingHead(facts, participant.name, index) !== undefined;
+    const coordinate = { location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation' };
     let claimToken;
+    const release = async () => {
+        if (claimToken !== undefined)
+            await input.hostLedger.releaseEvidence({ ...coordinate, claimToken });
+    };
     if (input.hostLedger !== undefined && input.session !== undefined) {
-        const claim = await input.hostLedger.claimEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', leaseMs: input.timeoutMs ?? 5000 });
+        const claim = await input.hostLedger.claimEvidence({ ...coordinate, leaseMs: input.timeoutMs ?? 5000 });
         if (claim.status !== 'acquired')
             return { presented: false };
         claimToken = claim.claimToken;
-        let current;
-        try {
-            current = await input.artifact.read(input.signal);
-        }
-        catch {
-            await input.hostLedger.releaseEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', claimToken }).catch(() => undefined);
-            return { presented: false };
-        }
-        if (input.current?.(current.state) === false || deriveDeliveryModel(current.state).isSeen(input.participant, index)) {
-            await input.hostLedger.releaseEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', claimToken }).catch(() => undefined);
+        const fresh = await input.artifact.read(current, input.signal).catch(() => undefined);
+        if (!fresh?.value) {
+            await release().catch(() => undefined);
             return { presented: false };
         }
-        try {
-            await input.sink.present(item);
-        }
-        catch (error) {
-            await input.hostLedger.appendEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', outcome: 'failed', message: error instanceof Error ? error.message : String(error), claimToken });
-            throw error;
-        }
     }
-    else
+    try {
         await input.sink.present(item);
-    const committed = await input.artifact.transact((state) => {
-        const current = deriveDeliveryModel(state);
-        if (input.current?.(state) === false || current.isSeen(input.participant, index) || !current.pendingFor(input.participant).some((notification) => notification.item.index === index))
-            return { result: false };
-        if (input.markSeen === false)
-            return { result: true };
-        const changed = recordObservation(state, input.participant, index, 'seen', input.now ?? Date.now());
-        return changed ? { state, result: true } : { result: false };
+    }
+    catch (error) {
+        if (claimToken !== undefined)
+            await input.hostLedger.appendEvidence({ ...coordinate, outcome: 'failed', message: error instanceof Error ? error.message : String(error), claimToken });
+        throw error;
+    }
+    const { value: committed } = await input.artifact.transact((facts) => {
+        if (!current(facts))
+            return false;
+        return input.markSeen === false || facts.markSeen(participant.name, [index], input.now ?? Date.now()) > 0;
     }, input.signal);
     if (!committed) {
-        if (input.hostLedger !== undefined && input.session !== undefined && claimToken !== undefined)
-            await input.hostLedger.releaseEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', claimToken });
+        await release();
         return { presented: false };
     }
-    if (input.hostLedger !== undefined && input.session !== undefined && claimToken !== undefined)
-        await input.hostLedger.appendEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', outcome: input.markSeen === false ? 'clipped' : 'presented', ...(input.markSeen === false ? { message: 'presentation clipped' } : {}), claimToken });
+    if (claimToken !== undefined)
+        await input.hostLedger.appendEvidence({ ...coordinate, outcome: input.markSeen === false ? 'clipped' : 'presented',
+            ...(input.markSeen === false ? { message: 'presentation clipped' } : {}), claimToken });
     return { presented: true, activity: item };
 }

package/dist/presentation.d.ts

@@ -1,7 +1,7 @@
-import { type StoredAct, type SquareState, type PublicAct, type RoomChangeAct } from './model.js';
+import { type StoredAct, type RoomChangeAct } from './model.js';
 export { participantIdentity } from './participant-identity.js';
 import { type Perception } from './square-core.js';
-import type { UnreadActivitySummary, ParticipantStatus } from './decisions.js';
+import type { Activity, UnreadActivitySummary, ParticipantSummary } from './square-facade.js';
 export type WatchStatus = 'stale' | 'empty-now' | 'quorum' | 'capped';
 interface HeaderOptions {
     participantCount?: number;
@@ -23,7 +23,7 @@ interface ActivityLimitOptions extends ParticipantOutputOptions {
 interface ActivityBlockedOptions extends ParticipantOutputOptions {
     retryCommand: string;
     forceCommand: string;
-    activitySummaries: UnreadActivitySummary[];
+    activitySummaries: readonly UnreadActivitySummary[];
     draftPath?: string;
 }
 interface ExpressWaitingOptions {
@@ -44,7 +44,7 @@ interface WatchStatusOptions extends ParticipantOutputOptions {
     status: WatchStatus;
     idleMs?: number;
     presence?: {
-        participants: ParticipantStatus[];
+        participants: readonly ParticipantSummary[];
         now: number;
     };
     showCatchHint?: boolean;
@@ -58,6 +58,7 @@ export declare function formatRefusal(squarePath: string, bodyLines: string[], o
     participantCount?: number;
     held?: boolean;
 }): string;
+export declare function refusalText(error: unknown): string;
 export declare function quoteShell(value: string): string;
 export declare function commandPrefix(squarePath: string): string;
 export declare function participantCommandPrefix(squarePath: string, name: string): string;
@@ -66,44 +67,42 @@ export declare function joinRecoveryCommand(squarePath: string, name: string): s
 /** Taking a name is an explicit recovery choice, never an automatic retry. */
 export declare function takeoverRecoveryLines(squarePath: string, name: string): string[];
 export declare function participantsRecoveryCommand(squarePath: string): string;
-export declare function renderPresenceLines(participants: ParticipantStatus[], now: number, limit?: number): string[];
+export declare function renderPresenceLines(recent: readonly ParticipantSummary[], 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 truncateExternalDiagnostic(diagnostic: string): string;
-export declare function renderRoomChangeText(event: RoomChangeAct): string;
+export declare function renderRoomChangeText(event: RoomChangeAct | Activity): string;
 interface RenderedEvent {
     text: string;
     /** The rendered body was cut short by `preview`. */
     bodyClipped: boolean;
 }
-export declare function renderEventCli(event: StoredAct, opts?: {
+export declare function renderEventCli(event: StoredAct | Activity, opts?: {
     now?: number;
     preview?: number;
     actNumber?: number;
     mention?: string;
 }): string;
-export declare function renderAmbientEventFacts(event: StoredAct, viewer: string, opts?: {
+export declare function renderAmbientEventFacts(event: StoredAct | Activity, viewer: string, opts?: {
     now?: number;
     preview?: number;
     presencePreview?: number;
     actNumber?: number;
     mention?: string;
-    squareState?: SquareState;
     perception?: Perception;
 }): RenderedEvent;
-export declare function renderAmbientEvent(event: StoredAct, viewer: string, opts?: {
+export declare function renderAmbientEvent(event: StoredAct | Activity, viewer: string, opts?: {
     now?: number;
     preview?: number;
     presencePreview?: number;
     actNumber?: number;
     mention?: string;
-    squareState?: SquareState;
     perception?: Perception;
 }): string;
-export declare function renderPendingFeed(history: StoredAct[], publicItems: PublicAct[], viewer: string | undefined, squareState: SquareState): string;
+export declare function renderPendingFeed(publicItems: readonly StoredAct[], sayNumbers: Readonly<Record<number, number>>, perceptions: Readonly<Record<number, Perception>>, viewer: string): string;
 export declare function renderActivityBlocked(opts: ActivityBlockedOptions): string;
 /** An indeterminate or already-committed send only points to inspection, never resend. */
 export declare function renderActivityUncertain(opts: ParticipantOutputOptions & {
@@ -114,7 +113,7 @@ export declare function renderActivityUncertain(opts: ParticipantOutputOptions &
 export declare function renderExpressWaiting(opts: ExpressWaitingOptions): string;
 export declare function renderExpressNoWait(opts: ExpressNoWaitOptions): string;
 export declare function renderPresenceAnchor(names: readonly string[]): string;
-export declare function renderGrepActivitiesView(visible: StoredAct[], totalMatches: number, noTruncate: boolean | undefined, squarePath: string, pattern: string, fixed?: boolean, perception?: (act: StoredAct) => Perception): string;
+export declare function renderGrepActivitiesView(visible: readonly StoredAct[], totalMatches: number, noTruncate: boolean | undefined, squarePath: string, pattern: string, fixed?: boolean, perception?: (act: StoredAct) => Perception): string;
 export declare function renderActivityLimit(opts: ActivityLimitOptions): string;
 export declare function renderWatchAlreadyActive(opts: ParticipantOutputOptions): string;
 export declare function renderWatchForceTakeover(_opts: ParticipantOutputOptions): string;
@@ -123,9 +122,3 @@ export declare function renderWatchReplaced(_opts: ParticipantOutputOptions): st
 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[], opts: {
-    mention?: string;
-    viewer: string;
-    squareState?: SquareState;
-    perceptions?: ReadonlyMap<number, Perception>;
-}): string;