@astrosheep/square 0.3.106 → 0.4.1

package/dist/plugins/opencode-v1/runtime.js

@@ -0,0 +1,152 @@
+import { canonicalPath } from '../../canonical-path.js';
+import { cancelOpenCodeDeliveries, currentOpenCodeGeneration, detachOpenCodeSession, endOpenCodeSession, listOpenCodeSessions, observeOpenCodeContext, observeOpenCodeSessions, publishOpenCodeAddress, receiveOpenCodePending } from '../opencode-shared/delivery.js';
+import { legacyTransport } from './transport.js';
+export async function startReceiver(ctx) {
+    const env = { ...process.env };
+    const directory = await canonicalPath(ctx.directory);
+    const discovery = await observeOpenCodeSessions(env);
+    const lifetime = new AbortController();
+    const receivers = new Map();
+    const terminal = new Set();
+    const interrupting = new Set();
+    const cancellationFailed = new Set();
+    let coordinating = Promise.resolve();
+    const coordinate = (operation) => {
+        coordinating = coordinating.then(() => lifetime.signal.aborted ? undefined : operation()).catch(() => { });
+        return coordinating;
+    };
+    const stop = (id) => {
+        const receiver = receivers.get(id);
+        receiver?.abort.abort();
+        receivers.delete(id);
+        return receiver?.running;
+    };
+    const validate = async (id) => {
+        const result = await ctx.client.session.get({ path: { id }, signal: lifetime.signal }).catch(() => undefined);
+        const info = result?.data;
+        return !result?.error && info?.id === id && info.projectID === ctx.project.id && typeof info.directory === 'string'
+            && await canonicalPath(info.directory) === directory;
+    };
+    const reconcile = async (active) => {
+        const candidates = new Set(await listOpenCodeSessions(env));
+        if (active)
+            candidates.add(active);
+        for (const id of candidates) {
+            if (lifetime.signal.aborted)
+                return;
+            if (interrupting.has(id) || cancellationFailed.has(id))
+                continue;
+            if (terminal.has(id) || !await validate(id) || terminal.has(id)) {
+                const receiver = receivers.get(id);
+                stop(id);
+                if (receiver)
+                    await detachOpenCodeSession(id, receiver.generation, env);
+                continue;
+            }
+            const existing = receivers.get(id);
+            if (existing?.settled === false || interrupting.has(id))
+                continue;
+            const generation = existing?.generation ?? await publishOpenCodeAddress(id, env, lifetime.signal);
+            if (!generation) {
+                stop(id);
+                continue;
+            }
+            if (terminal.has(id) || interrupting.has(id) || lifetime.signal.aborted) {
+                await detachOpenCodeSession(id, generation, env);
+                continue;
+            }
+            const abort = new AbortController();
+            const signal = AbortSignal.any([lifetime.signal, abort.signal]);
+            const receiver = { abort, generation, settled: false, running: receiveOpenCodePending(id, generation, legacyTransport(ctx.client, id, signal), env, signal).catch(() => { }).finally(() => { receiver.settled = true; }) };
+            receivers.set(id, receiver);
+        }
+        for (const id of receivers.keys())
+            if (!candidates.has(id))
+                stop(id);
+    };
+    const loop = (async () => {
+        while (!lifetime.signal.aborted) {
+            const baseline = discovery.observer.generation;
+            await coordinate(() => reconcile());
+            await discovery.observer.hinted(baseline, 2000, lifetime.signal);
+        }
+    })().catch(() => { });
+    let disposal;
+    return {
+        'experimental.chat.messages.transform': async (_input, output) => {
+            const ids = new Set(output.messages.map(message => message.info?.sessionID));
+            if (ids.size !== 1 || typeof [...ids][0] !== 'string')
+                return;
+            const id = [...ids][0];
+            if (terminal.has(id))
+                return;
+            await coordinate(() => reconcile(id));
+            const receiver = receivers.get(id);
+            if (!receiver || terminal.has(id) || lifetime.signal.aborted)
+                return;
+            const messages = output.messages.flatMap(({ info, parts }) => {
+                if (info?.role !== 'user' || !info.id || !parts?.length || !parts.every(part => part.type === 'text'
+                    && typeof part.text === 'string' && part.sessionID === id && part.messageID === info.id && !part.synthetic && !part.ignored))
+                    return [];
+                return [{ id: info.id, role: 'user', content: parts.map(part => ({ type: 'text', text: part.text })) }];
+            });
+            await observeOpenCodeContext(id, receiver.generation, messages, env, AbortSignal.any([lifetime.signal, receiver.abort.signal])).catch(() => { });
+        },
+        event: async ({ event }) => {
+            const interrupted = event.type === 'session.error' && event.properties?.error?.name === 'MessageAbortedError'
+                ? event.properties.sessionID : undefined;
+            if (interrupted) {
+                const receiver = receivers.get(interrupted);
+                if (!receiver || interrupting.has(interrupted))
+                    return;
+                interrupting.add(interrupted);
+                stop(interrupted);
+                await coordinate(async () => {
+                    try {
+                        await receiver.running;
+                        if (!await cancelOpenCodeDeliveries(interrupted, receiver.generation, env))
+                            throw new Error('OpenCode cancellation fence lost');
+                    }
+                    catch (error) {
+                        cancellationFailed.add(interrupted);
+                        await detachOpenCodeSession(interrupted, receiver.generation, env).catch(() => { });
+                        throw error;
+                    }
+                    finally {
+                        interrupting.delete(interrupted);
+                    }
+                    await reconcile(interrupted);
+                });
+                return;
+            }
+            const info = event.properties?.info;
+            if (event.type !== 'session.deleted' || !info?.id || info.projectID !== ctx.project.id || typeof info.directory !== 'string'
+                || await canonicalPath(info.directory).catch(() => undefined) !== directory)
+                return;
+            const id = info.id;
+            terminal.add(id);
+            const receiver = receivers.get(id);
+            stop(id);
+            await coordinate(async () => {
+                const generation = receiver?.generation ?? await currentOpenCodeGeneration(id, env);
+                if (generation)
+                    await endOpenCodeSession(id, generation, env);
+            });
+        },
+        dispose: () => disposal ??= (async () => {
+            lifetime.abort();
+            const captured = [...receivers.entries()];
+            const tasks = [loop, coordinating, ...captured.map(([id]) => stop(id))];
+            let timer;
+            try {
+                await Promise.race([Promise.allSettled(tasks), new Promise(resolve => { timer = setTimeout(resolve, 3000); })]);
+            }
+            finally {
+                if (timer !== undefined)
+                    clearTimeout(timer);
+            }
+            await Promise.allSettled(captured.map(([id, receiver]) => detachOpenCodeSession(id, receiver.generation, env)));
+            await discovery.close();
+        })(),
+    };
+}

package/dist/plugins/opencode-v1/transport.d.ts

@@ -0,0 +1,13 @@
+import type { DeliveryTransport } from '../../delivery-ledger.js';
+type Client = {
+    session: {
+        promptAsync(input: unknown): Promise<{
+            error?: unknown;
+            response?: Response;
+        }>;
+    };
+};
+/** OpenCode's 48-bit timestamp/counter prefix followed by 14 random base62 digits. */
+export declare function nativeMessageId(): string;
+export declare function legacyTransport(client: Client, sessionId: string, lifetime: AbortSignal): DeliveryTransport;
+export {};

package/dist/plugins/opencode-v1/transport.js

@@ -0,0 +1,50 @@
+import { randomInt, createHash } from 'node:crypto';
+import { renderDeliveryReminder } from '../../delivery-frame.js';
+let lastTime = 0, counter = 0;
+const alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+/** OpenCode's 48-bit timestamp/counter prefix followed by 14 random base62 digits. */
+export function nativeMessageId() {
+    const now = Math.max(Date.now(), lastTime);
+    counter = now === lastTime ? counter + 1 : 0;
+    if (counter >= 0x1000) {
+        lastTime = now + 1;
+        counter = 0;
+    }
+    else
+        lastTime = now;
+    const prefix = (BigInt(lastTime) * 0x1000n + BigInt(counter)).toString(16).slice(-12).padStart(12, '0');
+    return `msg_${prefix}${Array.from({ length: 14 }, () => alphabet[randomInt(62)]).join('')}`;
+}
+export function legacyTransport(client, sessionId, lifetime) {
+    return {
+        kind: 'opencode-server',
+        async send(card, address, context) {
+            const signal = AbortSignal.any([lifetime, context.signal]);
+            if (address.sessionId !== sessionId || signal.aborted)
+                return 'not-capable';
+            const messageId = nativeMessageId();
+            const text = renderDeliveryReminder([card.text], { tagged: true });
+            const payloadHash = createHash('sha256').update(text).digest('hex');
+            if (!await context.prepare({ token: context.token, messageId, payloadHash }) || signal.aborted
+                || !await context.beforeSend() || signal.aborted || Date.now() >= context.deadline)
+                return 'not-capable';
+            let onAbort;
+            try {
+                await Promise.race([
+                    client.session.promptAsync({ path: { id: sessionId }, body: { messageID: messageId, parts: [{ type: 'text', text }] }, signal }),
+                    new Promise((_, reject) => { onAbort = () => reject(signal.reason); signal.addEventListener('abort', onAbort, { once: true }); if (signal.aborted)
+                        onAbort(); }),
+                ]);
+                // promptAsync acknowledges only submission, not native acceptance or presentation.
+                return 'unknown';
+            }
+            catch {
+                return 'unknown';
+            }
+            finally {
+                if (onAbort)
+                    signal.removeEventListener('abort', onAbort);
+            }
+        },
+    };
+}

package/dist/plugins/paseo/shared/card-presentation.d.ts

@@ -0,0 +1,10 @@
+/** Producer-neutral display facts; independent of model-facing delivery text. */
+export type CardPresentation = {
+    readonly kind: 'presentation';
+    readonly origin: string;
+    readonly author?: string;
+    readonly ref?: string;
+    readonly badge?: string;
+    readonly body: string;
+};
+export declare function isCardPresentation(value: unknown): value is CardPresentation;

package/dist/plugins/paseo/shared/card-presentation.js

@@ -0,0 +1,7 @@
+export function isCardPresentation(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const item = value;
+    return item.kind === 'presentation' && typeof item.origin === 'string' && typeof item.body === 'string'
+        && ['author', 'ref', 'badge'].every(key => item[key] === undefined || typeof item[key] === 'string');
+}

package/dist/ports.d.ts

@@ -1,7 +1,9 @@
-import type { Act, ActivityId, Owner, HardCap, Seat, StoredAct, WakeAddress, WakeRoute, WatchLease } from './model.js';
-import type { AttemptOutcome } from './delivery-attempts.js';
-import type { MetadataMatch, DeliveryDeferralFact } from './delivery-deferral.js';
+import type { ActDraft, HydratedAct, Owner, HardCap, Seat, StoredAct, WakeAddress, WatchLease, DirectedNotificationRoute } from './model.js';
 import type { ActivitySearch } from './square-facade.js';
+import type { IndexPage, FactPage } from './neutral.js';
+import type { MetadataMatch } from './delivery-deferral.js';
+import type { ProducerRead, ProducerWrite } from './square-post.js';
+export type { IndexPage, FactPage } from './neutral.js';
 export type ActivityIndex = number;
 export interface SquareHeader {
     readonly revision: number;
@@ -50,20 +52,12 @@ export interface ActivityFilter {
     readonly actors?: readonly string[];
     readonly actorMatch?: 'identity' | 'exact';
     readonly afterAt?: number;
-    /** Shared query predicates, applied before paging or counting. */
     readonly metadataMatch?: MetadataMatch;
     readonly search?: ActivitySearch;
 }
-export interface IndexPage {
-    readonly edge: 'oldest' | 'newest';
-    readonly limit: number;
-}
-export interface FactPage<T> {
-    readonly items: readonly T[];
-    readonly hasMore: boolean;
-}
 export interface DirectedFilter extends Omit<ActivityFilter, 'actors' | 'actorMatch'> {
     readonly unseenOnly?: true;
+    readonly currentGeneration?: true;
     readonly senders?: readonly string[];
     readonly attentionOnly?: true;
 }
@@ -72,18 +66,21 @@ export interface DirectedHead {
     readonly at: number;
     readonly actor: string;
     readonly recipient: string;
-    readonly route: import('./attention.js').AudienceRoute;
+    readonly route: DirectedNotificationRoute;
+    readonly generation?: string;
+}
+export interface LandedRecipient {
+    readonly recipient: string;
+    readonly route: DirectedNotificationRoute;
+    readonly generation?: string;
+    readonly owner?: Owner;
 }
-export type LandedRecipient = import('./attention.js').AudienceRecipient;
 export interface ReceiptFacts {
     readonly latestAt?: number;
     readonly latestActorActivityIndex?: number;
 }
 export type SeatRef = Pick<Seat, 'participant' | 'owner' | 'generation'>;
 export type ArtifactWriteAuthority = {
-    readonly kind: 'send';
-    readonly actor: string;
-} | {
     readonly kind: 'participant';
     readonly seat: SeatRef;
 } | {
@@ -98,88 +95,27 @@ export type ArtifactWriteAuthority = {
     readonly kind: 'takeover';
     readonly participant: string;
     readonly owner: Owner;
-    readonly expectedGeneration: ActivityId;
+    readonly expectedGeneration: string;
     readonly wakeAddress?: WakeAddress;
-};
-export interface DeliveryEvidence {
-    readonly participant: string;
-    readonly generation: ActivityId;
-    readonly activity: ActivityId;
-    readonly kind: 'wake' | 'presentation';
-    readonly outcome: AttemptOutcome;
-    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';
-    /** Observe an existing wake's exact token; never authorizes another content injection. */
-    readonly observationOf?: string;
-    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' | 'deferred';
-    readonly evidence?: DeliveryEvidence;
+    readonly kind: 'producer';
+} | {
+    readonly kind: 'send';
+    readonly actor: string;
 };
-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;
+/** All callbacks are synchronous and their facts cannot escape the transaction. */
+export interface SquareRead extends ProducerRead {
+    seat(name: string): Seat | undefined;
     seatsForOwner(owner: Owner): 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;
+    participant(name: string): ParticipantFact | undefined;
     participantCounts(): ParticipantCounts;
     roster(): readonly ParticipantFact[];
     attention(listener: string): readonly AttentionFact[];
     incomingAttention(sender: string): readonly AttentionFact[];
     activity(index: ActivityIndex): StoredAct | undefined;
     activityHeads(filter: ActivityFilter, page: IndexPage): FactPage<ActivityHead>;
-    activities(indexes: readonly ActivityIndex[]): readonly StoredAct[];
+    activities(indexes: readonly ActivityIndex[]): readonly HydratedAct[];
     activityCount(filter: ActivityFilter): number;
     contextIndexes(centers: readonly ActivityIndex[], before: number, after: number): readonly ActivityIndex[];
     sayOrdinals(indexes: readonly ActivityIndex[]): Readonly<Record<number, number>>;
@@ -188,46 +124,18 @@ export interface SquareRead {
     directed(recipient: string, filter: DirectedFilter, page: IndexPage): FactPage<DirectedHead>;
     directedAt(recipient: string, index: ActivityIndex): DirectedHead | undefined;
     directedCount(recipient: string, filter: DirectedFilter): number;
-    pendingAudience(afterExclusive: number, throughInclusive: number, activityLimit: number): {
-        readonly groups: readonly {
-            readonly index: ActivityIndex;
-            readonly at: number;
-            readonly actor: string;
-            readonly recipients: readonly LandedRecipient[];
-        }[];
-        readonly hasMore: boolean;
-    };
-    receipt(requestedName: string, index: ActivityIndex): {
+    receipt(name: string, index: ActivityIndex): {
         readonly at: number;
     } | undefined;
-    receiptFacts(requestedName: string, afterIndex: number): ReceiptFacts;
-    lease(requestedName: string): WatchLease | undefined;
-    deliveryDeferrals(participant: string, generation: ActivityId): readonly DeliveryDeferralFact[];
+    receiptFacts(name: string, afterIndex: number): ReceiptFacts;
+    lease(name: string): WatchLease | undefined;
 }
-export interface SquareWrite extends SquareRead {
-    land(activity: Act & {
-        readonly at: number;
-    }): StoredAct;
-    updateWakeAddress(seat: SeatRef, wakeAddress?: WakeAddress): boolean;
-    /** Join authority only; preserves membership and its establishing generation. */
-    reattachSeat(seat: SeatRef, wakeAddress?: WakeAddress): boolean;
-    /** Host-cleanup authority only; stale/already-detached coordinates are a no-op. */
-    detachSeat(seat: SeatRef): 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, generation?: ActivityId): boolean;
-    removeLease(requestedName: string, expectedLeaseId: string, generation?: ActivityId): boolean;
-    putDeliveryDeferral(seat: SeatRef, id: string, match: MetadataMatch, expiresAt: number, now: number): boolean;
-    renewDeliveryDeferral(seat: SeatRef, id: string, expiresAt: number, now: number): boolean;
-    releaseDeliveryDeferral(seat: SeatRef, id: string, now: number): boolean;
+export interface SquareWrite extends SquareRead, ProducerWrite {
+    land(draft: ActDraft): StoredAct;
+    putLease(name: string, lease: WatchLease, generation?: string): boolean;
+    removeLease(name: string, expectedLeaseId: string, generation?: string): boolean;
+    markSeen(recipient: string, indexes: readonly number[], at: number): number;
+    setSeatAttachment(seat: SeatRef, attachment: 'attached' | 'detached'): boolean;
 }
 export interface SquareReadResult<R> {
     readonly value: R;
@@ -236,105 +144,16 @@ export interface SquareReadResult<R> {
 export interface SquareCommitResult<R> extends SquareReadResult<R> {
     readonly changed: boolean;
 }
-/** Atomic artifact access; no framing, SQL or lazy transaction capability escapes. */
 export interface SquareArtifactPort {
     read<R>(select: (facts: SquareRead) => R, signal?: AbortSignal): Promise<SquareReadResult<R>>;
-    /** Participant/domain writes must carry an explicit owner; no owner-less mutation path exists. */
     transactAs<R>(authority: ArtifactWriteAuthority, change: (facts: SquareWrite) => R, signal?: AbortSignal): Promise<SquareCommitResult<R>>;
-    /** Bounded cleanup/evidence settlement on this same connection after custody was acquired.
-     * Independent of request/lifetime cancellation; explicit close and authority fences still apply. */
     settleAs<R>(authority: ArtifactWriteAuthority, change: (facts: SquareWrite) => R): 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>;
 }
-/** Explicit lifetime for an artifact connection reused by a long-lived caller.
- * Only the connection is shared: every open still derives its own environment,
- * clock, ledger and transport, and no request signal becomes a connection lifetime.
- * The owner holds one location and refuses a second rather than sharing the wrong
- * square; the caller lends the connection and never closes it. */
 export interface SquareResourceOwner {
-    /** The shared connection for a location. Never close it; the owner does. */
     artifact(location: string): SquareArtifactPort;
     close(): Promise<void>;
 }
-/** 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>;
-}
-export interface WakeRequest {
-    readonly location: string;
-    readonly participant: string;
-    readonly activity: string;
-    readonly actor: string;
-    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>;
-}
-export type WakeOutcome = {
-    readonly outcome: 'accepted';
-    readonly signature?: string;
-} | {
-    readonly outcome: 'failed';
-    readonly message?: string;
-    readonly signature?: string;
-    readonly diagnostic?: unknown;
-} | {
-    readonly outcome: 'not-capable';
-    readonly diagnostic?: string;
-} | {
-    readonly outcome: 'unknown';
-    readonly signature?: string;
-    readonly message?: string;
-    readonly diagnostic?: unknown;
-};
-export interface DeliverPendingInput {
-    readonly artifact: SquareArtifactPort;
-    readonly transport: WakeTransportPort;
-    readonly location: string;
-    readonly timeoutMs?: number;
-    readonly now?: number;
-    readonly activity?: string | number;
-}
-export interface PresentationResult {
-    readonly presented: boolean;
-    readonly activity?: StoredAct;
-}
-export interface PresentPendingInput {
-    readonly artifact: SquareArtifactPort;
-    readonly location: string;
-    readonly participant: string;
-    readonly activity: string | number;
-    readonly sink: PresentationSinkPort;
-    /** Existing wake observed by a native receiver; the sink must not inject content. */
-    readonly observationOf?: string;
-    /** Captured artifact seat; used to fence both presentation and consumption. */
-    readonly seat?: SeatRef;
-    readonly generation?: ActivityId;
-    readonly now?: number;
-    readonly timeoutMs?: number;
-    /** Pre-effect work control only; successful sink evidence settles independently, with a bounded lifetime. */
-    readonly signal?: AbortSignal;
-    /** Boundary previews that were clipped remain pending for a later full presentation. */
-    readonly markSeen?: boolean;
-    /** Receiver-specific pre-effect eligibility, never a veto of an already successful sink. */
-    readonly current?: (facts: SquareRead) => boolean;
-}

package/dist/presentation.d.ts

@@ -1,4 +1,4 @@
-import { type StoredAct, type RoomChangeAct } from './model.js';
+import { type HydratedAct, 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';
@@ -72,19 +72,19 @@ interface RenderedEvent {
     /** The rendered body was cut short by `preview`. */
     bodyClipped: boolean;
 }
-export declare function renderEventCli(event: StoredAct | Activity, opts?: {
+export declare function renderEventCli(event: HydratedAct | Activity, opts?: {
     now?: number;
     preview?: number;
     mention?: string;
 }): string;
-export declare function renderAmbientEventFacts(event: StoredAct | Activity, viewer: string, opts?: {
+export declare function renderAmbientEventFacts(event: HydratedAct | Activity, viewer: string, opts?: {
     now?: number;
     preview?: number;
     presencePreview?: number;
     mention?: string;
     perception?: Perception;
 }): RenderedEvent;
-export declare function renderAmbientEvent(event: StoredAct | Activity, viewer: string, opts?: {
+export declare function renderAmbientEvent(event: HydratedAct | Activity, viewer: string, opts?: {
     now?: number;
     preview?: number;
     presencePreview?: number;
@@ -101,7 +101,7 @@ export declare function renderActivityUncertain(opts: ParticipantOutputOptions &
 export declare function renderExpressWaiting(opts: ExpressWaitingOptions): string;
 export declare function renderExpressNoWait(opts: ExpressNoWaitOptions): string;
 export declare function renderPresenceAnchor(names: readonly string[]): string;
-export declare function renderGrepActivitiesView(visible: readonly StoredAct[], totalMatches: number, noTruncate: boolean | undefined, squarePath: string, pattern: string, fixed?: boolean, perception?: (act: StoredAct) => Perception): string;
+export declare function renderGrepActivitiesView(visible: readonly HydratedAct[], totalMatches: number, noTruncate: boolean | undefined, squarePath: string, pattern: string, fixed?: boolean, perception?: (act: HydratedAct) => Perception): string;
 export declare function renderActivityLimit(opts: ActivityLimitOptions): string;
 export declare function renderWatchAlreadyActive(opts: ParticipantOutputOptions): string;
 export declare function renderWatchForceTakeover(_opts: ParticipantOutputOptions): string;

package/dist/presentation.js

@@ -177,6 +177,7 @@ function renderEventCliFacts(event, opts = {}) {
                 bodyClipped: body.clipped,
             };
         }
+        case 'say':
         case 'read':
             return { text: '', bodyClipped: false };
     }

package/dist/runtime.js

@@ -30,7 +30,7 @@ export function watchTerminalStatus(facts, name) {
 /** A continuous prefix stops at the first unseen historical audience edge after join. */
 export function readCursor(facts, name) {
     const boundary = facts.participant(name)?.lastJoinIndex ?? -1;
-    const block = facts.directed(name, { afterIndex: boundary, unseenOnly: true }, { edge: 'oldest', limit: 1 }).items[0]?.index;
+    const block = facts.directed(name, { kinds: ['say'], afterIndex: boundary, unseenOnly: true }, { edge: 'oldest', limit: 1 }).items[0]?.index;
     const last = facts.activityHeads({
         afterIndex: boundary, ...(block === undefined ? {} : { beforeIndex: block }),
         kinds: ['join', 'done', 'say', 'listen', 'ignore', 'unlisten'],
@@ -42,7 +42,7 @@ export function presenceAnchor(facts, name) {
     const boundary = facts.participant(name)?.lastJoinIndex ?? -1;
     if (boundary < 0)
         return -1;
-    const own = facts.activityHeads({ afterIndex: boundary, actors: [name] }, { edge: 'newest', limit: 1 }).items[0]?.index;
+    const own = facts.activityHeads({ afterIndex: boundary, actors: [name], kinds: ['join', 'done', 'say', 'read', 'listen', 'ignore', 'unlisten'] }, { edge: 'newest', limit: 1 }).items[0]?.index;
     const evidence = Math.max(boundary, own ?? boundary, facts.receiptFacts(name, boundary).latestActorActivityIndex ?? boundary);
     return facts.activityHeads({ afterIndex: boundary, throughIndex: evidence, kinds: ['say', 'done'] }, { edge: 'newest', limit: 1 }).items[0]?.index ?? -1;
 }

package/dist/search.js

@@ -1,7 +1,7 @@
 // Shared case-insensitive search semantics for storage filtering and presentation.
 // Regex mode intentionally uses JavaScript's built-in engine, without a ReDoS
 // timeout. Callers should use literal mode for plain text and avoid untrusted regexes.
-import { SquareError } from './model.js';
+import { SquareError } from './neutral.js';
 export function compileSearchPattern(pattern, fixed) {
     if (fixed)
         return new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i');

package/dist/session-lifecycle.d.ts

@@ -1,7 +1,8 @@
-import { type Owner } from './owner.js';
-import type { AutomaticProvider } from './participant-identity.js';
-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>;
+import { type DeliveryRoute, type DeliverySession } from './delivery-ledger.js';
+import type { Owner } from './owner.js';
+/** Rotate the captured session generation; omitted routes retain its registrations. */
+export declare function attachDeliverySession(owner: Owner, env?: NodeJS.ProcessEnv, routes?: readonly DeliveryRoute[], signal?: AbortSignal): Promise<DeliverySession | false>;
+/** Replace the supplied route kinds while preserving every other registered route. */
+export declare function attachDeliverySessionRoutes(owner: Owner, env: NodeJS.ProcessEnv | undefined, routes: readonly DeliveryRoute[], signal?: AbortSignal): Promise<DeliverySession | false>;
+export declare function detachDeliverySession(owner: Owner, generation: string, env?: NodeJS.ProcessEnv): Promise<boolean>;
+export declare function markDeliverySessionDeleted(owner: Owner, generation: string, env?: NodeJS.ProcessEnv): Promise<boolean>;