@astrosheep/square 0.3.93 → 0.3.95

package/dist/cli/square-commands.js

@@ -1,9 +1,10 @@
 import { formatHardCap } from '../model.js';
 import { commandPrefix, participantCommandPrefix, withPathOutput, } from '../presentation.js';
 import { renderJoinResult, renderLifecycleResult, renderListenerChange, renderListeningResult, } from '../operation-presentation.js';
-import { Square } from '../square-api.js';
+import { Square, requireOwner, requireJoinName, selectOwnSeat } from '../square-api.js';
 import { executeExpression } from './express-presentation.js';
-import { squareInput, withSquare, fail, parseBoundedLimit, parseHardCap, parsePositiveInteger, readStdin, requireSquarePath, requireValue, resolveBody, usage, } from './context.js';
+import { jsonResult } from './json.js';
+import { squareInput, withSquare, fail, parseBoundedLimit, parseHardCap, parsePositiveInteger, readStdin, requireSquarePath, requireValue, resolveBody, usage, commandIdentity, } from './context.js';
 const JOIN_DEFAULT_LAST = 10;
 const JOIN_MAX_LAST = 100;
 export const buildCommand = {
@@ -53,7 +54,7 @@ export const buildCommand = {
         const cap = data.hardCap === null ? 'unlimited' : formatHardCap(data.hardCap);
         const throttle = data.throttlePerMinute === undefined ? [] : [`  · throttle ${data.throttlePerMinute}/min`];
         return withPathOutput(square.location, ['· the square stands ready', `  · cap ${cap}`, ...throttle].join('\n'), {
-            participantCount: 0, held: false,
+            participantCount: 0,
         });
     },
     present: (result) => process.stdout.write(result),
@@ -69,14 +70,17 @@ export const joinCommand = {
             }
             else if (argv[index] === '--kick')
                 kick = true;
-            else
+            else if (argv[index] !== '--json')
                 usage(context.command);
         }
         return { lastN, kick };
     },
     async execute(intent, context) {
-        const data = await withSquare(context, (square) => square.join(context.name, { takeover: intent.kick, last: intent.lastN, observe: true }));
-        return renderJoinResult(data);
+        const { owner, wakeAddress } = commandIdentity(context.env, context.owner);
+        const data = await withSquare(context, (square) => square.join(requireJoinName(context.name), {
+            owner: requireOwner(owner), wakeAddress, takeover: intent.kick, last: intent.lastN, ...(context.json ? {} : { observe: true }),
+        }));
+        return context.json ? jsonResult(data) : renderJoinResult(data, context.owner ?? context.env.SQUARE_OWNER);
     },
     present: (result) => process.stdout.write(result),
 };
@@ -92,6 +96,8 @@ function parseActivity(argv, context) {
     const bodyArgs = [];
     for (let index = 0; index < argv.length; index++) {
         const argument = argv[index];
+        if (argument === '--json')
+            continue;
         if (argument === '-f' || argument === '--force')
             force = true;
         else if (argument === '--no-wait')
@@ -141,23 +147,25 @@ export const expressCommand = {
         await executeExpression((control) => Square.at(squareInput(context), control), requireSquarePath(context), context.name, rawInput, {
             force: intent.force, noWait: intent.noWait, noMention: intent.noMention,
             mentions: intent.mentions, reach: intent.reach, reply: intent.reply, metadata: intent.metadata,
+            recoveryOwner: context.owner ?? context.env.SQUARE_OWNER,
             metadataJson: intent.metadataJson, bodyProvided: intent.activity !== undefined,
-        });
+        }, context.json, () => commandIdentity(context.env, context.owner).owner);
     },
     present: () => { },
 };
 function parseListener(argv, context, targetRequired) {
-    if (targetRequired ? argv.length !== 1 : argv.length !== 0)
+    const args = argv.filter((arg) => arg !== '--json');
+    if (targetRequired ? args.length !== 1 : args.length !== 0)
         usage(context.command);
-    return targetRequired ? { target: argv[0] } : {};
+    return targetRequired ? { target: args[0] } : {};
 }
 function listenerCommand(verb) {
     return {
         parse(argv, context) { return parseListener(argv, context, true); },
         async execute(intent, context) {
             const squarePath = requireSquarePath(context);
-            const data = await withSquare(context, async (square) => (await square.participant(context.name))[verb](intent.target, { observe: true }));
-            return renderListenerChange(squarePath, verb, data);
+            const data = await withSquare(context, async (square) => (await selectOwnSeat(square, commandIdentity(context.env, context.owner).owner, context.name))[verb](intent.target, context.json ? {} : { observe: true }));
+            return context.json ? jsonResult(data) : renderListenerChange(squarePath, verb, data);
         },
         present: (result) => process.stdout.write(result),
     };
@@ -169,50 +177,28 @@ export const listeningCommand = {
     parse(argv, context) { return parseListener(argv, context, false); },
     async execute(_intent, context) {
         const squarePath = requireSquarePath(context);
-        const data = await withSquare(context, async (square) => (await square.participant(context.name)).listening({ observe: true }));
-        return renderListeningResult(squarePath, data);
+        const data = await withSquare(context, async (square) => (await selectOwnSeat(square, commandIdentity(context.env, context.owner).owner, context.name)).listening(context.json ? {} : { observe: true }));
+        return context.json ? jsonResult(data) : renderListeningResult(squarePath, data);
     },
     present: (result) => process.stdout.write(result),
 };
 export const doneCommand = {
     parse(argv, context) {
-        if (argv.length > 1)
+        const args = argv.filter((arg) => arg !== '--json');
+        if (args.length > 1)
             usage(context.command);
-        return { body: argv[0] };
+        return { body: args[0] };
     },
     async execute(intent, context) {
         const body = intent.body === '-' || ((intent.body === undefined || intent.body === '') && !process.stdin.isTTY)
             ? await readStdin() : intent.body;
         const squarePath = requireSquarePath(context);
-        const data = await withSquare(context, async (square) => (await square.participant(context.name)).done(body, { observe: true }));
-        return renderLifecycleResult(squarePath, 'done', data);
-    },
-    present: (result) => process.stdout.write(result),
-};
-export const holdCommand = {
-    parse(argv, context) {
-        if (argv.length > 1)
-            usage(context.command);
-        return { body: argv[0] };
-    },
-    async execute(intent, context) {
-        const body = (await resolveBody(intent.body ?? '')).replace(/\r\n/g, '\n').trim();
-        const squarePath = requireSquarePath(context);
-        const result = await withSquare(context, async (square) => (await square.participant(context.name)).hold(body, { observe: true }));
-        return renderLifecycleResult(squarePath, 'hold', result);
-    },
-    present: (result) => process.stdout.write(result),
-};
-export const resumeCommand = {
-    parse(argv, context) {
-        if (argv.length !== 0)
-            usage(context.command);
-        return {};
-    },
-    async execute(_intent, context) {
-        const squarePath = requireSquarePath(context);
-        const result = await withSquare(context, async (square) => (await square.participant(context.name)).resume({ observe: true }));
-        return renderLifecycleResult(squarePath, 'resume', result);
+        const result = await withSquare(context, async (square) => {
+            const participant = await selectOwnSeat(square, commandIdentity(context.env, context.owner).owner, context.name);
+            const options = context.json ? {} : { observe: true };
+            return participant.done(body, options);
+        });
+        return context.json ? jsonResult(result) : renderLifecycleResult(squarePath, result);
     },
     present: (result) => process.stdout.write(result),
 };

package/dist/codex-hook.d.ts

@@ -1,4 +1,5 @@
-import type { Body, PendingMembership } from './model.js';
+import { type Owner } from './owner.js';
+import type { PendingMembership } from './model.js';
 import type { WakeTransports } from './notifications.js';
 export interface CodexHookInput {
     session_id?: unknown;
@@ -8,6 +9,6 @@ export interface CodexHookInput {
 }
 export type HookTrace = (line: string) => void;
 export declare const CODEX_HOOK_BUDGET_MS = 4500;
-export declare function codexHookResponse(input: CodexHookInput, lookup?: (identity: Body, env?: NodeJS.ProcessEnv, signal?: AbortSignal) => Promise<PendingMembership[]> | PendingMembership[], env?: NodeJS.ProcessEnv, deliveryTransports?: WakeTransports, trace?: HookTrace): Promise<object | undefined>;
+export declare function codexHookResponse(input: CodexHookInput, lookup?: (identity: Owner, env?: NodeJS.ProcessEnv, signal?: AbortSignal) => Promise<PendingMembership[]> | PendingMembership[], env?: NodeJS.ProcessEnv, deliveryTransports?: WakeTransports, trace?: HookTrace): Promise<object | undefined>;
 export declare function runCodexHook(inputText: string, env?: NodeJS.ProcessEnv): Promise<string>;
 export declare const runCodexHookAsync: typeof runCodexHook;

package/dist/codex-hook.js

@@ -1,8 +1,10 @@
 import { handleCodexHook } from './packages/agent-delivery/src/codex-hook.js';
 import { presentPendingAtBoundary } from './boundary-presentation.js';
 import { sessionInbox } from './inbox.js';
-import { endSessionMemberships } from './session-lifecycle.js';
+import { harnessOwner } from './owner.js';
+import { detachSessionSeats, restoreSessionSeats } from './session-lifecycle.js';
 import { codexBoundaryStore } from './codex-boundary-state.js';
+import { codexWakeAddress } from './codex-address.js';
 import { PRIVILEGED_HOOK_BUDGET_MS, sweepPrivilegedPending } from './notifications.js';
 export const CODEX_HOOK_BUDGET_MS = 4500;
 const defaultTrace = (line) => { process.stderr.write(`${line}\n`); };
@@ -10,13 +12,20 @@ export async function codexHookResponse(input, lookup = sessionInbox, env = proc
     const configured = Number(env.SQUARE_CODEX_HOOK_BUDGET_MS ?? CODEX_HOOK_BUDGET_MS);
     const startedAt = Date.now();
     let mark = startedAt;
+    const timeoutMs = Number.isFinite(configured) && configured > 0 ? configured : CODEX_HOOK_BUDGET_MS;
+    const signal = AbortSignal.timeout(timeoutMs);
+    if ((input.hook_event_name === 'SessionStart' || input.hook_event_name === 'SessionResume')
+        && typeof input.session_id === 'string' && input.session_id.trim()) {
+        await restoreSessionSeats(harnessOwner({ channel: 'codex', session: input.session_id }), env, codexWakeAddress(input.session_id, env), signal);
+    }
     return handleCodexHook(input, {
         boundaries: codexBoundaryStore(env),
-        timeoutMs: Number.isFinite(configured) && configured > 0 ? configured : CODEX_HOOK_BUDGET_MS,
+        timeoutMs,
+        signal,
         sweepTimeoutMs: PRIVILEGED_HOOK_BUDGET_MS,
-        pull: (id, signal) => presentPendingAtBoundary({ channel: 'codex', session: id }, (context) => context, lookup, env, signal),
+        pull: (id, signal) => presentPendingAtBoundary(harnessOwner({ channel: 'codex', session: id }), (context) => context, lookup, env, signal),
         sweep: (cwd, deadline, signal) => sweepPrivilegedPending(cwd ?? process.cwd(), env, deliveryTransports, deadline, signal),
-        end: async (id) => { await endSessionMemberships('codex', id, env); },
+        end: async (id) => { await detachSessionSeats('codex', id, env); },
         trace: (name, detail = '') => {
             const now = Date.now();
             const durationMs = now - mark;

package/dist/codex-queue.js

@@ -12,7 +12,7 @@ export class CodexQueueTransport {
         const { address } = request.route;
         const threadId = address.threadId?.trim();
         if (!threadId) {
-            return { outcome: 'failed', unavailable: true, signature: 'invalid_address', message: 'Codex route has no thread id.', routeStale: true };
+            return { outcome: 'failed', signature: 'invalid_address', message: 'Codex route has no thread id.' };
         }
         const env = this.opts.env ?? process.env;
         const payload = request.artifact === undefined ? undefined
@@ -28,15 +28,15 @@ export class CodexQueueTransport {
             });
             const remaining = deadline - Date.now();
             if (remaining <= 0) {
-                return { outcome: 'failed', unavailable: true, signature: 'dispatch_budget_exhausted', message: 'The wake dispatch budget elapsed before queueing.', retainRoute: true };
+                return { outcome: 'failed', signature: 'dispatch_budget_exhausted', message: 'The wake dispatch budget elapsed before queueing.' };
             }
             await agent.queue(payload, { timeoutMs: remaining });
             return { outcome: 'accepted' };
         }
         catch (error) {
             if (error instanceof DeliveryError && error.code === 'session_inactive') {
-                return { outcome: 'failed', unavailable: true, signature: 'boundary_not_stopped',
-                    message: 'The Codex thread has no current Stop boundary for queueing.', retainRoute: true };
+                return { outcome: 'failed', signature: 'boundary_not_stopped',
+                    message: 'The Codex thread has no current Stop boundary for queueing.' };
             }
             const message = error instanceof Error ? error.message : String(error);
             if (!(error instanceof DeliveryError) || error.maybeDelivered)

package/dist/decisions.d.ts

@@ -5,21 +5,14 @@ type TimedAct<K extends Act['kind'] = Act['kind']> = Extract<Act, {
 }> & {
     at: number;
 };
-import type { ExpressResult, ParticipantSummary as ParticipantStatus, UnreadActivitySummary } from './square-facade.js';
-export type { ParticipantSummary as ParticipantStatus, ParticipantPresence as CorePresenceState, UnreadActivitySummary, UnreadActivityPreview } from './square-facade.js';
+import type { ExpressResult, ParticipantSummary, UnreadActivitySummary } from './square-facade.js';
 export declare function resolveKnownName(facts: SquareRead, name: string): string;
 export interface DecideJoinResult {
     joinedName: string;
     addParticipant: boolean;
     joinAct?: TimedAct<'join'>;
 }
-export interface DecideImplicitJoinResult {
-    joinedName: string;
-    state: 'joined' | 'active' | 'done';
-    joinAct?: TimedAct<'join'>;
-}
 export declare function decideJoin(facts: SquareRead, name: string, now: number): DecideJoinResult;
-export declare function decideImplicitJoin(facts: SquareRead, name: string, now: number): DecideImplicitJoinResult;
 export type ActDecision = ({
     type: 'sent';
     act: TimedAct;
@@ -33,14 +26,11 @@ export type ActDecision = ({
 } | {
     type: 'throttled';
     delayMs: number;
-} | {
-    type: 'held';
-    reason: string | undefined;
 } | {
     type: 'bell_quota';
     nextAt: number;
 };
-/** Count the directed suffix, but hydrate only its last three previews per spelling. */
+/** Count the directed suffix and hydrate only its last activity by index per spelling. */
 export declare function unreadActivitySummaries(facts: SquareRead, name: string, now: number): UnreadActivitySummary[];
 export declare function decideAct(facts: SquareRead, input: {
     name: string;
@@ -59,7 +49,6 @@ export declare function coreListen(facts: SquareRead, actor: string, target: str
 export declare function coreIgnore(facts: SquareRead, actor: string, target: string, now: number): TimedAct<"listen" | "ignore" | "unlisten"> | undefined;
 export declare function coreUnlisten(facts: SquareRead, actor: string, target: string, now: number): TimedAct<"listen" | "ignore" | "unlisten"> | undefined;
 export declare function coreListening(facts: SquareRead, actor: string): readonly string[];
-export declare function coreHold(facts: SquareRead, actor: string, body: string, now: number): TimedAct<'hold'>;
-export declare function coreResume(facts: SquareRead, actor: string, now: number): TimedAct<'resume'>;
-export declare function compareParticipantActivity(a: Pick<ParticipantStatus, 'name' | 'lastActiveAt'>, b: Pick<ParticipantStatus, 'name' | 'lastActiveAt'>): number;
-export declare function coreParticipants(facts: SquareRead, now: number): ParticipantStatus[];
+export declare function compareParticipantActivity(a: Pick<ParticipantSummary, 'name' | 'lastActiveAt'>, b: Pick<ParticipantSummary, 'name' | 'lastActiveAt'>): number;
+export declare function coreParticipants(facts: SquareRead, now: number): ParticipantSummary[];
+export {};

package/dist/decisions.js

@@ -1,4 +1,4 @@
-import { SquareError, isSquareError, sameName, nameKey, validateName, validateActivityMetadata, activityMetadataHasContent, } from './model.js';
+import { SquareError, isSquareError, sameName, validateName, validateActivityMetadata, activityMetadataHasContent, } from './model.js';
 import { participantIdentity } from './participant-identity.js';
 import { UNREAD_BLOCK_GRACE_MS, freshWatchLease, readCursor, FACT_PAGE_SIZE, THROTTLE_WINDOW_MS } from './runtime.js';
 import { formatActivityId, MAX_IDENTITY_SET_SIZE } from './square-core.js';
@@ -17,12 +17,6 @@ export function decideJoin(facts, name, now) {
     return current?.joined ? { joinedName, addParticipant: false }
         : { joinedName, addParticipant: current === undefined, joinAct: { kind: 'join', actor: joinedName, at: now } };
 }
-export function decideImplicitJoin(facts, name, now) {
-    validateName(name);
-    const current = facts.participant(name);
-    return current === undefined ? { joinedName: name, state: 'joined', joinAct: { kind: 'join', actor: name, at: now } }
-        : { joinedName: current.name, state: current.joined ? 'active' : 'done' };
-}
 function validateActivityName(name) {
     try {
         validateName(name);
@@ -54,34 +48,28 @@ function requireStanding(current) {
     if (!current.joined)
         throw new SquareError('not_joined', `${participantIdentity(current.name)} has not joined this square`);
 }
-/** Count the directed suffix, but hydrate only its last three previews per spelling. */
+/** Count the directed suffix and hydrate only its last activity by index per spelling. */
 export function unreadActivitySummaries(facts, name, now) {
     let afterIndex = readCursor(facts, name);
-    const numbers = new Map();
     const summaries = new Map();
     while (true) {
         const page = facts.directed(name, { afterIndex }, { edge: 'oldest', limit: FACT_PAGE_SIZE });
         for (const item of page.items) {
-            const key = nameKey(item.actor);
-            const number = (numbers.get(key) ?? 0) + 1;
-            numbers.set(key, number);
-            const summary = summaries.get(item.actor) ?? { count: 0, latestAt: -Infinity, previews: [] };
+            const summary = summaries.get(item.actor) ?? { count: 0, latestAt: -Infinity, lastIndex: item.index };
             summary.count++;
             summary.latestAt = Math.max(summary.latestAt, item.at);
-            summary.previews.push({ index: item.index, number });
-            if (summary.previews.length > 3)
-                summary.previews.shift();
+            summary.lastIndex = item.index;
             summaries.set(item.actor, summary);
         }
         if (!page.hasMore)
             break;
         afterIndex = page.items.at(-1).index;
     }
-    const selected = facts.activities([...summaries.values()].flatMap((item) => item.previews.map((preview) => preview.index)));
+    const selected = facts.activities([...summaries.values()].map((item) => item.lastIndex));
     const byIndex = new Map(selected.map((item) => [item.index, item]));
     return [...summaries].map(([name, summary]) => ({
         name, count: summary.count, latestActivityAgeMs: Math.max(0, now - summary.latestAt),
-        previews: summary.previews.map((preview) => ({ number: preview.number, act: byIndex.get(preview.index), perception: 'full' })),
+        preview: byIndex.get(summary.lastIndex),
     })).sort((a, b) => a.latestActivityAgeMs - b.latestActivityAgeMs || a.name.localeCompare(b.name));
 }
 export function decideAct(facts, input) {
@@ -142,9 +130,6 @@ export function decideAct(facts, input) {
         throw activityRefusal('already_done', `${name} is already done`);
     if (!current.joined)
         throw activityRefusal('not_joined', `${name} has not joined this square`);
-    const hold = facts.hold();
-    if (hold.active)
-        return { type: 'held', reason: hold.reason };
     if (header.hardCap !== null && current.sayCount >= header.hardCap)
         return { type: 'capped', count: current.sayCount, hardCap: header.hardCap };
     if (reach === 'bell') {
@@ -197,16 +182,6 @@ export function coreListening(facts, actor) {
     const current = resolveStanding(facts, actor);
     return facts.attention(current.name).filter((item) => item.kind === 'listen').map((item) => item.target);
 }
-export function coreHold(facts, actor, body, now) {
-    const current = resolveStanding(facts, actor);
-    requireStanding(current);
-    return { kind: 'hold', actor: current.name, at: now, body: body.replace(/\r\n/g, '\n').trim() };
-}
-export function coreResume(facts, actor, now) {
-    const current = resolveStanding(facts, actor);
-    requireStanding(current);
-    return { kind: 'resume', actor: current.name, at: now };
-}
 export function compareParticipantActivity(a, b) {
     return (b.lastActiveAt ?? -Infinity) - (a.lastActiveAt ?? -Infinity) || a.name.localeCompare(b.name);
 }
@@ -219,10 +194,11 @@ export function coreParticipants(facts, now) {
                 lastActiveAt = Math.max(lastActiveAt ?? -Infinity, seenAt);
         }
         return {
-            name: current.name, state: current.done ? 'done' : current.joined ? 'active' : 'not joined',
+            name: current.name, deliveryAvailable: facts.seat(current.name)?.wakeAddress !== undefined,
             listening: facts.attention(current.name).filter((item) => item.kind === 'listen').map((item) => item.target),
             activityCount: current.sayCount, lastActiveAt,
-            presence: current.done ? 'done' : !current.joined ? 'never-joined' : freshWatchLease(facts, current.name, now) !== undefined ? 'watching' : 'active',
+            presence: current.done ? 'done' : !current.joined ? 'never-joined' : facts.seat(current.name)?.attachment === 'detached' ? 'away'
+                : freshWatchLease(facts, current.name, now) !== undefined ? 'watching' : 'active',
             unreadActivityCount: current.joined ? facts.directedCount(current.name, { afterIndex: readCursor(facts, current.name) }) : 0,
             pendingMentionCount: current.joined ? facts.directedCount(current.name, { afterIndex: current.lastJoinIndex ?? -1, unseenOnly: true }) : 0,
         };

package/dist/delivery-attempts.d.ts

@@ -0,0 +1,52 @@
+export type DeliveryPurpose = 'dispatch' | 'presentation';
+export type AttemptOutcome = 'dispatching' | 'accepted' | 'failed' | 'unknown' | 'released' | 'presented' | 'clipped';
+export interface Attempt<D> {
+    readonly purpose: DeliveryPurpose;
+    readonly token: string;
+    readonly ordinal: number;
+    readonly outcome: AttemptOutcome;
+    readonly at: number;
+    readonly expiresAt?: number;
+    readonly data: D;
+}
+/** One item/recipient/authority/purpose series, bound inside the caller's transaction.
+ * The caller owns token uniqueness, isolation and rollback; replacements retain coordinates.
+ */
+export interface AttemptRows<D> {
+    list(): readonly Attempt<D>[];
+    byToken(token: string): Attempt<D> | undefined;
+    insert(attempt: Attempt<D>): void;
+    replace(attempt: Attempt<D>): void;
+}
+export type AttemptClaim<D> = {
+    readonly status: 'acquired';
+    readonly token: string;
+    readonly ordinal: number;
+} | {
+    readonly status: 'busy' | 'terminal';
+    readonly evidence: Attempt<D>;
+    readonly interrupted?: true;
+};
+export declare function claimAttempt<D>(rows: AttemptRows<D>, input: {
+    purpose: DeliveryPurpose;
+    token: string;
+    at: number;
+    leaseMs: number;
+    data: D;
+}): AttemptClaim<D>;
+export declare function prepareAttempt<D>(rows: AttemptRows<D>, input: {
+    token: string;
+    data: D;
+}): boolean;
+export declare function settleAttempt<D>(rows: AttemptRows<D>, input: {
+    token: string;
+    outcome: Exclude<AttemptOutcome, 'dispatching'>;
+    at: number;
+    data: D;
+}): boolean;
+type Custody = Pick<Attempt<unknown>, 'purpose' | 'outcome' | 'expiresAt'>;
+/** Presentation custody suppresses dispatch independently of dispatch acceptance. */
+export declare function presentationBlocksDispatch(attempts: readonly Custody[], now: number): boolean;
+/** An expired dispatch is uncertain, not permission for automatic replay. */
+export declare function automaticDispatchEligible(attempts: readonly Custody[], now: number): boolean;
+export {};

package/dist/delivery-attempts.js

@@ -0,0 +1,73 @@
+function finite(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        throw new RangeError('time must be finite');
+}
+function token(value) {
+    if (typeof value !== 'string' || value.length === 0)
+        throw new TypeError('token must be nonempty');
+}
+export function claimAttempt(rows, input) {
+    if (input.purpose !== 'dispatch' && input.purpose !== 'presentation')
+        throw new TypeError('unsupported purpose');
+    token(input.token);
+    finite(input.at);
+    if (!Number.isSafeInteger(input.leaseMs) || input.leaseMs <= 0)
+        throw new RangeError('leaseMs must be a positive safe integer');
+    const expiresAt = input.at + input.leaseMs;
+    finite(expiresAt);
+    const attempts = rows.list();
+    const terminal = attempts.find(row => row.outcome === 'unknown'
+        || row.outcome === (input.purpose === 'dispatch' ? 'accepted' : 'presented'));
+    if (terminal !== undefined)
+        return { status: 'terminal', evidence: terminal };
+    const dispatching = attempts.find(row => row.outcome === 'dispatching');
+    if (dispatching !== undefined) {
+        if (dispatching.expiresAt === undefined || dispatching.expiresAt > input.at)
+            return { status: 'busy', evidence: dispatching };
+        const { expiresAt: _expiry, ...previous } = dispatching;
+        const evidence = { ...previous, outcome: 'unknown', at: input.at };
+        rows.replace(evidence);
+        return { status: 'terminal', evidence, interrupted: true };
+    }
+    const ordinal = (attempts[0]?.ordinal ?? -1) + 1;
+    if (!Number.isSafeInteger(ordinal) || ordinal < 0)
+        throw new RangeError('attempt ordinal exhausted');
+    rows.insert({ purpose: input.purpose, token: input.token, ordinal, outcome: 'dispatching', at: input.at, expiresAt, data: input.data });
+    return { status: 'acquired', token: input.token, ordinal };
+}
+export function prepareAttempt(rows, input) {
+    token(input.token);
+    const previous = rows.byToken(input.token);
+    if (previous?.outcome !== 'dispatching')
+        return false;
+    rows.replace({ ...previous, data: input.data });
+    return true;
+}
+export function settleAttempt(rows, input) {
+    token(input.token);
+    finite(input.at);
+    if (!['accepted', 'failed', 'unknown', 'released', 'presented', 'clipped'].includes(input.outcome))
+        throw new TypeError('unsupported completion');
+    const previous = rows.byToken(input.token);
+    if (previous === undefined)
+        return false;
+    if (previous.outcome === 'accepted' && input.outcome === 'accepted')
+        return true;
+    if (previous.outcome !== 'dispatching' && !(previous.outcome === 'unknown' && input.outcome === 'accepted'))
+        return false;
+    const { expiresAt: _expiry, ...retained } = previous;
+    rows.replace({ ...retained, outcome: input.outcome, at: input.at, data: input.data });
+    return true;
+}
+/** Presentation custody suppresses dispatch independently of dispatch acceptance. */
+export function presentationBlocksDispatch(attempts, now) {
+    finite(now);
+    return attempts.some(row => row.purpose === 'presentation'
+        && (row.outcome === 'presented' || row.outcome === 'clipped' || row.outcome === 'unknown'
+            || row.outcome === 'dispatching' && (row.expiresAt === undefined || row.expiresAt > now)));
+}
+/** An expired dispatch is uncertain, not permission for automatic replay. */
+export function automaticDispatchEligible(attempts, now) {
+    return !presentationBlocksDispatch(attempts, now) && !attempts.some(row => row.purpose === 'dispatch'
+        && (row.outcome === 'accepted' || row.outcome === 'unknown' || row.outcome === 'dispatching'));
+}

package/dist/delivery-deferral.js

@@ -1,4 +1,4 @@
-import { SquareError, sameBody } from './model.js';
+import { SquareError } from './model.js';
 export const MAX_DELIVERY_DEFERRAL_MS = 24 * 60 * 60 * 1000;
 export function validateMetadataMatch(value) {
     const fail = () => { throw new SquareError('invalid_args', 'Invalid metadata match.'); };
@@ -69,7 +69,7 @@ export function matchingDeferrals(deferrals, metadata, now) {
 }
 export function deliveryDeferralExpiry(facts, captured, index, now) {
     const seat = facts.seat(captured.participant);
-    if (seat === undefined || seat.generation !== captured.generation || !sameBody(seat.body, captured.body))
+    if (seat === undefined || seat.generation !== captured.generation || seat.owner !== captured.owner)
         return undefined;
     const leases = facts.deliveryDeferrals(seat.participant, seat.generation);
     if (!leases.some(lease => lease.expiresAt > now))