@astrosheep/square 0.4.0 → 0.4.2

package/dist/claude-delivery.d.ts

@@ -1,12 +0,0 @@
-export { createClaudeWakeTransport, nativeTokens, nativePayload } from './claude-transport.js';
-/** Recognize the whole frame first; one inactive token vetoes it before any evidence/receipt write. */
-export declare function observeClaudeDelivery(sessionId: string, text: string, operation: 'guard' | 'admitted' | 'stored', env?: NodeJS.ProcessEnv): Promise<{
-    recognized: boolean;
-    current: boolean;
-}>;
-export type ClaudeBinding = {
-    readonly location: string;
-    readonly participant: string;
-    readonly session: string;
-    readonly generation?: string;
-};

package/dist/claude-delivery.js

@@ -1,108 +0,0 @@
-import { createArtifactPort } from './artifact.js';
-import { presentPending } from './presentation-operations.js';
-import { nativePendingHead } from './delivery.js';
-import { decodeHarnessOwner } from './owner.js';
-import { indexedSquareEntries } from './square-index.js';
-import { parseMessageId } from './message.js';
-export { createClaudeWakeTransport, nativeTokens, nativePayload } from './claude-transport.js';
-import { nativeTokens, hashPayload } from './claude-transport.js';
-async function rowsForSession(sessionId, env, tokens) {
-    const rows = [];
-    const candidates = (await indexedSquareEntries({}, env)).filter(entry => {
-        const coordinate = decodeHarnessOwner(entry.owner);
-        return coordinate?.channel === 'claude-code' && coordinate.session === sessionId;
-    });
-    const paths = new Set(candidates.map(candidate => candidate.location));
-    for (const location of paths) {
-        const artifact = createArtifactPort(location);
-        try {
-            const found = await artifact.read((facts) => tokens.flatMap((token) => {
-                const evidence = facts.deliveryByToken(token);
-                if (evidence?.kind !== 'wake' || evidence.correlation?.harness !== 'claude' || evidence.correlation.token !== token
-                    || evidence.route?.kind !== 'claude-native' || evidence.route.address.sessionId !== sessionId)
-                    return [];
-                const seat = facts.seat(evidence.participant);
-                return [{ artifact, evidence, location, index: parseMessageId(evidence.message),
-                        ...(seat === undefined ? {} : { seat: { participant: evidence.participant, owner: seat.owner, generation: evidence.generation } }) }];
-            }));
-            rows.push(...found.value);
-            if (found.value.length === 0)
-                await artifact.close();
-        }
-        catch {
-            await artifact.close();
-        }
-    }
-    return rows;
-}
-/** The token, participant, activity and captured generation must still be the exact wake. */
-function sameCapturedEvidence(facts, row) {
-    const token = row.evidence.claimToken;
-    const evidence = token === undefined ? undefined : facts.deliveryByToken(token);
-    return token !== undefined && evidence !== undefined && row.seat !== undefined && row.seat.participant === row.evidence.participant
-        && row.seat.generation === row.evidence.generation && evidence.kind === 'wake' && evidence.claimToken === token
-        && evidence.participant === row.evidence.participant && evidence.message === row.evidence.message
-        && evidence.generation === row.evidence.generation
-        && evidence.correlation?.harness === 'claude' && evidence.correlation.token === token
-        && evidence.correlation.payloadHash === row.evidence.correlation?.payloadHash
-        && ['dispatching', 'unknown', 'accepted'].includes(evidence.outcome);
-}
-function capturedInput(row, now) {
-    if (row.seat === undefined || row.index === undefined || row.evidence.route === undefined)
-        return undefined;
-    return { location: row.location, participant: row.evidence.participant, generation: row.seat.generation,
-        owner: row.seat.owner, index: row.index, route: row.evidence.route, now };
-}
-function currentRow(facts, row, now) {
-    const input = capturedInput(row, now);
-    return input !== undefined && sameCapturedEvidence(facts, row) && nativePendingHead(facts, input) !== undefined;
-}
-/** Recognize the whole frame first; one inactive token vetoes it before any evidence/receipt write. */
-export async function observeClaudeDelivery(sessionId, text, operation, env = process.env) {
-    const tokens = nativeTokens(text);
-    if (tokens.length === 0)
-        return { recognized: false, current: false };
-    const rows = await rowsForSession(sessionId, env, [...new Set(tokens)]);
-    const recognized = rows.length > 0;
-    const frames = [...text.matchAll(/(?:^|\n)(\[square-inbox:([a-zA-Z0-9-]+)\]\n[\s\S]*?\n\[\/square-inbox:\2\])(?=\n|$)/g)];
-    try {
-        // Every recognized token is vetted before any row can write: actual bytes against the
-        // stored correlation hash, then independent current eligibility.
-        const contentCurrent = rows.every(row => {
-            const token = row.evidence.claimToken, hash = row.evidence.correlation?.payloadHash;
-            if (token === undefined || hash === undefined || row.seat === undefined || row.index === undefined
-                || !['dispatching', 'unknown', 'accepted'].includes(row.evidence.outcome))
-                return false;
-            const matching = frames.filter(frame => frame[2] === token);
-            return matching.length === tokens.filter(candidate => candidate === token).length
-                && matching.every(frame => hashPayload(frame[1]) === hash);
-        });
-        if (!recognized || !contentCurrent)
-            return { recognized, current: false };
-        const now = Date.now();
-        for (const row of rows) {
-            if (!(await row.artifact.read(facts => currentRow(facts, row, now))).value)
-                return { recognized, current: false };
-        }
-        for (const row of rows) {
-            if (operation === 'guard')
-                continue;
-            const seat = row.seat;
-            const current = (facts) => currentRow(facts, row, Date.now());
-            const admitted = await row.artifact.transactAs({ kind: 'participant', seat }, facts => current(facts) && facts.channel.completeDelivery({ seat, message: row.evidence.message,
-                claimToken: row.evidence.claimToken, outcome: 'accepted', at: Date.now() })).catch(() => ({ value: false }));
-            if (!admitted.value)
-                return { recognized, current: false };
-            if (operation === 'stored') {
-                await presentPending({ artifact: row.artifact, location: row.location,
-                    // Persisted coverage decides consumption; the current renderer never guesses.
-                    participant: row.evidence.participant, message: row.evidence.message, seat, observationOf: row.evidence.claimToken,
-                    markSeen: row.evidence.coverage !== 'clipped', sink: { present() { } }, current });
-            }
-        }
-        return { recognized, current: true };
-    }
-    finally {
-        await Promise.all([...new Set(rows.map(row => row.artifact))].map(artifact => artifact.close()));
-    }
-}

package/dist/claude-mod.d.ts

@@ -1,8 +0,0 @@
-export interface ClaudeCoordinate {
-    readonly sessionId: string;
-    readonly cwd: string;
-    readonly version: string;
-    readonly endpoint?: string;
-}
-/** JSON stdin bridge. Identity is explicit per operation; process.env is never rewritten. */
-export declare function runClaudeMod(inputText: string, env?: NodeJS.ProcessEnv): Promise<string>;

package/dist/claude-mod.js

@@ -1,172 +0,0 @@
-import { operationEnv } from './participant-identity.js';
-import { channelArtifact, createArtifactPort } from './artifact.js';
-import { recordClaudeDeliveryStatus } from './claude-delivery-status.js';
-import { Square } from './square-api.js';
-import { observeClaudeDelivery } from './claude-delivery.js';
-import { processActNotificationsOnce } from './notifications.js';
-import { sweepPending } from './delivery-operations.js';
-import { beginClaudeMcpCall, endClaudeMcpCall } from './claude-mcp-context.js';
-import { asSeatRef } from './seats.js';
-import { projectSessionSeats } from './inbox.js';
-import { restoreSessionSeats } from './session-lifecycle.js';
-import { harnessOwner } from './owner.js';
-import { InternalSquareError, SquareError } from './model.js';
-/** Persisted hook state keeps its wire coordinate; internal consumers keep the located seat. */
-function claudeBinding({ location, seat }, sessionId) {
-    return { location, participant: seat.participant, session: sessionId, generation: seat.generation };
-}
-/** JSON stdin bridge. Identity is explicit per operation; process.env is never rewritten. */
-export async function runClaudeMod(inputText, env = process.env) {
-    if (inputText.length > 512_000)
-        throw new Error('Claude bridge input exceeds its bound.');
-    const input = JSON.parse(inputText);
-    if (!input || typeof input.sessionId !== 'string' || !input.sessionId || typeof input.cwd !== 'string')
-        throw new Error('Claude bridge coordinate missing.');
-    if (input.operation === 'status') {
-        const recorded = input.status?.sessionId === input.sessionId && await recordClaudeDeliveryStatus(input.status, env);
-        return `${JSON.stringify({ recorded })}\n`;
-    }
-    if (input.operation === 'tool-begin') {
-        return `${JSON.stringify(await beginClaudeMcpCall({ toolUseId: input.toolUseId, sessionId: input.sessionId, cwd: input.cwd, agentId: input.agentId }, env))}\n`;
-    }
-    if (input.operation === 'tool-end') {
-        await endClaudeMcpCall(input.toolUseId, input.token, env);
-        return '{}\n';
-    }
-    const scoped = operationEnv('claude', input.sessionId, env);
-    const signal = AbortSignal.timeout(2500);
-    const owner = harnessOwner({ channel: 'claude-code', session: input.sessionId, ...(input.agentId === undefined ? {} : { agent: input.agentId }) });
-    const supported = process.platform === 'darwin' && typeof input.endpoint === 'string' && input.endpoint.startsWith('/');
-    const sessionSeats = async () => (await projectSessionSeats({ owner, env }, signal)).filter(member => member.seat.attachment === 'attached');
-    if (input.operation === 'end') {
-        const retired = [];
-        const captured = [...input.bindings ?? []];
-        // Discover committed late joins at the pinned end boundary, never later owners.
-        if (input.endedAt !== undefined)
-            for (const member of await projectSessionSeats({ owner, env }, signal)) {
-                if (member.joinedAt > input.endedAt || captured.some((item) => item.location === member.location
-                    && item.participant === member.seat.participant && item.generation === member.seat.generation))
-                    continue;
-                captured.push(claudeBinding(member, input.sessionId));
-            }
-        for (const binding of captured) {
-            if (binding.session !== input.sessionId)
-                continue;
-            const square = await Square.at({ path: binding.location, env: scoped });
-            try {
-                const detached = binding.generation === undefined ? null
-                    : await square.detach(binding.participant, { owner, generation: binding.generation });
-                if (detached)
-                    retired.push(binding);
-            }
-            finally {
-                await square.close();
-            }
-            if (signal.aborted)
-                break;
-        }
-        return `${JSON.stringify({ retired })}\n`;
-    }
-    const recovery = new Set();
-    const cancelledBindings = [...input.cancelledBindings ?? []];
-    if (input.operation === 'start') {
-        await restoreSessionSeats(owner, scoped, supported ? {
-            kind: 'claude-native', address: { sessionId: input.sessionId, endpoint: input.endpoint, version: input.version, platform: 'darwin', loaded: 'true' },
-        } : undefined, signal);
-    }
-    if (input.operation === 'start' || input.operation === 'reconcile' || input.operation === 'cancel' || input.cancelAt !== undefined) {
-        for (const member of await sessionSeats()) {
-            if (signal.aborted)
-                break;
-            const { location, seat: capturedSeat, joinedAt } = member;
-            const matches = (item) => item !== undefined
-                && item.location === location && item.participant === capturedSeat.participant && item.session === input.sessionId
-                && (item.generation === undefined || item.generation === capturedSeat.generation);
-            const expected = input.bindings?.find(matches);
-            const cancelled = input.cancelledBindings?.find(matches) ?? (input.operation === 'cancel' ? expected : undefined);
-            const lateCancelledJoin = input.operation === 'cancel' && input.cancelAt !== undefined
-                && joinedAt <= input.cancelAt && expected === undefined;
-            if (lateCancelledJoin && !cancelledBindings.some(matches))
-                cancelledBindings.push(claudeBinding(member, input.sessionId));
-            if (input.operation !== 'start' && input.operation !== 'reconcile' && !lateCancelledJoin && expected === undefined)
-                continue;
-            const artifact = createArtifactPort(location, undefined, signal);
-            try {
-                const { value: currentSeat } = await artifact.read((facts) => facts.seat(capturedSeat.participant), signal);
-                if (currentSeat === undefined || currentSeat.attachment !== 'attached' || currentSeat.generation !== capturedSeat.generation
-                    || currentSeat.owner !== capturedSeat.owner)
-                    continue;
-                const seat = asSeatRef(currentSeat);
-                const existing = currentSeat.wakeAddress?.kind === 'claude-native' ? currentSeat.wakeAddress : undefined;
-                const cutoff = input.cancelAt !== undefined && (cancelled !== undefined || lateCancelledJoin) ? input.cancelAt : undefined;
-                if (cutoff !== undefined) {
-                    const { value: through } = await artifact.read((facts) => {
-                        let beforeIndex;
-                        for (;;) {
-                            const page = facts.activityHeads({ beforeIndex }, { edge: 'newest', limit: 100 });
-                            const last = page.items.find((activity) => activity.at <= cutoff && activity.messageIndex !== undefined);
-                            if (last !== undefined)
-                                return last.messageIndex;
-                            if (!page.hasMore)
-                                return -1;
-                            beforeIndex = page.items[0].index;
-                        }
-                    }, signal);
-                    if (through >= 0)
-                        await artifact.cancelDeliveries(seat, through, signal);
-                }
-                if (!supported) {
-                    if (existing !== undefined)
-                        await artifact.transactAs({ kind: 'participant', seat }, (facts) => facts.updateWakeAddress(seat, undefined), signal);
-                    continue;
-                }
-                if (existing === undefined || existing.address.endpoint !== input.endpoint)
-                    recovery.add(location);
-                await artifact.transactAs({ kind: 'participant', seat }, (facts) => facts.updateWakeAddress(seat, {
-                    kind: 'claude-native', address: { sessionId: input.sessionId, endpoint: input.endpoint, version: input.version, platform: 'darwin', loaded: 'true' },
-                }), signal);
-            }
-            catch (error) {
-                if (error instanceof InternalSquareError && error.code === 'not_found')
-                    throw new SquareError('unavailable', `Square is unavailable at ${location}`);
-                throw error;
-            }
-            finally {
-                await artifact.close();
-            }
-        }
-    }
-    if (input.operation === 'start' || input.operation === 'reconcile' || input.operation === 'cancel') {
-        const members = await sessionSeats();
-        // One startup recovery pass for known unsent work. Unknown/admitted sends never replay.
-        if (supported && input.operation !== 'cancel')
-            for (const { location } of members) {
-                if (signal.aborted)
-                    break;
-                if (input.operation !== 'start' && !recovery.has(location))
-                    continue;
-                const artifact = createArtifactPort(location, undefined, signal);
-                let indices;
-                try {
-                    indices = await sweepPending({ artifact: channelArtifact(artifact), location, now: Date.now(), graceMs: 0, limit: 8 });
-                }
-                catch (error) {
-                    if (error instanceof InternalSquareError && error.code === 'not_found')
-                        throw new SquareError('unavailable', `Square is unavailable at ${location}`);
-                    throw error;
-                }
-                finally {
-                    await artifact.close();
-                }
-                for (const index of indices) {
-                    if (signal.aborted)
-                        break;
-                    await processActNotificationsOnce(location, index, { env: { ...env, SQUARE_NOTIFY_DELIVERY_WAIT_MS: '200' } });
-                }
-            }
-        return `${JSON.stringify({ available: supported, diagnostic: supported ? undefined : 'Native inbox unavailable: requires macOS Claude with an interactive loaded mod and its real endpoint.', bindings: members.map(member => claudeBinding(member, input.sessionId)), cancelledBindings })}\n`;
-    }
-    if (!['guard', 'admitted', 'stored'].includes(input.operation) || typeof input.text !== 'string')
-        throw new Error('Unknown Claude bridge operation.');
-    return `${JSON.stringify(await observeClaudeDelivery(input.sessionId, input.text, input.operation, env))}\n`;
-}

package/dist/claude-transport.d.ts

@@ -1,5 +0,0 @@
-import type { WakeTransportPort } from './channel-transport.js';
-export declare function nativeTokens(text: string): string[];
-export declare function nativePayload(token: string, preview: string): string;
-export declare function hashPayload(payload: string): string;
-export declare function createClaudeWakeTransport(env?: NodeJS.ProcessEnv): WakeTransportPort;

package/dist/claude-transport.js

@@ -1,58 +0,0 @@
-import { stat } from 'node:fs/promises';
-import { createHash, randomUUID } from 'node:crypto';
-import { writeClaudeNative } from './packages/agent-delivery/src/claude-native.js';
-const marker = /(?:^|\n)\[square-inbox:([a-zA-Z0-9-]+)\](?:\n|$)/g;
-export function nativeTokens(text) { return [...text.matchAll(marker)].map((match) => match[1]); }
-export function nativePayload(token, preview) { return `[square-inbox:${token}]\n${preview}\n[/square-inbox:${token}]`; }
-function nativeSupported(route) { return route.address.loaded === 'true' && !!route.address.endpoint; }
-export function hashPayload(payload) { return createHash('sha256').update(payload).digest('hex'); }
-async function preview(request) {
-    return request.presentation;
-}
-async function writeClaudeWake(sessionId, endpoint, messageId, payload, timeoutMs, signal) {
-    const result = await writeClaudeNative({ sessionId, endpoint, messageId }, payload, { deadline: Date.now() + timeoutMs, signal });
-    if (result.outcome === 'unavailable')
-        return { outcome: 'failed', signature: 'claude_endpoint_unavailable', message: result.message };
-    return { outcome: 'unknown', signature: 'native_admission_unconfirmed', message: result.outcome === 'written' ? 'Claude accepted the local write; native admission is unconfirmed.' : result.message };
-}
-export function createClaudeWakeTransport(env = process.env) {
-    return {
-        async probe(route) {
-            if (!nativeSupported(route))
-                return { outcome: 'not-capable', diagnostic: 'Claude native inbox unavailable: a loaded interactive Square mod is required.' };
-            try {
-                return (await stat(route.address.endpoint)).isSocket() || { outcome: 'not-capable', diagnostic: 'Claude native inbox endpoint is not a socket.' };
-            }
-            catch {
-                return { outcome: 'not-capable', diagnostic: 'Claude native inbox endpoint unavailable.' };
-            }
-        },
-        attempt: (request, timeoutMs, beforeSend) => dispatchClaude(request, timeoutMs, beforeSend, env),
-    };
-}
-async function dispatchClaude(request, timeoutMs, beforeSend, env = process.env) {
-    void env;
-    const signal = AbortSignal.timeout(timeoutMs);
-    if (!nativeSupported(request.route) || request.claimToken === undefined)
-        return { outcome: 'not-capable', diagnostic: 'Claude native delivery needs a current artifact claim and loaded inbox.' };
-    if (signal.aborted || !await beforeSend())
-        return { outcome: 'unknown', signature: 'native_send_suppressed' };
-    const prepared = await preview(request);
-    if (prepared === undefined)
-        return { outcome: 'not-capable', diagnostic: 'Claude activity is no longer current.' };
-    const messageId = randomUUID();
-    const payload = nativePayload(request.claimToken, prepared.payload);
-    const correlation = { harness: 'claude', token: request.claimToken, messageId, payloadHash: hashPayload(payload) };
-    if (!await request.channel.prepare({ correlation, coverage: prepared.coverage,
-        ...(prepared.description === undefined ? {} : { description: prepared.description }) }))
-        return { outcome: 'not-capable', diagnostic: 'Claude delivery claim is no longer current.' };
-    const fresh = await preview(request);
-    if (fresh === undefined || nativePayload(request.claimToken, fresh.payload) !== payload)
-        return { outcome: 'not-capable', diagnostic: 'Claude activity changed before native write.' };
-    if (signal.aborted || !await beforeSend())
-        return { outcome: 'not-capable', diagnostic: 'Claude activity was consumed before native write.' };
-    const sessionId = request.route.address.sessionId;
-    if (sessionId === undefined)
-        return { outcome: 'not-capable', diagnostic: 'Claude native route has no session address.' };
-    return writeClaudeWake(sessionId, request.route.address.endpoint, messageId, payload, timeoutMs, signal);
-}

package/dist/cmd/notify-once.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/cmd/notify-once.js

@@ -1,29 +0,0 @@
-#!/usr/bin/env node
-import { resolve } from 'node:path';
-import { setTimeout as sleep } from 'node:timers/promises';
-import { processActNotificationsOnce, wakeGraceMs } from '../notifications.js';
-function args(argv) {
-    let squarePath;
-    let actIndex;
-    for (let index = 0; index < argv.length; index += 1) {
-        if (argv[index] === '--location' && argv[index + 1] !== undefined)
-            squarePath = resolve(argv[++index]);
-        else if (argv[index] === '--act-index' && /^\d+$/.test(argv[index + 1] ?? ''))
-            actIndex = Number(argv[++index]);
-        else
-            throw new Error(`Unknown notify-once argument: ${argv[index]}`);
-    }
-    if (squarePath === undefined || actIndex === undefined)
-        throw new Error('notify-once requires --location and --act-index.');
-    return { squarePath, actIndex };
-}
-async function main() {
-    if (process.env.SQUARE_DISABLE_PASEO_WAKE === '1')
-        return;
-    const { squarePath, actIndex } = args(process.argv.slice(2));
-    await sleep(wakeGraceMs());
-    await processActNotificationsOnce(squarePath, actIndex);
-}
-main().catch(() => {
-    process.exitCode = 0;
-});

package/dist/delivery-attempts.d.ts

@@ -1,52 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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'));
-}
-/** 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'));
-}