@astrosheep/square 0.3.93 → 0.3.94

package/dist/presentation-operations.js

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { formatActivityId, parseActivityId } from './square-core.js';
-import { isSquareError, sameBody } from './model.js';
+import { isSquareError } from './model.js';
 import { pendingHead, sameJoin } from './delivery.js';
 import { deliveryDeferralExpiry } from './delivery-deferral.js';
 import { asSeatRef } from './seats.js';
@@ -12,8 +12,8 @@ export async function preparePendingPresentation(input) {
     const initial = await input.artifact.read((facts) => {
         const participant = facts.participant(input.participant);
         const seat = facts.seat(input.participant);
-        if (!participant?.joined || seat === undefined || input.generation !== undefined && input.generation !== seat.generation
-            || input.seat !== undefined && (input.seat.generation !== seat.generation || !sameBody(input.seat.body, seat.body))
+        if (!participant?.joined || seat === undefined || seat.attachment !== 'attached' || input.generation !== undefined && input.generation !== seat.generation
+            || input.seat !== undefined && (input.seat.generation !== seat.generation || input.seat.owner !== seat.owner)
             || input.current?.(facts) === false || !pendingHead(facts, participant.name, index)
             || deliveryDeferralExpiry(facts, seat, index, input.now ?? Date.now()) !== undefined)
             return undefined;
@@ -26,7 +26,7 @@ export async function preparePendingPresentation(input) {
     const ref = asSeatRef(seat);
     const owns = (facts) => {
         const current = facts.seat(seat.participant);
-        return current !== undefined && sameBody(current.body, seat.body) && current.generation === seat.generation
+        return current !== undefined && current.attachment === 'attached' && current.owner === seat.owner && current.generation === seat.generation
             && sameJoin(facts, participant);
     };
     const claimToken = randomUUID();

package/dist/presentation.d.ts

@@ -2,7 +2,7 @@ import { type StoredAct, type RoomChangeAct } from './model.js';
 export { participantIdentity } from './participant-identity.js';
 import { type Perception } from './square-core.js';
 import type { Activity, UnreadActivitySummary, ParticipantSummary } from './square-facade.js';
-export type WatchStatus = 'stale' | 'empty-now' | 'quorum' | 'capped';
+export type WatchStatus = 'idle' | 'drained' | 'quorum' | 'capped';
 interface HeaderOptions {
     participantCount?: number;
     held?: boolean;
@@ -10,6 +10,7 @@ interface HeaderOptions {
     plain?: boolean;
 }
 interface ParticipantOutputOptions {
+    owner?: string;
     squarePath: string;
     name: string;
     participantCount?: number;
@@ -60,11 +61,11 @@ export declare function formatRefusal(squarePath: string, bodyLines: string[], o
 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;
+export declare function participantCommandPrefix(squarePath: string, name: string, owner?: string): string;
 /** Blocked actions end with a full copy-pasteable recovery command. */
-export declare function joinRecoveryCommand(squarePath: string, name: string): string;
+export declare function joinRecoveryCommand(squarePath: string, name: string, owner?: string): string;
 /** Taking a name is an explicit recovery choice, never an automatic retry. */
-export declare function takeoverRecoveryLines(squarePath: string, name: string): string[];
+export declare function takeoverRecoveryLines(squarePath: string, name: string, owner?: string): string[];
 export declare function participantsRecoveryCommand(squarePath: string): string;
 export declare function renderPresenceLines(recent: readonly ParticipantSummary[], now: number, limit?: number): string[];
 export declare function truncateChars(body: string, maxChars: number): {
@@ -81,14 +82,12 @@ interface RenderedEvent {
 export declare function renderEventCli(event: StoredAct | Activity, opts?: {
     now?: number;
     preview?: number;
-    actNumber?: number;
     mention?: string;
 }): string;
 export declare function renderAmbientEventFacts(event: StoredAct | Activity, viewer: string, opts?: {
     now?: number;
     preview?: number;
     presencePreview?: number;
-    actNumber?: number;
     mention?: string;
     perception?: Perception;
 }): RenderedEvent;
@@ -96,11 +95,9 @@ export declare function renderAmbientEvent(event: StoredAct | Activity, viewer:
     now?: number;
     preview?: number;
     presencePreview?: number;
-    actNumber?: number;
     mention?: string;
     perception?: Perception;
 }): 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 & {

package/dist/presentation.js

@@ -50,18 +50,18 @@ export function quoteShell(value) {
 export function commandPrefix(squarePath) {
     return `square --location ${quoteShell(squarePath)}`;
 }
-export function participantCommandPrefix(squarePath, name) {
-    return `square --location ${quoteShell(/^[A-Za-z][A-Za-z0-9+.-]*:/.test(squarePath) ? squarePath : path.resolve(squarePath))} --as ${quoteShell(name)}`;
+export function participantCommandPrefix(squarePath, name, owner) {
+    return `square --location ${quoteShell(/^[A-Za-z][A-Za-z0-9+.-]*:/.test(squarePath) ? squarePath : path.resolve(squarePath))} --as ${quoteShell(name)}${owner === undefined ? '' : ` --owner ${quoteShell(owner)}`}`;
 }
 /** Blocked actions end with a full copy-pasteable recovery command. */
-export function joinRecoveryCommand(squarePath, name) {
-    return `${participantCommandPrefix(squarePath, name)} join`;
+export function joinRecoveryCommand(squarePath, name, owner) {
+    return `${participantCommandPrefix(squarePath, name, owner)} join`;
 }
 /** Taking a name is an explicit recovery choice, never an automatic retry. */
-export function takeoverRecoveryLines(squarePath, name) {
+export function takeoverRecoveryLines(squarePath, name, owner) {
     return [
         'If this is your name to reclaim, --kick banishes the one standing here so you can step in:',
-        `${participantCommandPrefix(squarePath, name)} join --kick`,
+        `${participantCommandPrefix(squarePath, name, owner)} join --kick`,
     ];
 }
 export function participantsRecoveryCommand(squarePath) {
@@ -79,13 +79,14 @@ export function renderPresenceLines(recent, now, limit = 5) {
     if (shown.length === 0)
         return [style('dim', '  ○ nobody nearby')];
     const lines = shown.map((p) => {
-        const glyph = p.state === 'done' ? '○' : p.presence === 'watching' ? '◎' : p.lastActiveAt !== undefined ? '●' : '○';
-        const text = p.state === 'done'
+        const glyph = p.presence === 'done' || p.presence === 'away' ? '○' : p.presence === 'watching' ? '◎' : p.lastActiveAt !== undefined ? '●' : '○';
+        const text = p.presence === 'done'
             ? (p.lastActiveAt === undefined ? 'stepped out of the square' : `stepped out of the square · ${formatRelativeTime(p.lastActiveAt, now)}`)
-            : p.presence === 'watching'
-                ? (p.lastActiveAt === undefined ? 'is nearby · catching' : `is nearby · catching · ${formatRelativeTime(p.lastActiveAt, now)}`)
-                : p.lastActiveAt === undefined ? 'is nearby · quiet'
-                    : p.activityCount > 0 ? `is nearby · ${formatRelativeTime(p.lastActiveAt, now)}` : `is nearby · quiet · ${formatRelativeTime(p.lastActiveAt, now)}`;
+            : p.presence === 'away' ? 'is away'
+                : p.presence === 'watching'
+                    ? (p.lastActiveAt === undefined ? 'is nearby · catching' : `is nearby · catching · ${formatRelativeTime(p.lastActiveAt, now)}`)
+                    : p.lastActiveAt === undefined ? 'is nearby · quiet'
+                        : p.activityCount > 0 ? `is nearby · ${formatRelativeTime(p.lastActiveAt, now)}` : `is nearby · quiet · ${formatRelativeTime(p.lastActiveAt, now)}`;
         return `  ${glyph === '○' ? style('dim', glyph) : glyph} ${participantIdentity(p.name)}${style('dim', ` ${text}`)}`;
     });
     const remaining = recent.length - shown.length;
@@ -229,37 +230,26 @@ function draftSavedLines(draftPath) {
 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;
+function renderUnreadSummary(activitySummaries) {
+    const visibleSummaries = activitySummaries.slice(0, MAX_IDENTITY_SET_SIZE);
+    const remainingSummaries = activitySummaries.length - visibleSummaries.length;
     return [
-        ...visibleSummaries.flatMap((item) => [
-            ...item.previews.slice(-1).map((preview) => {
-                const rendered = renderAmbientEvent(preview.act, opts.viewer, { actNumber: preview.number, perception: preview.perception });
-                if (rendered === '')
-                    return style('dim', `  · ${participantIdentity(item.name)} spoke — ${formatAge(item.latestActivityAgeMs)} ago`);
-                if (preview.perception === 'presence') {
-                    return style('dim', `  · ${participantIdentity(item.name)} spoke — ${formatAge(item.latestActivityAgeMs)} ago · ${rendered.replace(/\n/g, ' ')}`);
-                }
-                const compact = (preview.act.body ?? '').replace(/\s+/g, ' ').trim();
-                const bodyPreview = compact === ''
-                    ? { text: preview.act.metadata === undefined ? '(empty)' : '(structured activity)', remaining: 0 }
-                    : truncateChars(compact, UNREAD_PREVIEW_CHARS);
-                const bodyText = bodyPreview.remaining === 0 ? bodyPreview.text : `${bodyPreview.text}${style('dim', `… (+${bodyPreview.remaining} chars)`)}`;
-                return style('dim', `  · ${participantIdentity(item.name)} spoke — ${formatAge(item.latestActivityAgeMs)} ago · "${bodyText}"`);
-            }),
-        ]),
+        ...visibleSummaries.map((item) => {
+            const compact = (item.preview.body ?? '').replace(/\s+/g, ' ').trim();
+            const bodyPreview = compact === ''
+                ? { text: item.preview.metadata === undefined ? '(empty)' : '(structured activity)', remaining: 0 }
+                : truncateChars(compact, UNREAD_PREVIEW_CHARS);
+            const bodyText = bodyPreview.remaining === 0 ? bodyPreview.text : `${bodyPreview.text}${style('dim', `… (+${bodyPreview.remaining} chars)`)}`;
+            return style('dim', `  · ${participantIdentity(item.name)} spoke — ${formatAge(item.latestActivityAgeMs)} ago · "${bodyText}"`);
+        }),
         ...(remainingSummaries === 0 ? [] : [style('dim', `  · ${remainingSummaries} more participants have unread activity`)]),
     ];
 }
-export function renderPendingFeed(publicItems, sayNumbers, perceptions, viewer) {
-    return publicItems.map((act) => renderAmbientEvent(act, viewer, { actNumber: sayNumbers[act.index], perception: perceptions[act.index] })).filter(Boolean).join('\n\n');
-}
 export function renderActivityBlocked(opts) {
-    const readNowCommand = `${participantCommandPrefix(opts.squarePath, opts.name)} catch`;
+    const readNowCommand = `${participantCommandPrefix(opts.squarePath, opts.name, opts.owner)} catch`;
     return withPathOutput(opts.squarePath, [
         `${style('blocked', '✕')} your activity hasn't landed — someone spoke while you were away`,
-        ...renderUnreadSummary({ activitySummaries: opts.activitySummaries, viewer: opts.name }),
+        ...renderUnreadSummary(opts.activitySummaries),
         ...draftSavedLines(opts.draftPath),
         `${readNowCommand}`,
         '  · take it in, then retry:',
@@ -373,7 +363,7 @@ export function renderGrepActivitiesView(visible, totalMatches, noTruncate, squa
 export function renderActivityLimit(opts) {
     // The cap wording lives inside the count: the speaker is simply spent.
     const spoken = opts.count !== undefined && opts.hardCap !== undefined ? ` — ${opts.count}/${opts.hardCap} spoken` : '';
-    const doneCommand = `${participantCommandPrefix(opts.squarePath, opts.name)} done`;
+    const doneCommand = `${participantCommandPrefix(opts.squarePath, opts.name, opts.owner)} done`;
     return withPathOutput(opts.squarePath, [
         `${style('blocked', '✕')} you’ve reached your speaking cap${spoken}`,
         ...draftSavedLines(opts.draftPath),
@@ -386,7 +376,7 @@ export function renderWatchAlreadyActive(opts) {
         `${style('blocked', '✕')} you are already catching`,
         `  · an active catch is already running for ${participantIdentity(opts.name)}`,
         '  · --replace lets a new catch take over',
-        `${participantCommandPrefix(opts.squarePath, opts.name)} catch --idle 30m --replace`,
+        `${participantCommandPrefix(opts.squarePath, opts.name, opts.owner)} catch --idle 30m --replace`,
     ].join('\n');
 }
 export function renderWatchForceTakeover(_opts) {
@@ -406,9 +396,9 @@ export function renderWatchStatus(opts) {
         ? ['', 'around the square', ...renderPresenceLines(others, opts.presence.now)]
         : [];
     switch (opts.status) {
-        case 'stale':
-        case 'empty-now': {
-            const prefix = participantCommandPrefix(opts.squarePath, opts.name);
+        case 'idle':
+        case 'drained': {
+            const prefix = participantCommandPrefix(opts.squarePath, opts.name, opts.owner);
             // Quiet graduates with the idle length; an empty catch has no idle budget to report.
             const idleMs = opts.idleMs;
             const quiet = idleMs !== undefined && idleMs >= 60 * 60 * 1000
@@ -425,12 +415,12 @@ export function renderWatchStatus(opts) {
             ].join('\n');
         }
         case 'quorum':
-            return [`${style('release', '✓')} everyone else has left — the square is yours alone`, `${participantCommandPrefix(opts.squarePath, opts.name)} done`].join('\n');
+            return [`${style('release', '✓')} everyone else has left — the square is yours alone`, `${participantCommandPrefix(opts.squarePath, opts.name, opts.owner)} done`].join('\n');
         case 'capped': {
             const spoken = opts.hardCap === undefined || opts.hardCap === null
                 ? ''
                 : ` — ${opts.ownActivityCount ?? 0}/${opts.hardCap} spoken`;
-            return [`${style('blocked', '✕')} you’ve reached your speaking cap${spoken}`, `${participantCommandPrefix(opts.squarePath, opts.name)} done`].join('\n');
+            return [`${style('blocked', '✕')} you’ve reached your speaking cap${spoken}`, `${participantCommandPrefix(opts.squarePath, opts.name, opts.owner)} done`].join('\n');
         }
     }
 }

package/dist/runtime.d.ts

@@ -1,18 +1,12 @@
-import { type ActivityId } from './square-core.js';
-import { type StoredAct, type WatchLease } from './model.js';
+import { type WatchLease } from './model.js';
 import type { ParticipantCounts, ParticipantFact, SquareRead } from './ports.js';
 export declare const WATCH_HEARTBEAT_MS: number;
-export declare const SLEEP_MS: number;
-export declare const STALE_MS: number;
 export declare const WATCH_STALE_MS: number;
 export declare const THROTTLE_WINDOW_MS: number;
 export declare const UNREAD_BLOCK_GRACE_MS: number;
 export declare const HELD_WAIT_BUDGET_MS: number;
 export declare const FACT_PAGE_SIZE = 100;
-export declare function nowMs(): number;
-export declare function rosterNames(facts: SquareRead): string[];
 export declare function inSquareCount(facts: SquareRead): number;
-export declare function actId(actOrIndex: StoredAct | number): ActivityId;
 export declare function terminalStatusFor(current: ParticipantFact | undefined, hardCap: number | null, counts: ParticipantCounts): 'capped' | 'quorum' | undefined;
 export declare function watchTerminalStatus(facts: SquareRead, name: string): 'capped' | 'quorum' | undefined;
 /** A continuous prefix stops at the first unseen historical audience edge after join. */

package/dist/runtime.js

@@ -1,4 +1,3 @@
-import { formatActivityId } from './square-core.js';
 import { SquareError } from './model.js';
 function parseIntegerEnv(name, fallback) {
     const raw = process.env[name];
@@ -10,25 +9,12 @@ function parseIntegerEnv(name, fallback) {
     return value;
 }
 export const WATCH_HEARTBEAT_MS = parseIntegerEnv('SQUARE_WATCH_HEARTBEAT_MS', 60000);
-export const SLEEP_MS = parseIntegerEnv('SQUARE_WATCH_POLL_MS', 10000);
-export const STALE_MS = parseIntegerEnv('SQUARE_WATCH_QUIET_MS', 300000);
 export const WATCH_STALE_MS = parseIntegerEnv('SQUARE_WATCH_STALE_MS', 180000);
 export const THROTTLE_WINDOW_MS = parseIntegerEnv('SQUARE_THROTTLE_WINDOW_MS', 60000);
 export const UNREAD_BLOCK_GRACE_MS = parseIntegerEnv('SQUARE_UNREAD_BLOCK_GRACE_MS', 90000);
 export const HELD_WAIT_BUDGET_MS = parseIntegerEnv('SQUARE_HELD_WAIT_BUDGET_MS', 10 * 60 * 1000);
 export const FACT_PAGE_SIZE = 100;
-export function nowMs() {
-    const override = process.env.SQUARE_NOW_MS;
-    if (override === undefined)
-        return Date.now();
-    const value = parseInt(override, 10);
-    if (!Number.isFinite(value))
-        throw new SquareError('invalid_args', 'Invalid SQUARE_NOW_MS: expected integer milliseconds.');
-    return value;
-}
-export function rosterNames(facts) { return facts.roster().map((participant) => participant.name); }
 export function inSquareCount(facts) { return facts.participantCounts().joined; }
-export function actId(actOrIndex) { return formatActivityId(typeof actOrIndex === 'number' ? actOrIndex : actOrIndex.index); }
 export function terminalStatusFor(current, hardCap, counts) {
     if (hardCap !== null && (current?.sayCount ?? 0) >= hardCap)
         return 'capped';

package/dist/seats.d.ts

@@ -1,7 +1,6 @@
-import { type Body, type Seat } from './model.js';
+import { type Owner, type Seat } from './model.js';
 import type { ArtifactWriteAuthority, SeatRef } from './ports.js';
-export declare function requireBody(body: Body | undefined): Body;
+export declare function requireOwner(owner: Owner | undefined): Owner;
 export declare function requireJoinName(name: string | undefined): string;
 export declare function asSeatRef(seat: Seat): SeatRef;
 export declare function participantAuthority(seat: Seat): ArtifactWriteAuthority;
-export declare function requireSeat(seat: Seat | undefined, body: Body | undefined, participant: string): Seat;

package/dist/seats.js

@@ -1,9 +1,9 @@
-import { SquareError, sameBody, sameName, validateBody, validateName } from './model.js';
-export function requireBody(body) {
-    if (body === undefined)
-        throw new SquareError('invalid_args', 'Participant writes require an explicit body: channel and session.');
-    validateBody(body);
-    return body;
+import { SquareError, validateOwner, validateName } from './model.js';
+export function requireOwner(owner) {
+    if (owner === undefined)
+        throw new SquareError('invalid_args', 'Participant writes require an explicit owner.');
+    validateOwner(owner);
+    return owner;
 }
 export function requireJoinName(name) {
     if (name === undefined)
@@ -12,16 +12,8 @@ export function requireJoinName(name) {
     return name;
 }
 export function asSeatRef(seat) {
-    const { wakeAddress: _wakeAddress, ...ref } = seat;
-    return ref;
+    return { participant: seat.participant, owner: seat.owner, generation: seat.generation };
 }
 export function participantAuthority(seat) {
     return { kind: 'participant', seat: asSeatRef(seat) };
 }
-export function requireSeat(seat, body, participant) {
-    if (seat === undefined || !sameName(seat.participant, participant))
-        throw new SquareError('already_joined', `${participant} needs a current participant handle; join first`);
-    if (!sameBody(seat.body, requireBody(body)))
-        throw new SquareError('already_joined', `${participant} is not held by this body`);
-    return seat;
-}

package/dist/session-lifecycle.d.ts

@@ -1,3 +1,7 @@
+import { type Owner } from './owner.js';
 import type { AutomaticProvider } from './participant-identity.js';
-/** Retire only seats held by this exact body, discovered through the rebuildable index. */
-export declare function endSessionMemberships(provider: AutomaticProvider, sessionId: string, env?: NodeJS.ProcessEnv): Promise<void>;
+import type { WakeAddress } from './model.js';
+/** Host shutdown suspends execution, not membership. Discovery never grants custody. */
+export declare function detachSessionSeats(provider: AutomaticProvider, sessionId: string, env?: NodeJS.ProcessEnv): Promise<void>;
+/** Restore only detached, standing seats of this exact owner before starting a receiver. */
+export declare function restoreSessionSeats(owner: Owner, env?: NodeJS.ProcessEnv, wakeAddress?: WakeAddress, signal?: AbortSignal): Promise<void>;

package/dist/session-lifecycle.js

@@ -1,19 +1,47 @@
 import { Square } from './square-api.js';
-import { projectSessionSeats } from './inbox.js';
-function bodyFor(provider, sessionId) {
-    return { channel: provider === 'claude' ? 'claude-code' : provider, session: sessionId };
+import { harnessOwner } from './owner.js';
+import { projectSessionCandidates, projectSessionSeats } from './inbox.js';
+function ownerFor(provider, sessionId) {
+    return harnessOwner({ channel: provider === 'claude' ? 'claude-code' : provider, session: sessionId });
 }
-/** Retire only seats held by this exact body, discovered through the rebuildable index. */
-export async function endSessionMemberships(provider, sessionId, env = process.env) {
-    const body = bodyFor(provider, sessionId);
-    const seats = await projectSessionSeats({ body, env });
-    for (const { location, seat } of seats) {
-        const square = await Square.at({ path: location, env, body, participant: seat.participant });
+/** Host shutdown suspends execution, not membership. Discovery never grants custody. */
+export async function detachSessionSeats(provider, sessionId, env = process.env) {
+    const owner = ownerFor(provider, sessionId);
+    for (const { location, seat } of await projectSessionSeats({ owner, env })) {
+        let square;
         try {
-            await square.endOwnedSession(seat.participant, sessionId, seat.generation, body);
+            square = await Square.at({ path: location, env });
+            await square.detach(seat.participant, { owner, generation: seat.generation });
         }
+        catch { /* One unavailable or replaced seat must not block cleanup of the others. */ }
         finally {
-            await square.close();
+            await square?.close();
+        }
+    }
+}
+/** Restore only detached, standing seats of this exact owner before starting a receiver. */
+export async function restoreSessionSeats(owner, env = process.env, wakeAddress, signal) {
+    const locations = new Set((await projectSessionCandidates({ owner, env })).map(candidate => candidate.location));
+    for (const location of locations) {
+        if (signal?.aborted)
+            return;
+        let square;
+        try {
+            square = await Square.at({ path: location, env }, { signal });
+            for (const seat of await square.seatsOf(owner)) {
+                if (signal?.aborted)
+                    return;
+                if (seat.attachment !== 'detached')
+                    continue;
+                try {
+                    await square.reattach(seat.name, { owner, wakeAddress }, { signal });
+                }
+                catch { /* A replacement or one failed seat does not block its peers. */ }
+            }
+        }
+        catch { /* An indexed location is only a candidate, not a promise of availability. */ }
+        finally {
+            await square?.close();
         }
     }
 }

package/dist/sqlite-square.d.ts

@@ -1,5 +1,5 @@
-import { type Body } from './model.js';
-import type { ActivityResult, HistoryQuery, HistoryResult, JoinOptions, JoinResult, ObservationOptions, OperationControl, Participant, SquareAtInput, SquareBuildInput, SquareLocation, StatusOptions, StatusResult, ParticipantsResult, RecoveryResult, DiscoveryOptions, InboxOptions, InboxResult, StreamOptions } from './square-facade.js';
+import { type Owner } from './model.js';
+import type { HistoryQuery, HistoryResult, JoinOptions, JoinResult, LifecycleResult, ObservationOptions, OperationControl, Participant, SquareAtInput, SquareBuildInput, SquareLocation, StatusOptions, StatusResult, ParticipantsResult, RecoveryResult, DiscoveryOptions, InboxOptions, InboxResult, StreamOptions, StreamRecord, Activity, PerceivedActivity } from './square-facade.js';
 export type * from './square-facade.js';
 export { createSquareResourceOwner } from './artifact.js';
 export { formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE } from './square-core.js';
@@ -13,41 +13,55 @@ export declare class SqliteSquare {
     readonly location: string;
     private readonly artifact;
     private readonly clock;
-    private readonly body?;
-    private readonly wakeAddress?;
     private readonly wakeTransport?;
     private readonly indexPath?;
-    private readonly automaticDelivery;
-    private readonly ownsArtifact;
-    private readonly defaultParticipant?;
+    private readonly closesArtifact;
+    private readonly deliveryLocation;
     private constructor();
-    static at(input: SquareAtInput, control?: OperationControl, automaticDelivery?: boolean): Promise<SqliteSquare>;
-    static build(input: SquareBuildInput, control?: OperationControl, automaticDelivery?: boolean): Promise<SqliteSquare>;
+    static at(input: SquareAtInput, control?: OperationControl): Promise<SqliteSquare>;
+    static build(input: SquareBuildInput, control?: OperationControl): Promise<SqliteSquare>;
     static inMemory(input: Omit<SquareBuildInput, 'path' | 'resources'>): SqliteSquare;
-    /** Discovery is best effort and never grants write authority. Finish it before returning. */
-    private publishIdentity;
+    /** Discovery is best effort and never grants write authority. */
+    private publishSeat;
     private observation;
     private contextObservation;
     private handle;
     private static readonly ParticipantHandle;
-    participant(requested?: string): Promise<Participant>;
-    join(requested?: string, options?: JoinOptions, control?: OperationControl): Promise<JoinResult>;
-    implicitJoin(name: string, control?: OperationControl): Promise<{
-        readonly state: 'joined' | 'active' | 'done';
-        readonly participant?: Participant;
-    }>;
+    participant(name: string, { owner }: {
+        readonly owner: Owner;
+    }): Promise<Participant>;
+    join(requested: string, options: JoinOptions, control?: OperationControl): Promise<JoinResult>;
+    /** Restore only a standing seat; a concurrent departure or takeover cannot be revived. */
+    reattach(name: string, { owner, wakeAddress }: Pick<JoinOptions, 'owner' | 'wakeAddress'>, control?: OperationControl): Promise<Participant | null>;
     snapshot(control?: OperationControl): Promise<import("./square-facade.js").SquareSnapshot>;
     history(query?: HistoryQuery, control?: OperationControl): Promise<HistoryResult>;
     status(options?: StatusOptions, control?: OperationControl): Promise<StatusResult>;
     participants(options?: ObservationOptions, control?: OperationControl): Promise<ParticipantsResult>;
     recovery(requested?: string, control?: OperationControl): Promise<RecoveryResult>;
-    stream(options: StreamOptions, control?: OperationControl): AsyncIterable<import("./square-facade.js").StreamRecord>;
-    recognize(): Promise<readonly Participant[]>;
+    stream(options: StreamOptions & {
+        readonly recipient: string;
+    }, control?: OperationControl): AsyncIterable<PerceivedActivity>;
+    stream(options: StreamOptions & {
+        readonly recipient?: undefined;
+    }, control?: OperationControl): AsyncIterable<Activity>;
+    stream(options: StreamOptions, control?: OperationControl): AsyncIterable<StreamRecord>;
+    seatsOf(owner: Owner): Promise<readonly import('./square-facade.js').HeldSeat[]>;
     close(): Promise<void>;
-    cancelDeliveries(name: string, expectedGeneration: import('./square-core.js').ActivityId): Promise<boolean>;
-    endOwnedSession(name: string, sessionId: string, expectedGeneration?: import('./square-core.js').ActivityId, body?: Body): Promise<ActivityResult | null>;
+    private heldSeat;
+    cancelDeliveries(name: string, identity: {
+        readonly owner: Owner;
+        readonly generation: import('./square-core.js').ActivityId;
+    }): Promise<boolean>;
+    detach(name: string, identity: {
+        readonly owner: Owner;
+        readonly generation: import('./square-core.js').ActivityId;
+    }): Promise<true | null>;
+    endHeld(name: string, identity: {
+        readonly owner: Owner;
+        readonly generation: import('./square-core.js').ActivityId;
+    }): Promise<LifecycleResult | null>;
 }
 export declare function diagnoseSquare(input: SquareLocation, control?: OperationControl): Promise<import("./artifact.js").DiagnoseResult>;
 export declare function migrateSquare(input: SquareLocation, control?: OperationControl): Promise<import("./square-migration.js").MigrationOutcome>;
 export declare function discover(input: SquareAtInput, options?: DiscoveryOptions, control?: OperationControl): Promise<import("./square-facade.js").DiscoveryResult>;
-export declare function inbox(input: SquareAtInput, identity: string | Body, options?: InboxOptions, control?: OperationControl): Promise<InboxResult>;
+export declare function inbox(input: SquareAtInput, owner: Owner, options?: InboxOptions, control?: OperationControl): Promise<InboxResult>;