@astrosheep/square 0.3.86 → 0.3.87

package/dist/ports.d.ts

@@ -1,9 +1,8 @@
-import type { Act, HardCap, InboxNotification, StoredAct, WakeRoute, WakeRouteKind, WatchLease } from './model.js';
-export type { ClaimResult, EvidenceClaim, EvidenceRelease, EvidenceLookup, EvidenceRecord, NativeTokenLookup, NativeTokenResult, HostLedgerPort, PresenceKey, PresenceLookup, PresenceRecord, PresenceClaimResult, PresenceChannel, PresenceResult, } from './host-ledger.js';
-import type { HostLedgerPort } from './host-ledger.js';
+import type { Act, ActivityId, Body, HardCap, Seat, StoredAct, WakeAddress, WakeRoute, WatchLease } from './model.js';
 export type ActivityIndex = number;
 export interface SquareHeader {
     readonly revision: number;
+    readonly deliveryRevision: number;
     readonly nextActIndex: number;
     readonly lastActIndex: number;
     readonly hardCap: HardCap;
@@ -88,19 +87,92 @@ export interface ReceiptAssignment {
 export type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
     readonly [key: string]: JsonValue;
 };
-export interface RouteFact {
-    readonly location: string;
+export type SeatRef = Omit<Seat, 'wakeAddress'>;
+export type ArtifactWriteAuthority = {
+    readonly kind: 'participant';
+    readonly seat: SeatRef;
+} | {
+    readonly kind: 'join';
     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>>;
+    readonly body: Body;
+    readonly wakeAddress?: WakeAddress;
+} | {
+    readonly kind: 'takeover';
+    readonly participant: string;
+    readonly body: Body;
+    readonly expectedGeneration: ActivityId;
+    readonly wakeAddress?: WakeAddress;
+};
+export interface DeliveryEvidence {
+    readonly participant: string;
+    readonly generation: ActivityId;
+    readonly activity: ActivityId;
+    readonly kind: 'wake' | 'presentation';
+    readonly outcome: 'dispatching' | 'accepted' | 'failed' | 'unknown' | 'released' | 'presented' | 'clipped';
+    readonly attemptN: number;
+    readonly at: number;
+    readonly expiresAt?: number;
+    readonly claimToken?: string;
+    readonly route?: WakeAddress;
+    readonly signature?: string;
+    readonly message?: string;
+    readonly diagnostic?: import('./model.js').JsonValue;
+    readonly correlation?: {
+        readonly harness: 'claude' | 'opencode' | 'pi';
+        readonly token?: string;
+        readonly messageId?: string;
+        readonly payloadHash?: string;
+    };
+    readonly nativeObservations?: readonly {
+        readonly eventId: string;
+        readonly messageId: string;
+        readonly state: 'held' | 'released' | 'dropped';
+        readonly reason?: string;
+        readonly observedAt: number;
+    }[];
+}
+export interface DeliveryClaimInput {
+    readonly seat: SeatRef;
+    readonly activity: ActivityId;
+    readonly kind: 'wake' | 'presentation';
+    readonly route?: WakeAddress;
+    readonly at: number;
+    readonly leaseMs: number;
+    readonly claimToken: string;
+}
+export type DeliveryClaimResult = {
+    readonly status: 'acquired';
+    readonly claimToken: string;
+    readonly attemptN: number;
+} | {
+    readonly status: 'busy' | 'terminal' | 'stale';
+    readonly evidence?: DeliveryEvidence;
+};
+export interface DeliveryPreparation {
+    readonly seat: SeatRef;
+    readonly claimToken: string;
+    readonly correlation: NonNullable<DeliveryEvidence['correlation']>;
+}
+export interface DeliveryCompletion {
+    readonly seat: SeatRef;
+    readonly activity: ActivityId;
+    readonly claimToken: string;
+    readonly outcome: Exclude<DeliveryEvidence['outcome'], 'dispatching'>;
+    readonly at: number;
+    readonly signature?: string;
+    readonly message?: string;
+    readonly diagnostic?: import('./model.js').JsonValue;
+    readonly correlation?: DeliveryEvidence['correlation'];
 }
 /** Domain facts exist only during a synchronous artifact callback. Values are detached. */
 export interface SquareRead {
+    seat(requestedName: string): Seat | undefined;
+    seatsForBody(body: Body): readonly Seat[];
+    /** Latest completed coordinates only; never participant write authority. */
+    completedSeatsForBody(body: Body): readonly Seat[];
+    deliveryEvidence(participant: string, generation: ActivityId, activity?: ActivityId): readonly DeliveryEvidence[];
+    deliveryByToken(claimToken: string): DeliveryEvidence | undefined;
+    cancelledThrough(participant: string, generation: ActivityId): number | undefined;
     header(): SquareHeader;
     participant(requestedName: string): ParticipantFact | undefined;
     participantCounts(): ParticipantCounts;
@@ -139,16 +211,24 @@ export interface SquareRead {
     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;
+    updateWakeAddress(seat: SeatRef, wakeAddress?: WakeAddress): boolean;
+    cancelThrough(seat: SeatRef, through: ActivityIndex): boolean;
+    claimDelivery(input: DeliveryClaimInput): DeliveryClaimResult;
+    prepareDelivery(input: DeliveryPreparation): boolean;
+    completeDelivery(input: DeliveryCompletion): boolean;
+    observeNativeDelivery(input: {
+        readonly seat: SeatRef;
+        readonly claimToken: string;
+        readonly observation: NonNullable<DeliveryEvidence['nativeObservations']>[number];
+    }): boolean;
     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;
+    putLease(requestedName: string, lease: WatchLease, generation?: ActivityId): boolean;
+    removeLease(requestedName: string, expectedLeaseId: string, generation?: ActivityId): boolean;
 }
 export interface SquareReadResult<R> {
     readonly value: R;
@@ -160,8 +240,15 @@ export interface SquareCommitResult<R> extends SquareReadResult<R> {
 /** Atomic artifact access; no framing, SQL or lazy transaction capability escapes. */
 export interface SquareArtifactPort {
     read<R>(select: (facts: SquareRead) => R, signal?: AbortSignal): Promise<SquareReadResult<R>>;
-    transact<R>(change: (facts: SquareWrite) => R, signal?: AbortSignal): Promise<SquareCommitResult<R>>;
+    /** Participant/domain writes must carry an explicit authority; no body-less mutation path exists. */
+    transactAs<R>(authority: ArtifactWriteAuthority, change: (facts: SquareWrite) => R, signal?: AbortSignal): Promise<SquareCommitResult<R>>;
     revision(signal?: AbortSignal): Promise<number>;
+    deliveryRevision(signal?: AbortSignal): Promise<number>;
+    claimDelivery(input: DeliveryClaimInput, signal?: AbortSignal): Promise<DeliveryClaimResult>;
+    prepareDelivery(input: DeliveryPreparation, signal?: AbortSignal): Promise<boolean>;
+    completeDelivery(input: DeliveryCompletion, signal?: AbortSignal): Promise<boolean>;
+    /** Persist suppression through a fixed index, or atomically capture the current artifact head. */
+    cancelDeliveries(seat: SeatRef, through?: ActivityIndex, signal?: AbortSignal): Promise<boolean>;
     changed(sinceVersion: number, timeoutMs: number, signal?: AbortSignal): Promise<boolean>;
     close(): Promise<void>;
 }
@@ -175,46 +262,31 @@ export interface SquareResourceOwner {
     artifact(location: string): SquareArtifactPort;
     close(): Promise<void>;
 }
-/** Capability-neutral wake transport. Unused by this Contract's activity operations. */
+/** Sole wake executor protocol; implementations own only transport readiness and sending. */
 export interface WakeTransportPort {
     /** Capability check that performs no external wake and writes no evidence. */
     probe?(route: WakeRoute): Promise<boolean | {
         readonly outcome: 'not-capable';
         readonly diagnostic?: string;
     }>;
-    attempt(request: WakeRequest, timeoutMs: number, beforeSend?: () => Promise<boolean>): Promise<WakeOutcome>;
+    attempt(request: WakeRequest, timeoutMs: number, beforeSend: () => Promise<boolean>): Promise<WakeOutcome>;
 }
 export interface WakeRequest {
     readonly location: string;
     readonly participant: string;
     readonly activity: string;
     readonly actor: string;
-    /** Wake attempt token, also the opaque native correlation. */
+    readonly seat: SeatRef;
     readonly claimToken?: string;
     readonly attemptN?: number;
     readonly route: WakeRoute;
+    /** Artifact context for native adapters that must persist correlation before I/O. */
+    readonly artifact?: SquareArtifactPort;
 }
 /** Executor-neutral presentation capability; intentionally separate from wake transport. */
 export interface PresentationSinkPort {
     present(activity: StoredAct): void | Promise<void>;
 }
-/** Stable projection of a host binding; storage rows never cross this boundary. */
-export interface SessionBindingProjection {
-    readonly epoch?: number;
-    readonly cancelledThrough?: number;
-    readonly location: string;
-    readonly participant: string;
-    readonly sessionId: string;
-    readonly channel: import('./host-ledger.js').PresenceChannel;
-    readonly updatedAt: number;
-}
-/** Pending boundary presentation projected for one bound session. */
-export interface PresentationProjection {
-    readonly binding: SessionBindingProjection;
-    readonly joined: boolean;
-    readonly notifications: readonly InboxNotification[];
-    readonly catchLease?: WatchLease;
-}
 /** Read-only presentation evidence projection for diagnostics and migration callers. */
 export interface PresentationEvidenceProjection {
     readonly location: string;
@@ -256,7 +328,6 @@ export interface DeliveryResult {
 }
 export interface DeliverPendingInput {
     readonly artifact: SquareArtifactPort;
-    readonly hostLedger: HostLedgerPort;
     readonly transport: WakeTransportPort;
     readonly location: string;
     readonly timeoutMs?: number;
@@ -273,8 +344,9 @@ export interface PresentPendingInput {
     readonly participant: string;
     readonly activity: string | number;
     readonly sink: PresentationSinkPort;
-    readonly hostLedger?: HostLedgerPort;
-    readonly session?: string;
+    /** Captured artifact seat; used to fence both presentation and consumption. */
+    readonly seat?: SeatRef;
+    readonly generation?: ActivityId;
     readonly now?: number;
     readonly timeoutMs?: number;
     /** One hook deadline propagated into artifact reads/transitions so busy retries stay bounded. */

package/dist/presentation-operations.d.ts

@@ -1,3 +1,3 @@
 import type { PresentationResult, PresentPendingInput } from './ports.js';
-/** Presentation evidence is not a receipt; only the fenced receipt transaction marks seen. */
+/** Presentation is external; its claim and receipt/evidence commit are generation-fenced in the artifact. */
 export declare function presentPending(input: PresentPendingInput): Promise<PresentationResult>;

package/dist/presentation-operations.js

@@ -1,56 +1,72 @@
+import { randomUUID } from 'node:crypto';
 import { formatActivityId, parseActivityId } from './square-core.js';
+import { isSquareError, sameBody } from './model.js';
 import { pendingHead, sameJoin } from './delivery.js';
-/** Presentation evidence is not a receipt; only the fenced receipt transaction marks seen. */
+import { asSeatRef } from './seats.js';
+function currentFor(input, captured, participant, index) {
+    return (facts) => {
+        const seat = facts.seat(captured.participant);
+        return seat !== undefined && sameBody(seat.body, captured.body) && seat.generation === captured.generation
+            && sameJoin(facts, participant) && input.current?.(facts) !== false
+            && pendingHead(facts, captured.participant, index) !== undefined;
+    };
+}
+/** Presentation is external; its claim and receipt/evidence commit are generation-fenced in the artifact. */
 export async function presentPending(input) {
     const index = typeof input.activity === 'number' ? input.activity : parseActivityId(input.activity);
     if (index === undefined)
         return { presented: false };
-    const before = await input.artifact.read((facts) => {
-        if (input.current?.(facts) === false || !pendingHead(facts, input.participant, index))
+    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))
+            || input.current?.(facts) === false || !pendingHead(facts, participant.name, index))
             return undefined;
-        return { item: facts.activity(index), participant: facts.participant(input.participant) };
+        const item = facts.activity(index);
+        return item?.kind === 'say' ? { participant, seat, item } : undefined;
     }, input.signal).catch(() => undefined);
-    if (before?.value === undefined)
+    if (initial?.value === undefined)
+        return { presented: false };
+    const { participant, seat, item } = initial.value;
+    const ref = asSeatRef(seat);
+    const current = currentFor(input, seat, participant, index);
+    const claimToken = randomUUID();
+    const claimed = await input.artifact.claimDelivery({ seat: ref, activity: formatActivityId(index), kind: 'presentation',
+        at: input.now ?? Date.now(), leaseMs: input.timeoutMs ?? 5000, claimToken }, input.signal).catch(() => ({ status: 'stale' }));
+    if (claimed.status !== 'acquired')
+        return { presented: false };
+    const release = async (outcome, message) => input.artifact.completeDelivery({
+        seat: ref, activity: formatActivityId(index), claimToken, outcome, at: Date.now(),
+        ...(message === undefined ? {} : { message }),
+    }, input.signal).catch(() => false);
+    const fresh = await input.artifact.read(current, input.signal).catch(() => undefined);
+    if (!fresh?.value) {
+        await release('released', 'The notification changed before presentation.');
         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({ ...coordinate, leaseMs: input.timeoutMs ?? 5000 });
-        if (claim.status !== 'acquired')
-            return { presented: false };
-        claimToken = claim.claimToken;
-        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) {
-        if (claimToken !== undefined)
-            await input.hostLedger.appendEvidence({ ...coordinate, outcome: 'failed', message: error instanceof Error ? error.message : String(error), claimToken });
+        await release('failed', error instanceof Error ? error.message : String(error));
         throw error;
     }
-    const { value: committed } = await input.artifact.transact((facts) => {
+    const outcome = input.markSeen === false ? 'clipped' : 'presented';
+    const { value: committed } = await input.artifact.transactAs({ kind: 'participant', seat: ref }, (facts) => {
         if (!current(facts))
             return false;
-        return input.markSeen === false || facts.markSeen(participant.name, [index], input.now ?? Date.now()) > 0;
-    }, input.signal);
-    if (!committed) {
-        await release();
+        if (!facts.completeDelivery({ seat: ref, activity: formatActivityId(index), claimToken, outcome, at: input.now ?? Date.now() }))
+            return false;
+        if (input.markSeen === false)
+            return true;
+        return facts.markSeen(participant.name, [index], input.now ?? Date.now()) > 0;
+    }, input.signal).catch(error => {
+        if (isSquareError(error) && error.code === 'already_joined')
+            return { value: false };
+        throw error;
+    });
+    if (!committed)
         return { presented: false };
-    }
-    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.js

@@ -168,13 +168,16 @@ function renderEventCliFacts(event, opts = {}) {
             return { text: `· ${renderRoomChangeText(event)}`, bodyClipped: false };
         case 'say': {
             const body = renderedBody(event.body, maxBody);
+            const visibleBody = body.text === '' && event.metadata !== undefined
+                ? { text: '(structured activity)', clipped: false }
+                : body;
             const mention = opts.mention;
             const mentionSuffix = mention !== undefined && (event.reach === 'bell' || event.mentions?.some((name) => sameName(name, mention)))
                 ? ` · calls your name across the square — ${participantIdentity(mention)}`
                 : '';
             const replySuffix = event.reply === undefined ? '' : ` · replies to ${replyId(event.reply)}`;
             const meta = ` · ${eventId(event)} · ${formatRelativeTime(event.at, now)}${mentionSuffix}${replySuffix}`;
-            return { text: `● ${participantIdentity(event.actor)}${style('dim', meta)}${bodySuffix(body.text)}`, bodyClipped: body.clipped };
+            return { text: `● ${participantIdentity(event.actor)}${style('dim', meta)}${bodySuffix(visibleBody.text)}`, bodyClipped: visibleBody.clipped };
         }
         case 'done': {
             const body = renderedBody(event.body, maxBody);
@@ -238,8 +241,10 @@ function renderUnreadSummary(opts) {
                 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: '(empty)', remaining: 0 } : truncateChars(compact, UNREAD_PREVIEW_CHARS);
+                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}"`);
             }),

package/dist/seats.d.ts

@@ -0,0 +1,7 @@
+import { type Body, type Seat } from './model.js';
+import type { ArtifactWriteAuthority, SeatRef } from './ports.js';
+export declare function requireBody(body: Body | undefined): Body;
+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

@@ -0,0 +1,27 @@
+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;
+}
+export function requireJoinName(name) {
+    if (name === undefined)
+        throw new SquareError('invalid_args', 'Square.join requires an explicit participant name.');
+    validateName(name);
+    return name;
+}
+export function asSeatRef(seat) {
+    const { wakeAddress: _wakeAddress, ...ref } = seat;
+    return ref;
+}
+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,3 @@
-import { type AutomaticProvider } from './participant-identity.js';
-/** Retire only memberships owned at this session's end, regardless of square filename or cwd. */
+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>;

package/dist/session-lifecycle.js

@@ -1,18 +1,16 @@
 import { Square } from './square-api.js';
-import { operationEnv } from './participant-identity.js';
-import { hostLedgerForEnv } from './registry.js';
-import { projectSessionBindings } from './square-projections.js';
-/** Retire only memberships owned at this session's end, regardless of square filename or cwd. */
+import { projectSessionSeats } from './inbox.js';
+function bodyFor(provider, sessionId) {
+    return { 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 scoped = operationEnv(provider, sessionId, env);
-    const hostLedger = hostLedgerForEnv(scoped);
-    const bindings = await projectSessionBindings({ hostLedger, sessionId });
-    for (const binding of bindings) {
-        const square = await Square.at({ path: binding.location, hostLedger, env: scoped });
+    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 });
         try {
-            // The captured epoch fences a same-session rejoin as well as a foreign takeover.
-            // endOwnedSession also settles routes and presence under the ownership claim lock.
-            await square.endOwnedSession(binding.participant, sessionId, binding.epoch ?? 0);
+            await square.endOwnedSession(seat.participant, sessionId, seat.generation, body);
         }
         finally {
             await square.close();

package/dist/sqlite-square.d.ts

@@ -1,26 +1,37 @@
+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';
 export type * from './square-facade.js';
-export { createSquareResourceOwner } from './open-square.js';
+export { createSquareResourceOwner } from './artifact.js';
 export { formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE } from './square-core.js';
 export { CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT } from './catch-decisions.js';
 export { HELD_WAIT_BUDGET_MS } from './runtime.js';
 export { HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT } from './views.js';
 export { DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT } from './list.js';
 export declare function squareClock(env: NodeJS.ProcessEnv, clock?: () => number): () => number;
-/** One concrete square resource. Request handles may borrow a server-owned connection. */
+/** One concrete local resource, including its entry-resolved dependencies and lifetime. */
 export declare class SqliteSquare {
     readonly location: string;
-    private readonly square;
+    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 transport;
     private constructor();
     static at(input: SquareAtInput, control?: OperationControl, automaticDelivery?: boolean): Promise<SqliteSquare>;
     static build(input: SquareBuildInput, control?: OperationControl, automaticDelivery?: boolean): 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;
+    private observation;
+    private contextObservation;
     private handle;
+    private static readonly ParticipantHandle;
     participant(requested?: string): Promise<Participant>;
     join(requested?: string, options?: JoinOptions, control?: OperationControl): Promise<JoinResult>;
-    doneOwnedSession(name: string, body: string, expectedEpoch: number, control?: OperationControl): Promise<ActivityResult>;
     implicitJoin(name: string, control?: OperationControl): Promise<{
         readonly state: 'joined' | 'active' | 'done';
         readonly participant?: Participant;
@@ -31,12 +42,12 @@ export declare class SqliteSquare {
     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(env: NodeJS.ProcessEnv): Promise<Participant | null>;
+    recognize(): Promise<readonly Participant[]>;
     close(): Promise<void>;
-    endOwnedSession(name: string, sessionId: string, expectedEpoch?: number): Promise<ActivityResult | null>;
-    retireEndedSessionRoutes(sessionId: string): 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>;
 }
 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, sessionId: string, options?: InboxOptions, control?: OperationControl): Promise<InboxResult>;
+export declare function inbox(input: SquareAtInput, identity: string | Body, options?: InboxOptions, control?: OperationControl): Promise<InboxResult>;