@astrosheep/square 0.3.92 → 0.3.94

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>;