@astrosheep/square 0.3.92 → 0.3.94

package/dist/square-api.js

@@ -1,26 +1,30 @@
 import { SqliteSquare } from './sqlite-square.js';
-import { squareLocation, backendConfiguration, parseSquareLocation } from './square-location.js';
-import { openStdioSquare } from './square-stdio.js';
+import { SquareError } from './model.js';
+import { requireOwner } from './seats.js';
+import { createDefaultWakeTransport } from './notifications.js';
+export const Square = { at: async (input, control) => SqliteSquare.at({ ...input, wakeTransport: await resolveWakeTransport(input) }, control),
+    build: async (input, control) => SqliteSquare.build({ ...input, wakeTransport: await resolveWakeTransport(input) }, control), inMemory: SqliteSquare.inMemory };
+const resolveWakeTransport = (input) => input.wakeTransport !== undefined
+    ? Promise.resolve(input.wakeTransport)
+    : createDefaultWakeTransport(input.env ?? process.env).catch(() => undefined);
+export { requireOwner, requireJoinName } from './seats.js';
 export { squareLocation } from './square-location.js';
+export async function selectOwnSeat(square, owner, name, options) {
+    if (owner === undefined && options?.optional && name === undefined)
+        return undefined;
+    const caller = requireOwner(owner);
+    if (name !== undefined)
+        return square.participant(name, { owner: caller });
+    const seats = (await square.seatsOf(caller)).filter(seat => seat.attachment === 'attached');
+    if (seats.length !== 1) {
+        if (options?.optional)
+            return undefined;
+        throw new SquareError('invalid_args', seats.length > 1
+            ? 'Square needs an explicit participant name: this owner holds multiple names'
+            : 'Square needs one unambiguous participant name');
+    }
+    return square.participant(seats[0].name, { owner: caller });
+}
 export { ACTIVITY_METADATA_MAX_BYTES } from './model.js';
+export { localUserOwner, harnessOwner, decodeHarnessOwner } from './owner.js';
 export { squareClock, createSquareResourceOwner, formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE, CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT, HELD_WAIT_BUDGET_MS, HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT, DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT, diagnoseSquare, migrateSquare, discover, inbox } from './sqlite-square.js';
-export const Square = {
-    async at(input, control) {
-        const captured = { ...input, cwd: input.cwd ?? process.cwd(), env: { ...(input.env ?? process.env) } };
-        const location = squareLocation(captured);
-        const selected = parseSquareLocation(location);
-        return selected.kind === 'local' ? SqliteSquare.at({ ...captured, path: location }, control)
-            : openStdioSquare(location, selected, captured, await backendConfiguration(captured), undefined, control);
-    },
-    async build(input, control) {
-        const captured = { ...input, cwd: input.cwd ?? process.cwd(), env: { ...(input.env ?? process.env) } };
-        const location = squareLocation(captured);
-        const selected = parseSquareLocation(location);
-        return selected.kind === 'local' ? SqliteSquare.build({ ...captured, path: location }, control)
-            : openStdioSquare(location, selected, captured, await backendConfiguration(captured), {
-                markdown: input.markdown, hardCap: input.hardCap, throttlePerMinute: input.throttlePerMinute,
-                template: input.template, force: input.force,
-            }, control);
-    },
-    inMemory(input) { return SqliteSquare.inMemory(input); },
-};

package/dist/square-core.d.ts

@@ -59,9 +59,4 @@ export type Act = {
     target: Participant;
     at?: number;
 };
-export declare function audienceOf(say: {
-    body?: string;
-    mentions?: readonly Participant[];
-    reach?: Reach;
-}): Audience;
 export declare function audienceIncludes(audience: Audience, name: string): boolean;

package/dist/square-core.js

@@ -13,15 +13,6 @@ export function parseActivityId(value) {
     const index = Number(value.slice(4));
     return Number.isSafeInteger(index) ? index : undefined;
 }
-export function audienceOf(say) {
-    if (say.reach === 'bell')
-        return { kind: 'bell' };
-    const names = [];
-    for (const name of say.mentions ?? [])
-        if (!names.some((existing) => sameName(existing, name)))
-            names.push(name);
-    return { kind: 'mentions', names };
-}
 export function audienceIncludes(audience, name) {
     return audience.kind === 'bell' || audience.names.some((mentioned) => sameName(mentioned, name));
 }

package/dist/square-domain.d.ts

@@ -1,5 +1,5 @@
 import { type Seat, type StoredAct } from './model.js';
-import type { ArtifactWriteAuthority, AttentionFact, LandedRecipient, ParticipantFact, SquareRead, SquareWrite } from './ports.js';
+import type { ArtifactWriteAuthority, AttentionFact, LandedRecipient, ParticipantFact, SeatRef, SquareRead, SquareWrite } from './ports.js';
 export interface LandingEffect {
     readonly activity: StoredAct;
     readonly participant?: ParticipantFact;
@@ -21,7 +21,7 @@ export interface LandingFacts {
 /** The single landing transition, shared by both adapters and explicit rebuild. */
 export declare function deriveLanding(activity: StoredAct, facts: LandingFacts): LandingEffect;
 export declare function landingFacts(read: SquareRead, activity: StoredAct): LandingFacts;
-export interface LandingWriter extends Pick<SquareWrite, 'markSeen' | 'putLease' | 'removeLease' | 'updateWakeAddress' | 'cancelThrough' | 'putDeliveryDeferral' | 'renewDeliveryDeferral' | 'releaseDeliveryDeferral' | 'claimDelivery' | 'prepareDelivery' | 'completeDelivery' | 'observeNativeDelivery'> {
+export interface LandingWriter extends Pick<SquareWrite, 'markSeen' | 'putLease' | 'removeLease' | 'updateWakeAddress' | 'reattachSeat' | 'detachSeat' | 'cancelThrough' | 'putDeliveryDeferral' | 'renewDeliveryDeferral' | 'releaseDeliveryDeferral' | 'claimDelivery' | 'prepareDelivery' | 'completeDelivery' | 'observeNativeDelivery'> {
     /** Artifact-private seat persistence used only by this gate's lifecycle transition. */
     storeSeat(seat: Seat): boolean;
     removeSeat(seat: import('./ports.js').SeatRef): boolean;
@@ -31,5 +31,7 @@ export interface SquareWriteGate {
     readonly facts: SquareWrite;
     complete(): void;
 }
+/** Read probes and writes share the same captured-coordinate and attachment fence. */
+export declare function assertCurrentSeat(read: SquareRead, expected: SeatRef, allowDetached?: boolean): void;
 /** The artifact transaction supplies one captured authority; every mutation checks it here. */
 export declare function wrapSquareWrite(read: SquareRead, writes: LandingWriter, authority: ArtifactWriteAuthority): SquareWriteGate;

package/dist/square-domain.js

@@ -1,4 +1,4 @@
-import { SquareError, formatActivityId, parseActivityId, sameBody, sameName, validateBody, validateName } from './model.js';
+import { SquareError, formatActivityId, parseActivityId, sameName, validateOwner, validateName } from './model.js';
 /** The single landing transition, shared by both adapters and explicit rebuild. */
 export function deriveLanding(activity, facts) {
     const audience = [];
@@ -68,31 +68,38 @@ function validateGeneration(value) {
     if (typeof value !== 'string' || parseActivityId(value) === undefined)
         throw new SquareError('invalid_args', 'Artifact authority requires a valid join generation.');
 }
+/** Read probes and writes share the same captured-coordinate and attachment fence. */
+export function assertCurrentSeat(read, expected, allowDetached = false) {
+    const current = read.seat(expected.participant);
+    if (current === undefined || current.owner !== expected.owner || current.generation !== expected.generation)
+        throw new SquareError('already_joined', 'This participant seat has been replaced.');
+    if (!allowDetached && current.attachment !== 'attached')
+        throw new SquareError('already_joined', 'This participant is away; join again before writing.', { reason: 'needs_seat', activityUnsent: true });
+}
 /** The artifact transaction supplies one captured authority; every mutation checks it here. */
 export function wrapSquareWrite(read, writes, authority) {
     if (authority === undefined || typeof authority !== 'object' || authority === null)
         throw new SquareError('invalid_args', 'Artifact writes require an explicit authority.');
     const { applyLanding, ...mutations } = writes;
-    const expectedName = authority.kind === 'participant' ? authority.seat?.participant : authority.participant;
-    if (!['participant', 'join', 'takeover'].includes(authority.kind) || typeof expectedName !== 'string')
+    const seated = authority.kind === 'participant' || authority.kind === 'host-cleanup';
+    const expectedName = seated ? authority.seat?.participant : authority.participant;
+    if (!['participant', 'host-cleanup', 'join', 'takeover'].includes(authority.kind) || typeof expectedName !== 'string')
         throw new SquareError('invalid_args', 'Artifact write authority is malformed.');
     validateName(expectedName);
-    if (authority.kind === 'participant') {
-        validateBody(authority.seat.body);
+    if (seated) {
+        validateOwner(authority.seat.owner);
         validateGeneration(authority.seat.generation);
     }
     else {
-        validateBody(authority.body);
+        validateOwner(authority.owner);
         if (authority.kind === 'takeover')
             validateGeneration(authority.expectedGeneration);
     }
-    const assertSeat = (seat, expected = authority.kind === 'participant' ? authority.seat : undefined) => {
+    const assertSeat = (seat, expected = authority.kind === 'participant' ? authority.seat : undefined, allowDetached = false) => {
         if (expected === undefined || !sameName(expected.participant, seat.participant)
-            || seat.generation !== expected.generation || !sameBody(seat.body, expected.body))
+            || seat.generation !== expected.generation || seat.owner !== expected.owner)
             throw new SquareError('already_joined', 'This write needs the current participant seat.');
-        const current = read.seat(seat.participant);
-        if (current === undefined || !sameBody(current.body, expected.body) || current.generation !== expected.generation)
-            throw new SquareError('already_joined', 'This participant seat has been replaced.');
+        assertCurrentSeat(read, expected, allowDetached);
     };
     const assertParticipant = (name, generation) => {
         if (authority.kind !== 'participant')
@@ -104,11 +111,14 @@ export function wrapSquareWrite(read, writes, authority) {
     if (authority.kind === 'participant') {
         assertSeat(authority.seat);
     }
+    else if (authority.kind === 'host-cleanup') {
+        // A late host cleanup is allowed to inspect a stale coordinate and return a no-op.
+    }
     else if (authority.kind === 'join') {
         const participant = read.participant(expectedName), seat = read.seat(expectedName);
         if (participant?.joined) {
-            if (seat === undefined || !sameBody(seat.body, authority.body))
-                throw new SquareError('already_joined', `${expectedName} is held by another body; take it over explicitly`);
+            if (seat === undefined || seat.owner !== authority.owner)
+                throw new SquareError('already_joined', `${expectedName} is held by another owner; take it over explicitly`);
             reconnectSeat = seat;
         }
     }
@@ -131,6 +141,11 @@ export function wrapSquareWrite(read, writes, authority) {
                 if (activity.kind === 'join')
                     throw new SquareError('invalid_args', 'A participant seat can only be re-established by join.');
             }
+            else if (authority.kind === 'host-cleanup') {
+                assertSeat(authority.seat, authority.seat, true);
+                if (activity.kind !== 'done')
+                    throw new SquareError('invalid_args', 'Host cleanup may only end membership.');
+            }
             else if (authority.kind === 'join') {
                 if (activity.kind !== 'join')
                     throw new SquareError('invalid_args', 'A new seat must be established by its join activity.');
@@ -157,27 +172,28 @@ export function wrapSquareWrite(read, writes, authority) {
             const stored = { ...activity, index };
             applyLanding(deriveLanding(stored, landingFacts(read, stored)));
             if (stored.kind === 'join') {
-                if (authority.kind === 'participant')
-                    throw new SquareError('invalid_args', 'Participant authority cannot establish a seat.');
+                if (seated)
+                    throw new SquareError('invalid_args', 'Seat authority cannot establish another seat.');
                 const seat = {
                     participant: stored.actor,
-                    body: authority.body,
+                    owner: authority.owner,
                     generation: formatActivityId(stored.index),
+                    attachment: 'attached',
                     ...(authority.wakeAddress === undefined ? {} : { wakeAddress: authority.wakeAddress }),
                 };
                 mutations.storeSeat(seat);
                 const established = read.seat(seat.participant);
-                if (established === undefined || !sameBody(established.body, seat.body) || established.generation !== seat.generation)
+                if (established === undefined || established.owner !== seat.owner || established.generation !== seat.generation)
                     throw new SquareError('invalid_args', 'The join activity did not establish its artifact seat.');
                 if (authority.kind === 'takeover')
                     takeoverPhase = 'joined';
             }
-            else if (stored.kind === 'done' && authority.kind === 'participant') {
+            else if (stored.kind === 'done' && seated) {
                 if (!mutations.removeSeat(authority.seat))
                     throw new SquareError('already_joined', 'The participant seat changed while it was being completed.');
             }
             else if (stored.kind === 'done' && authority.kind === 'takeover') {
-                if (captured === undefined || !mutations.removeSeat({ participant: expectedName, body: captured.body, generation: captured.generation }))
+                if (captured === undefined || !mutations.removeSeat({ participant: expectedName, owner: captured.owner, generation: captured.generation }))
                     throw new SquareError('already_joined', 'The participant seat changed while takeover was completing it.');
                 takeoverPhase = 'done';
             }
@@ -185,9 +201,28 @@ export function wrapSquareWrite(read, writes, authority) {
             return lastActivity;
         },
         updateWakeAddress(seat, wakeAddress) {
-            assertSeat(seat, authority.kind === 'join' ? reconnectSeat : undefined);
+            if (authority.kind !== 'join' && authority.kind !== 'participant')
+                throw new SquareError('already_joined', 'This write needs the current participant seat.');
+            assertSeat(seat, authority.kind === 'join' ? reconnectSeat : authority.seat);
             return mutations.updateWakeAddress(seat, wakeAddress);
         },
+        reattachSeat(seat, wakeAddress) {
+            if (authority.kind !== 'join')
+                throw new SquareError('already_joined', 'Reattachment requires a same-owner join.');
+            assertSeat(seat, reconnectSeat, true);
+            return mutations.reattachSeat(seat, wakeAddress);
+        },
+        detachSeat(seat) {
+            if (authority.kind !== 'host-cleanup')
+                throw new SquareError('already_joined', 'Detach requires captured host cleanup authority.');
+            const current = read.seat(seat.participant), expected = authority.seat;
+            if (!sameName(seat.participant, expected.participant) || seat.owner !== expected.owner || seat.generation !== expected.generation)
+                throw new SquareError('already_joined', 'Host cleanup does not match its captured seat.');
+            if (current === undefined || current.attachment !== 'attached' || current.owner !== expected.owner
+                || current.generation !== expected.generation)
+                return false;
+            return mutations.detachSeat(seat);
+        },
         cancelThrough(seat, through) {
             assertSeat(seat);
             if (!Number.isSafeInteger(through) || through < 0 || through > read.header().lastActIndex || read.activity(through) === undefined)
@@ -242,7 +277,7 @@ export function wrapSquareWrite(read, writes, authority) {
                 return;
             const seat = read.seat(expectedName);
             if (takeoverPhase !== 'joined' || lastActivity?.kind !== 'join' || seat === undefined
-                || !sameBody(seat.body, authority.body) || seat.generation !== formatActivityId(lastActivity.index))
+                || seat.owner !== authority.owner || seat.generation !== formatActivityId(lastActivity.index))
                 throw new SquareError('already_joined', 'Takeover did not complete its replacement join.');
         },
     };

package/dist/square-facade.d.ts

@@ -1,11 +1,10 @@
-import type { SquareBackends } from './square-backend.js';
 import type { DeliveryDeferral, MetadataMatch } from './delivery-deferral.js';
 export type { DeliveryDeferral, MetadataMatch, MetadataScalar } from './delivery-deferral.js';
 import type { ActivityId, Perception, Reach } from './square-core.js';
-import type { Body, StoredAct, WakeAddress, ActivityMetadata } from './model.js';
-import type { WakeTransportPort, DeliveryResult, SquareResourceOwner } from './ports.js';
+import type { Owner, StoredAct, WakeAddress, ActivityMetadata, DirectedNotificationRoute } from './model.js';
+import type { WakeTransportPort, SquareResourceOwner } from './ports.js';
 export type { ActivityId, Perception, Reach } from './square-core.js';
-export type { Body, WakeAddress, ActivityMetadata, JsonValue } from './model.js';
+export type { Owner, WakeAddress, ActivityMetadata, JsonValue, DirectedNotificationRoute } from './model.js';
 /** Indexed archive event, including read and historical actorless lifecycle records. */
 export type ArchiveRecord = Readonly<StoredAct>;
 export interface Activity {
@@ -22,6 +21,7 @@ export interface Activity {
 }
 export interface PerceivedActivity extends Activity {
     readonly perception: Perception;
+    readonly via?: DirectedNotificationRoute;
 }
 /** Request extra facts for rendering, without changing operation semantics. */
 export interface ObservationOptions {
@@ -39,12 +39,8 @@ export interface ExpressOptions extends ObservationOptions {
 export interface ExpressInput extends ExpressOptions {
     readonly body?: string;
 }
-export interface ActivityResult {
+export interface ExpressResult {
     readonly activity: Activity;
-    readonly delivery?: DeliveryResult;
-}
-export interface ExpressResult extends ActivityResult {
-    readonly waited: boolean;
     /** The replied-to author was not standing when the reply landed. */
     readonly replyAuthorNotHere?: string;
     /** Body @name tokens with no standing match at landing; never stored on the activity. */
@@ -61,8 +57,9 @@ export interface ListeningResult {
     readonly listening: readonly string[];
     readonly observation?: SquareObservation;
 }
-export interface LifecycleResult extends ActivityResult {
-    readonly observation?: LifecycleObservation;
+export interface LifecycleResult {
+    readonly activity: Activity;
+    readonly observation?: SquareObservation;
 }
 export interface CatchOptions extends ObservationOptions {
     readonly id?: ActivityId;
@@ -72,12 +69,11 @@ export interface CatchOptions extends ObservationOptions {
     readonly limit?: number;
     readonly replace?: boolean;
 }
+export type CatchReason = 'drained' | 'idle' | 'capped' | 'quorum' | 'replaced' | 'already-active';
 export interface CatchResult {
     readonly activities: readonly PerceivedActivity[];
-    readonly consumedThrough: ActivityId | null;
-    readonly idleExpired: boolean;
     readonly remaining: number;
-    readonly status?: CatchTerminalStatus;
+    readonly reason: CatchReason;
     /** Occasional participant-facing nudge; not part of any activity. */
     readonly hint?: string;
     readonly observation?: CatchObservation;
@@ -134,13 +130,6 @@ export interface HistoryResult {
     readonly activities: readonly Activity[];
     readonly observation?: HistoryObservation;
 }
-export interface ParticipantStatus {
-    readonly name: string;
-    readonly state: 'joined' | 'done';
-    readonly consumedThrough: ActivityId | null;
-    readonly watching: boolean;
-    readonly listening: readonly string[];
-}
 export interface SquareSnapshot {
     readonly context: string;
     readonly actCount: number;
@@ -150,16 +139,12 @@ export interface SquareSnapshot {
         readonly by: string;
         readonly reason?: string;
     } | null;
-    readonly participants: readonly ParticipantStatus[];
+    readonly participants: readonly Pick<ParticipantSummary, 'name' | 'presence' | 'listening'>[];
     delivered(name: string, id: ActivityId): boolean;
 }
 export interface OpenOptions {
     readonly clock?: () => number;
-    readonly wakeTransport?: WakeTransportPort;
-    /** Explicit execution coordinate resolved by an adapter. */
-    readonly body?: Body;
-    /** Optional wake address attached to this body. */
-    readonly wakeAddress?: WakeAddress;
+    readonly wakeTransport?: WakeTransportPort | false;
 }
 export interface SquareLocation {
     readonly path?: string;
@@ -167,8 +152,6 @@ export interface SquareLocation {
     readonly env?: NodeJS.ProcessEnv;
 }
 export interface SquareAtInput extends SquareLocation, OpenOptions {
-    readonly backends?: SquareBackends;
-    readonly participant?: string;
     /** A caller-owned connection; closing this Square never closes its owner. */
     readonly resources?: SquareResourceOwner;
 }
@@ -180,6 +163,8 @@ export interface SquareBuildInput extends SquareAtInput {
     readonly force?: boolean;
 }
 export interface JoinOptions extends ObservationOptions {
+    readonly owner: Owner;
+    readonly wakeAddress?: WakeAddress;
     readonly takeover?: boolean;
     readonly last?: number;
 }
@@ -187,8 +172,6 @@ export interface JoinResult {
     readonly participant: Participant;
     readonly activity: Activity | null;
     readonly kind: 'joined' | 'reconnected' | 'taken-over';
-    /** Known joined-or-done participants, not the current standing count. */
-    readonly participantCount: number;
     readonly observation?: JoinObservation;
 }
 export interface Participant {
@@ -200,7 +183,6 @@ export interface Participant {
     unlisten(target: string, options?: ObservationOptions, control?: OperationControl): Promise<ListenerChangeResult>;
     listening(options?: ObservationOptions, control?: OperationControl): Promise<ListeningResult>;
     catch(options?: CatchOptions, control?: OperationControl): Promise<CatchResult>;
-    history(query?: HistoryQuery, control?: OperationControl): Promise<HistoryResult>;
     hold(reason?: string, options?: ObservationOptions, control?: OperationControl): Promise<LifecycleResult>;
     resume(options?: ObservationOptions, control?: OperationControl): Promise<LifecycleResult>;
     /** Leave without a message. Only an omitted or empty body is accepted. */
@@ -212,12 +194,15 @@ export interface Participant {
     renewDeliveryDeferral(id: string, durationMs: number, control?: OperationControl): Promise<DeliveryDeferral | null>;
     releaseDeliveryDeferral(id: string, control?: OperationControl): Promise<boolean>;
 }
-export type CatchTerminalStatus = 'already-active' | 'replaced' | 'capped' | 'quorum';
-export type CatchStopStatus = CatchTerminalStatus | 'empty-now' | 'stale';
-export type ParticipantPresence = 'never-joined' | 'active' | 'watching' | 'done';
+export interface HeldSeat {
+    readonly name: string;
+    readonly generation: ActivityId;
+    readonly attachment: 'attached' | 'detached';
+}
+export type ParticipantPresence = 'never-joined' | 'active' | 'watching' | 'away' | 'done';
 export interface ParticipantSummary {
     readonly name: string;
-    readonly state: 'active' | 'done' | 'not joined';
+    readonly deliveryAvailable: boolean;
     readonly listening: readonly string[];
     readonly activityCount: number;
     readonly lastActiveAt?: number;
@@ -232,12 +217,11 @@ export interface StatusResult {
     /** Present when a viewer resolves; an empty list means they listen to nobody. */
     readonly listening?: readonly string[];
     readonly hardCap: number | null;
-    readonly activeCount: number;
-    readonly doneCount: number;
     readonly participants: readonly ParticipantSummary[];
     readonly now: number;
     readonly throttlePerMinute?: number;
-    readonly hold: {
+    /** Non-null whenever held; by is present with an actor and omitted only for historical actorless holds. */
+    readonly held: {
         readonly by?: string;
         readonly reason?: string;
         readonly at?: number;
@@ -284,10 +268,8 @@ export interface RecoveryResult {
     readonly participant?: string;
     readonly standingCount?: number;
     readonly held?: boolean;
-    readonly holdReason?: string;
     readonly ownActivityCount?: number;
     readonly hardCap?: number | null;
-    readonly roster?: readonly string[];
     readonly activitySummaries?: readonly UnreadActivitySummary[];
 }
 export type StreamStart = {
@@ -295,69 +277,45 @@ export type StreamStart = {
     readonly last: number;
 } | {
     readonly kind: 'after';
-    readonly after: number;
+    readonly after: ActivityId;
 };
 export interface StreamOptions {
     readonly recipient?: string;
     readonly start?: StreamStart;
 }
-export type StreamRecord = ArchiveRecord & {
-    readonly seq: number;
-    readonly square: string;
-    readonly route?: string;
-};
-export interface UnreadActivityPreview {
-    readonly number: number;
-    readonly act: Extract<ArchiveRecord, {
-        kind: 'say';
-    }>;
-    readonly perception: Perception;
-}
+export type StreamRecord = Activity | PerceivedActivity;
 export interface UnreadActivitySummary {
     readonly name: string;
     readonly count: number;
     readonly latestActivityAgeMs: number;
-    readonly previews: readonly UnreadActivityPreview[];
+    readonly preview: Extract<ArchiveRecord, {
+        kind: 'say';
+    }>;
 }
 export interface EntryPresentation {
     readonly joinedBefore: boolean;
     readonly scene: string;
     readonly joinContext: string;
-    readonly recentActivities: readonly ArchiveRecord[];
-    readonly perceptions: Readonly<Record<number, Perception>>;
-    readonly sayNumbers: Readonly<Record<number, number>>;
-}
-export interface ListPresentation {
-    readonly context: readonly string[];
-    readonly participants: readonly string[];
-    readonly activities: number;
+    readonly recentActivities: readonly PerceivedActivity[];
 }
 export interface PresenceClassification {
     readonly orderedHereNames: readonly string[];
     readonly lingeringCount: number;
-    readonly classificationByName: Readonly<Record<string, 'here' | 'lingering' | 'done' | 'not-joined'>>;
+    readonly classificationByName: Readonly<Record<string, 'here' | 'lingering' | 'away' | 'done' | 'not-joined'>>;
 }
 export interface CatchPresence {
     readonly participants: readonly ParticipantSummary[];
     readonly now: number;
 }
-export interface StreamProjection {
-    readonly activities: readonly {
-        readonly activity: ArchiveRecord;
-        readonly route?: string;
-    }[];
-    readonly cursor: number;
-    readonly hasMore: boolean;
-}
 export interface SquareObservation {
     readonly location: string;
     readonly standingCount: number;
     readonly held: boolean;
     readonly now: number;
     readonly participant?: string;
-    readonly automaticDeliveryAvailable: boolean;
 }
 export interface JoinObservation extends SquareObservation {
+    readonly deliveryAvailable: boolean;
     readonly entry?: EntryPresentation;
     /** The receipt succeeded, but optional recent-history/context enrichment was unavailable. */
     readonly enrichmentUnavailable?: true;
@@ -366,19 +324,24 @@ export interface ExpressionObservation extends Pick<SquareObservation, 'standing
     readonly ownActivityCount: number;
     readonly hardCap: number | null;
 }
+export interface ExpressContext {
+    readonly activities: readonly {
+        readonly id: ActivityId;
+        readonly actor: string;
+        readonly preview: string;
+        readonly truncated: boolean;
+    }[];
+    /** Unread activities outside this preview, not a consumption cursor. */
+    readonly remaining: number;
+}
 export interface ExpressObservation extends SquareObservation, ExpressionObservation {
     readonly participant: string;
-    readonly pendingPublic: readonly ArchiveRecord[];
-    readonly sayNumbers: Readonly<Record<number, number>>;
-    readonly perceptions: Readonly<Record<number, Perception>>;
+    readonly context: ExpressContext;
 }
 export interface CatchObservation extends SquareObservation, ExpressionObservation {
+    readonly deliveryAvailable: boolean;
     readonly participant: string;
-    readonly sayNumbers: Readonly<Record<number, number>>;
     readonly presence?: CatchPresence;
-    readonly stop?: CatchStopStatus;
-    readonly waitStarted?: boolean;
-    readonly replaced?: boolean;
     readonly enrichmentUnavailable?: true;
 }
 export interface HistoryContinuation {
@@ -397,17 +360,12 @@ export interface HistoryObservation extends SquareObservation {
 export interface ListenerObservation extends SquareObservation {
     readonly participant: string;
     readonly target: string;
-    readonly requestedTarget: string;
-}
-export interface LifecycleObservation extends SquareObservation {
-    readonly activity: ArchiveRecord;
 }
-export interface StatusObservation extends SquareObservation, PresenceClassification {
+export interface StatusObservation extends Omit<SquareObservation, 'now' | 'held'>, PresenceClassification {
     readonly knownParticipantCount: number;
-    readonly latestActNumber?: number;
     readonly latestPerception?: Perception;
     readonly joins: readonly {
-        readonly activity: ArchiveRecord;
+        readonly activity: Activity;
         readonly rejoined: boolean;
     }[];
     readonly joinCount: number;

package/dist/square-index.d.ts

@@ -1,24 +1,16 @@
 import { type VersionObserver } from './file-changes.js';
-import { type Body } from './model.js';
-/** A rebuildable discovery hint: the body that may have used an artifact and its path.
- * It is deliberately not a participant, generation, ownership, suppression, or evidence row. */
+import { type Owner } from './model.js';
+/** A rebuildable discovery hint: the owner that may have used an artifact and its path. */
 export interface SquareIndexEntry {
     readonly location: string;
-    readonly body: Body;
+    readonly owner: Owner;
 }
 export interface SquareIndexQuery {
-    readonly body?: Body;
-    readonly channel?: string;
-    readonly session?: string;
-    readonly agent?: string;
+    readonly owner?: Owner;
 }
-/** The index is the only host-side Square state. Its path is test/configuration plumbing, not authority. */
 export declare function squareIndexPath(env?: NodeJS.ProcessEnv): string;
-/** Read and verify the disposable index. Paths are canonicalized on access and duplicates collapse. */
 export declare function indexedSquareEntries(query?: SquareIndexQuery, env?: NodeJS.ProcessEnv): Promise<readonly SquareIndexEntry[]>;
 export declare function indexedSquarePaths(query?: SquareIndexQuery, env?: NodeJS.ProcessEnv): Promise<readonly string[]>;
 /** Best-effort discovery only: a busy index skips publication, never queues or delays artifact work. */
-export declare function rememberSquarePath(location: string, body: Body, index: string): Promise<boolean>;
-/** Index loss is tolerated by every caller; this observer is only a wake hint for rediscovery. */
+export declare function rememberSquarePath(location: string, owner: Owner, index: string): Promise<boolean>;
 export declare function observeSquareIndex(env?: NodeJS.ProcessEnv): Promise<VersionObserver<string>>;
-export declare function bodyKey(body: Body): string;