@astrosheep/square 0.3.93 → 0.3.95

package/dist/delivery-effects.d.ts

@@ -0,0 +1,139 @@
+export interface EffectClaim {
+    readonly token: string;
+    readonly ordinal: number;
+}
+/** Bound to one captured item/recipient/authority/purpose, not an encoded series key. */
+export interface EffectPort<C> {
+    /** The caller's existing atomic claim operation. Undefined means no custody acquired. */
+    claim(signal?: AbortSignal): Promise<EffectClaim | undefined>;
+    /** Pre-effect policy only. Rejection means unverifiable/not current. */
+    current(signal?: AbortSignal): Promise<boolean>;
+    /**
+     * No request signal: persistence has its own bounded lifetime. For presentation,
+     * `presented` MUST complete the attempt and record ALL captured full-consumption
+     * receipts in ONE atomic transaction (rollback both on error). `clipped`, `failed`,
+     * `unknown` and `released` complete the attempt without full-consumption receipts.
+     * No post-effect currentness/deferral/cancellation veto; captured authority still fences.
+     */
+    settle(claim: EffectClaim, completion: C): Promise<boolean>;
+}
+export type Persistence = {
+    readonly status: 'recorded';
+} | {
+    readonly status: 'not-recorded';
+} | {
+    readonly status: 'error';
+    readonly error: unknown;
+};
+export interface Settlement<C> {
+    readonly completion: C;
+    readonly persistence: Persistence;
+}
+export interface DispatchOutcome {
+    readonly outcome: 'accepted' | 'failed' | 'unknown' | 'not-capable';
+    readonly data?: unknown;
+}
+export type DispatchCompletion = {
+    readonly outcome: 'accepted' | 'failed' | 'unknown';
+    readonly reason: 'returned';
+    readonly data?: unknown;
+} | {
+    readonly outcome: 'unknown';
+    readonly reason: 'threw';
+    readonly error: unknown;
+} | {
+    readonly outcome: 'unknown';
+    readonly reason: 'timeout';
+} | {
+    readonly outcome: 'released';
+    readonly reason: 'not-current';
+    readonly phase: 'initial' | 'final';
+} | {
+    readonly outcome: 'released';
+    readonly reason: 'not-capable';
+    readonly data?: unknown;
+} | {
+    readonly outcome: 'released';
+    readonly reason: 'cancelled';
+};
+export interface DispatchContext {
+    readonly claim: EffectClaim;
+    readonly timeoutMs: number;
+    readonly deadline: number;
+    readonly signal?: AbortSignal;
+    /** Policy only. Sender MUST recheck deadline/cancellation after this await before I/O. */
+    beforeSend(): Promise<boolean>;
+}
+export interface DispatchReport {
+    readonly observation: {
+        readonly kind: 'not-invoked';
+    } | {
+        readonly kind: 'returned';
+        readonly result: DispatchOutcome;
+    } | {
+        readonly kind: 'threw';
+        readonly error: unknown;
+    } | {
+        readonly kind: 'timeout';
+    };
+    readonly settlement?: Settlement<DispatchCompletion>;
+}
+/** Timer bounds the external attempt only, not claim/currentness/persistence. No automatic retry. */
+export declare function dispatchEffect(port: EffectPort<DispatchCompletion>, send: (context: DispatchContext) => Promise<DispatchOutcome>, options: {
+    readonly timeoutMs: number;
+    readonly signal?: AbortSignal;
+}): Promise<DispatchReport>;
+export type PresentationCompletion = {
+    readonly outcome: 'presented' | 'clipped';
+    readonly reason: 'returned';
+} | {
+    readonly outcome: 'failed' | 'unknown';
+    readonly reason: 'threw';
+    readonly error: unknown;
+} | {
+    readonly outcome: 'released';
+    readonly reason: 'not-current' | 'cancelled' | 'unused';
+};
+export interface PresentationWork<P> {
+    readonly payload: P;
+    readonly coverage: 'full' | 'clipped';
+    readonly port: EffectPort<PresentationCompletion>;
+}
+declare const preparedBrand: unique symbol;
+export interface PreparedPresentation<P> {
+    readonly [preparedBrand]: true;
+    readonly payload: P;
+    eligible(signal?: AbortSignal): Promise<boolean>;
+    release(): Promise<Settlement<PresentationCompletion>>;
+}
+export interface PresentationControl {
+    readonly signal?: AbortSignal;
+    /** Default unknown; throwing or invalid classifiers also stay unknown. */
+    readonly classifyError?: (error: unknown) => 'failed' | 'unknown';
+}
+export interface PresentationReport<P, R> {
+    readonly observation: {
+        readonly kind: 'not-invoked';
+    } | {
+        readonly kind: 'returned';
+        readonly value: R;
+    } | {
+        readonly kind: 'threw';
+        readonly error: unknown;
+        readonly outcome: 'failed' | 'unknown';
+    };
+    readonly settlements: readonly {
+        readonly prepared: PreparedPresentation<P>;
+        readonly result: Settlement<PresentationCompletion>;
+    }[];
+}
+export declare function preparePresentation<P>(work: PresentationWork<P>, control?: {
+    readonly signal?: AbortSignal;
+}): Promise<PreparedPresentation<P> | undefined>;
+export declare function presentPrepared<P, R>(prepared: PreparedPresentation<P>, sink: (payload: P) => R | Promise<R>, control?: PresentationControl): Promise<PresentationReport<P, R>>;
+/** Takes all local custody synchronously, then owns eligibility/effect/settlement/cleanup. */
+export declare function presentPreparedBatch<P, B, R>(prepared: readonly PreparedPresentation<P>[], render: (eligible: readonly PreparedPresentation<P>[]) => {
+    readonly payload: B;
+    readonly included: readonly PreparedPresentation<P>[];
+}, sink: (payload: B) => R | Promise<R>, control?: PresentationControl): Promise<PresentationReport<P, R>>;
+export {};

package/dist/delivery-effects.js

@@ -0,0 +1,163 @@
+async function settle(port, claim, completion) {
+    try {
+        return { completion, persistence: { status: await port.settle(claim, completion) ? 'recorded' : 'not-recorded' } };
+    }
+    catch (error) {
+        return { completion, persistence: { status: 'error', error } };
+    }
+}
+async function current(port, signal) {
+    try {
+        return await port.current(signal);
+    }
+    catch {
+        return false;
+    }
+}
+/** Timer bounds the external attempt only, not claim/currentness/persistence. No automatic retry. */
+export async function dispatchEffect(port, send, options) {
+    const notInvoked = { kind: 'not-invoked' };
+    if (options.signal?.aborted)
+        return { observation: notInvoked };
+    const claim = await port.claim(options.signal);
+    if (claim === undefined)
+        return { observation: notInvoked };
+    if (!await current(port, options.signal))
+        return { observation: notInvoked,
+            settlement: await settle(port, claim, { outcome: 'released', reason: 'not-current', phase: 'initial' }) };
+    if (options.signal?.aborted)
+        return { observation: notInvoked,
+            settlement: await settle(port, claim, { outcome: 'released', reason: 'cancelled' }) };
+    let denied = false;
+    let timer;
+    const deadline = Date.now() + options.timeoutMs;
+    const timeout = new Promise(resolve => {
+        timer = setTimeout(() => resolve({ kind: 'timeout' }), options.timeoutMs);
+    });
+    let observation;
+    let completion;
+    try {
+        observation = await Promise.race([timeout, (async () => {
+                try {
+                    return { kind: 'returned', result: await send({ claim, deadline, ...options,
+                            beforeSend: async () => {
+                                const allowed = await current(port, options.signal);
+                                if (!allowed)
+                                    denied = true;
+                                return allowed;
+                            },
+                        }) };
+                }
+                catch (error) {
+                    return { kind: 'threw', error };
+                }
+            })()]);
+        // Freeze before persistence. Late policy results/sender completions cannot rewrite it.
+        completion = observation.kind === 'timeout' ? { outcome: 'unknown', reason: 'timeout' }
+            : denied ? { outcome: 'released', reason: 'not-current', phase: 'final' }
+                : observation.kind === 'threw' ? { outcome: 'unknown', reason: 'threw', error: observation.error }
+                    : observation.result.outcome === 'not-capable'
+                        ? { outcome: 'released', reason: 'not-capable', data: observation.result.data }
+                        : { outcome: observation.result.outcome, reason: 'returned', data: observation.result.data };
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+    return { observation, settlement: await settle(port, claim, completion) };
+}
+const preparedBrand = Symbol('prepared presentation');
+const custody = new WeakMap();
+export async function preparePresentation(work, control) {
+    if (control?.signal?.aborted)
+        return undefined;
+    const claim = await work.port.claim(control?.signal);
+    if (claim === undefined)
+        return undefined;
+    let resolve;
+    let decided = false;
+    const state = {
+        owned: false, coverage: work.coverage,
+        eligible: signal => signal?.aborted ? Promise.resolve(false) : current(work.port, signal),
+        done: new Promise(res => { resolve = res; }),
+        finish(completion) {
+            if (decided)
+                return;
+            decided = true;
+            // Defer callbacks: every included handle is marked before any settlement starts.
+            void Promise.resolve().then(() => settle(work.port, claim, completion)).then(resolve);
+        },
+    };
+    const prepared = Object.freeze({
+        [preparedBrand]: true,
+        payload: work.payload,
+        eligible: (signal) => state.owned ? Promise.resolve(false) : state.eligible(signal),
+        release() {
+            if (!state.owned) {
+                state.owned = true;
+                state.finish({ outcome: 'released', reason: 'unused' });
+            }
+            return state.done;
+        },
+    });
+    custody.set(prepared, state);
+    return prepared;
+}
+export function presentPrepared(prepared, sink, control) {
+    return presentPreparedBatch([prepared], eligible => ({ payload: prepared.payload, included: eligible }), sink, control);
+}
+/** Takes all local custody synchronously, then owns eligibility/effect/settlement/cleanup. */
+export async function presentPreparedBatch(prepared, render, sink, control = {}) {
+    const handles = [...prepared];
+    const states = handles.map(handle => custody.get(handle));
+    if (new Set(handles).size !== handles.length || states.some(state => state === undefined || state.owned)) {
+        await Promise.all([...new Set(handles)].filter(handle => custody.has(handle) && !custody.get(handle).owned).map(handle => handle.release()));
+        throw new TypeError('Presentation requires unique, unused prepared custody.');
+    }
+    const owned = states;
+    for (const state of owned)
+        state.owned = true;
+    let observation = { kind: 'not-invoked' };
+    try {
+        const eligible = [];
+        for (const [index, state] of owned.entries()) {
+            if (await state.eligible(control.signal))
+                eligible.push(handles[index]);
+            else
+                state.finish({ outcome: 'released', reason: control.signal?.aborted ? 'cancelled' : 'not-current' });
+        }
+        const rendered = render(Object.freeze(eligible));
+        const included = [...rendered.included];
+        if (new Set(included).size !== included.length || included.some(handle => !eligible.includes(handle)))
+            throw new TypeError('Included presentations must be a unique subset of eligible custody.');
+        if (included.length > 0 && !control.signal?.aborted) {
+            let completion;
+            try {
+                const value = await sink(rendered.payload);
+                observation = { kind: 'returned', value };
+                completion = { outcome: 'presented', reason: 'returned' };
+            }
+            catch (error) {
+                let outcome = 'unknown';
+                try {
+                    if (control.classifyError?.(error) === 'failed')
+                        outcome = 'failed';
+                }
+                catch { /* conservative */ }
+                observation = { kind: 'threw', error, outcome };
+                completion = { outcome, reason: 'threw', error };
+            }
+            for (const handle of included) {
+                const state = custody.get(handle);
+                state.finish(completion.outcome === 'presented'
+                    ? { outcome: state.coverage === 'full' ? 'presented' : 'clipped', reason: 'returned' } : completion);
+            }
+        }
+    }
+    finally {
+        for (const state of owned)
+            state.finish({ outcome: 'released', reason: control.signal?.aborted ? 'cancelled' : 'unused' });
+        await Promise.all(owned.map(state => state.done));
+    }
+    return { observation, settlements: await Promise.all(handles.map(async (handle, index) => ({ prepared: handle, result: await owned[index].done }))) };
+}

package/dist/delivery-health.d.ts

@@ -12,7 +12,6 @@ export interface WakeAttempt {
     readonly outcome: 'accepted' | 'unknown' | 'failed';
     readonly signature?: string;
     readonly attemptN: number;
-    readonly session?: string;
     readonly message?: string;
     readonly diagnostic?: unknown;
 }

package/dist/delivery-health.js

@@ -38,7 +38,6 @@ export async function classifyDeliveryHealth(squarePath, opts) {
                 routeKind: attemptRow.route.kind,
                 outcome: attemptRow.outcome,
                 attemptN: attemptRow.attemptN,
-                session: seat.body.session,
                 ...(attemptRow.signature === undefined ? {} : { signature: attemptRow.signature }),
                 ...(attemptRow.message === undefined ? {} : { message: attemptRow.message }),
                 ...(attemptRow.diagnostic === undefined ? {} : { diagnostic: attemptRow.diagnostic }),
@@ -128,7 +127,7 @@ function formatRelease(release, now) {
     const diagnostic = release.diagnostic === undefined ? '' : ` · ${displayField(JSON.stringify(release.diagnostic))}`;
     return `  · ${formatActivityId(release.attention.actIndex)} → ${displayField(participantIdentity(release.attention.recipient))} · ${route} · ${reason} · ${age}${message}${diagnostic}`;
 }
-function deliveryAttempt(squarePath, row, session) {
+function deliveryAttempt(squarePath, row) {
     if (row.route?.kind === undefined || row.outcome === 'released' || row.outcome === 'dispatching')
         return undefined;
     return {
@@ -137,7 +136,6 @@ function deliveryAttempt(squarePath, row, session) {
         routeKind: row.route.kind,
         outcome: row.outcome,
         attemptN: row.attemptN,
-        ...(session === undefined ? {} : { session }),
         ...(row.signature === undefined ? {} : { signature: row.signature }),
         ...(row.message === undefined ? {} : { message: row.message }),
         ...(row.diagnostic === undefined ? {} : { diagnostic: row.diagnostic }),

package/dist/delivery-operations.d.ts

@@ -1,5 +1,5 @@
-import type { SquareArtifactPort, DeliverPendingInput, DeliveryResult } from './ports.js';
-export declare function deliverPending(input: DeliverPendingInput): Promise<DeliveryResult>;
+import type { SquareArtifactPort, DeliverPendingInput } from './ports.js';
+export declare function deliverPending(input: DeliverPendingInput): Promise<void>;
 export declare function sweepPending(input: {
     readonly artifact: SquareArtifactPort;
     readonly location: string;

package/dist/delivery-operations.js

@@ -1,17 +1,16 @@
 import { randomUUID } from 'node:crypto';
 import { formatActivityId, parseActivityId } from './square-core.js';
-import { sameBody } from './model.js';
 import { pendingHead, pendingHeads, pendingRecipients, presentationBlocksWake } from './delivery.js';
 import { asSeatRef } from './seats.js';
-import { canonicalPath } from './canonical-path.js';
 import { freshWatchLease } from './runtime.js';
 import { deliveryDeferralExpiry } from './delivery-deferral.js';
 import { leaseOwnsNotification } from './delivery.js';
+import { dispatchEffect } from './delivery-effects.js';
 function routeFor(location, seat, now) {
-    if (seat.wakeAddress === undefined)
+    if (seat.attachment !== 'attached' || seat.wakeAddress === undefined)
         return undefined;
     return {
-        location, participant: seat.participant, sessionId: seat.body.session, channel: seat.body.channel,
+        location, participant: seat.participant,
         kind: seat.wakeAddress.kind, address: { ...seat.wakeAddress.address }, updatedAt: now,
     };
 }
@@ -19,8 +18,8 @@ async function currentness(artifact, request, now) {
     const index = parseActivityId(request.activity);
     const { value } = await artifact.read((facts) => {
         const currentSeat = facts.seat(request.participant);
-        const seatCurrent = currentSeat !== undefined && currentSeat.generation === request.seat.generation
-            && sameBody(currentSeat.body, request.seat.body)
+        const seatCurrent = currentSeat !== undefined && currentSeat.attachment === 'attached' && currentSeat.generation === request.seat.generation
+            && currentSeat.owner === request.seat.owner
             && currentSeat.wakeAddress?.kind === request.route.kind
             && Object.keys(currentSeat.wakeAddress.address).length === Object.keys(request.route.address).length
             && Object.entries(currentSeat.wakeAddress.address).every(([key, val]) => request.route.address[key] === val);
@@ -39,19 +38,6 @@ async function currentness(artifact, request, now) {
     });
     return value;
 }
-async function attemptWakeWithin(transport, request, timeoutMs, beforeSend) {
-    let timer;
-    const timeout = new Promise((resolve) => {
-        timer = setTimeout(() => resolve({ outcome: 'unknown', diagnostic: 'transport timeout' }), timeoutMs);
-    });
-    try {
-        return await Promise.race([transport.attempt(request, timeoutMs, beforeSend), timeout]);
-    }
-    finally {
-        if (timer !== undefined)
-            clearTimeout(timer);
-    }
-}
 async function candidates(artifact, requested, now = Date.now()) {
     const { value } = await artifact.read((facts) => {
         const heads = requested === undefined
@@ -59,17 +45,11 @@ async function candidates(artifact, requested, now = Date.now()) {
             : pendingRecipients(facts, requested);
         return heads.flatMap((head) => {
             const seat = facts.seat(head.recipient);
-            return seat === undefined || deliveryDeferralExpiry(facts, seat, head.index, now) !== undefined ? [] : [{ seat, head }];
+            return seat === undefined || seat.attachment !== 'attached' || deliveryDeferralExpiry(facts, seat, head.index, now) !== undefined ? [] : [{ seat, head }];
         });
     });
     return value;
 }
-function releaseClaim(artifact, seat, activity, claimToken, signature, message, diagnostic) {
-    return artifact.completeDelivery({ seat, activity, claimToken, outcome: 'released', at: Date.now(), signature,
-        ...(message === undefined ? {} : { message }),
-        ...(diagnostic === undefined ? {} : { diagnostic: safeJson(diagnostic) }),
-    }).catch(() => false);
-}
 function safeJson(value) {
     if (value === null || typeof value === 'string' || typeof value === 'boolean' || typeof value === 'number')
         return value;
@@ -81,19 +61,25 @@ function safeJson(value) {
     return String(value);
 }
 export async function deliverPending(input) {
-    const location = await canonicalPath(input.location);
+    // The resource owner supplies its identity; delivery does not interpret it as a file.
+    const location = input.location;
     const requested = input.activity === undefined ? undefined
         : typeof input.activity === 'number' ? input.activity : parseActivityId(input.activity);
     if (input.activity !== undefined && requested === undefined)
-        return { attempted: 0, accepted: 0, failed: 0, unknown: 0, notCapable: 0 };
+        return;
     const pending = await candidates(input.artifact, requested, input.now ?? Date.now());
-    let attempted = 0, accepted = 0, failed = 0, unknown = 0, notCapable = 0;
-    for (const { seat, head } of pending) {
+    // Preserve order within a receiving owner; unrelated receivers need not wait for each other.
+    const receivers = new Map();
+    for (const candidate of pending) {
+        const key = candidate.seat.owner;
+        const group = receivers.get(key) ?? [];
+        group.push(candidate);
+        receivers.set(key, group);
+    }
+    const dispatch = async ({ seat, head }) => {
         const route = routeFor(location, seat, input.now ?? Date.now());
-        if (route === undefined) {
-            notCapable += 1;
-            continue;
-        }
+        if (route === undefined)
+            return;
         const request = {
             location, participant: seat.participant, activity: formatActivityId(head.index), actor: head.actor,
             seat: asSeatRef(seat), route,
@@ -102,79 +88,68 @@ export async function deliverPending(input) {
         if (input.transport.probe !== undefined) {
             try {
                 const probe = await input.transport.probe(route);
-                if (probe === false || typeof probe === 'object' && probe.outcome === 'not-capable') {
-                    notCapable += 1;
-                    continue;
-                }
+                if (probe === false || typeof probe === 'object' && probe.outcome === 'not-capable')
+                    return;
             }
             catch {
-                notCapable += 1;
-                continue;
+                return;
             }
         }
         const claimToken = randomUUID();
         const leaseMs = input.timeoutMs ?? 5000;
-        const claim = await input.artifact.claimDelivery({ seat: request.seat, activity: request.activity, kind: 'wake',
-            route: seat.wakeAddress, at: input.now ?? Date.now(), leaseMs, claimToken }).catch(() => ({ status: 'stale' }));
-        if (claim.status !== 'acquired')
-            continue;
-        const withClaim = { ...request, claimToken, attemptN: claim.attemptN };
-        let final;
-        let suppressed = false;
-        const beforeSend = async () => {
-            try {
-                final = await currentness(input.artifact, withClaim, input.now ?? Date.now());
-                suppressed = !final.current;
-            }
-            catch {
-                suppressed = true;
-            }
-            return !suppressed;
-        };
-        let before;
-        try {
-            before = await currentness(input.artifact, withClaim, input.now ?? Date.now());
-        }
-        catch { /* unverifiable */ }
-        if (!before?.current) {
-            await releaseClaim(input.artifact, request.seat, request.activity, claimToken, 'pre_send_revalidation_failed', before === undefined ? 'Square delivery state could not be verified.' : 'The notification is no longer current.', before);
-            continue;
-        }
-        let outcome;
-        try {
-            outcome = await attemptWakeWithin(input.transport, withClaim, leaseMs, beforeSend);
-        }
-        catch (error) {
-            outcome = { outcome: 'unknown', diagnostic: error instanceof Error ? error.message : String(error) };
-        }
-        if (suppressed) {
-            await releaseClaim(input.artifact, request.seat, request.activity, claimToken, 'pre_send_revalidation_failed', 'The notification changed before the final send check.', final ?? { observationAvailable: false });
-            continue;
-        }
-        if (outcome.outcome === 'not-capable') {
-            await releaseClaim(input.artifact, request.seat, request.activity, claimToken, 'transport_not_capable', undefined, outcome.diagnostic);
-            notCapable += 1;
-            continue;
-        }
-        attempted += 1;
-        const mapped = outcome.outcome === 'accepted' ? 'accepted'
-            : outcome.outcome === 'unknown' ? 'unknown' : 'failed';
-        const completed = await input.artifact.completeDelivery({ seat: request.seat, activity: request.activity, claimToken,
-            outcome: mapped, at: Date.now(),
-            ...('signature' in outcome && outcome.signature !== undefined ? { signature: outcome.signature } : {}),
-            ...('message' in outcome && outcome.message !== undefined ? { message: outcome.message } : {}),
-            ...('diagnostic' in outcome && outcome.diagnostic !== undefined ? { diagnostic: safeJson(outcome.diagnostic) } : {}),
-        }).catch(() => false);
-        if (!completed)
-            continue;
-        if (mapped === 'accepted')
-            accepted += 1;
-        else if (mapped === 'unknown')
-            unknown += 1;
-        else
-            failed += 1;
-    }
-    return { attempted, accepted, failed, unknown, notCapable };
+        let snapshot;
+        await dispatchEffect({
+            async claim() {
+                const claim = await input.artifact.claimDelivery({ seat: request.seat, activity: request.activity, kind: 'wake',
+                    route: seat.wakeAddress, at: input.now ?? Date.now(), leaseMs, claimToken }).catch(() => ({ status: 'stale' }));
+                return claim.status === 'acquired' ? { token: claimToken, ordinal: claim.attemptN } : undefined;
+            },
+            async current() {
+                snapshot = undefined;
+                snapshot = await currentness(input.artifact, request, input.now ?? Date.now());
+                return snapshot.current;
+            },
+            async settle(claim, completion) {
+                let fields = {};
+                if (completion.reason === 'not-current')
+                    fields = {
+                        signature: 'pre_send_revalidation_failed',
+                        message: completion.phase === 'final' ? 'The notification changed before the final send check.'
+                            : snapshot === undefined ? 'Square delivery state could not be verified.' : 'The notification is no longer current.',
+                        diagnostic: snapshot ?? (completion.phase === 'final' ? { observationAvailable: false } : undefined),
+                    };
+                else if (completion.reason === 'timeout')
+                    fields = { diagnostic: 'transport timeout' };
+                else if (completion.reason === 'threw')
+                    fields = { diagnostic: completion.error instanceof Error ? completion.error.message : String(completion.error) };
+                else if (completion.reason === 'not-capable')
+                    fields = {
+                        signature: 'transport_not_capable', diagnostic: completion.data?.diagnostic,
+                    };
+                else if (completion.reason === 'returned')
+                    fields = completion.data;
+                return input.artifact.completeDelivery({ seat: request.seat, activity: request.activity, claimToken: claim.token,
+                    outcome: completion.outcome, at: Date.now(),
+                    ...(fields.signature === undefined ? {} : { signature: fields.signature }),
+                    ...(fields.message === undefined ? {} : { message: fields.message }),
+                    ...(fields.diagnostic === undefined ? {} : { diagnostic: safeJson(fields.diagnostic) }),
+                }).catch(() => false);
+            },
+        }, async ({ claim, timeoutMs, beforeSend }) => {
+            const outcome = await input.transport.attempt({ ...request, claimToken: claim.token, attemptN: claim.ordinal }, timeoutMs, beforeSend);
+            return { outcome: outcome.outcome, data: outcome };
+        }, { timeoutMs: leaseMs });
+    };
+    const groups = receivers.values();
+    const settled = await Promise.allSettled(Array.from({ length: Math.min(4, receivers.size) }, async () => {
+        for (const group of groups)
+            for (const candidate of group)
+                await dispatch(candidate);
+    }));
+    // Even an unexpected failure must drain siblings before the caller closes its artifact.
+    for (const result of settled)
+        if (result.status === 'rejected')
+            throw result.reason;
 }
 export async function sweepPending(input) {
     if (input.limit <= 0)

package/dist/delivery-primitives.d.ts

@@ -0,0 +1,5 @@
+/** Storage-independent attempt transitions and bound effect lifecycles. */
+export { claimAttempt, prepareAttempt, settleAttempt, presentationBlocksDispatch, automaticDispatchEligible } from './delivery-attempts.js';
+export type { DeliveryPurpose, AttemptOutcome, Attempt, AttemptRows, AttemptClaim } from './delivery-attempts.js';
+export { dispatchEffect, preparePresentation, presentPrepared, presentPreparedBatch } from './delivery-effects.js';
+export type { EffectClaim, EffectPort, Persistence, Settlement, DispatchOutcome, DispatchCompletion, DispatchContext, DispatchReport, PresentationCompletion, PresentationWork, PreparedPresentation, PresentationControl, PresentationReport } from './delivery-effects.js';

package/dist/delivery-primitives.js

@@ -0,0 +1,3 @@
+/** Storage-independent attempt transitions and bound effect lifecycles. */
+export { claimAttempt, prepareAttempt, settleAttempt, presentationBlocksDispatch, automaticDispatchEligible } from './delivery-attempts.js';
+export { dispatchEffect, preparePresentation, presentPrepared, presentPreparedBatch } from './delivery-effects.js';

package/dist/delivery.d.ts

@@ -40,7 +40,7 @@ export declare function pendingPages(artifact: SquareArtifactPort, scan: Pending
     at: number;
     actor: string;
     recipient: string;
-    route: "bell" | "reply" | "mention" | "attention";
+    route: import("./attention.js").AudienceRoute;
 }[], void, unknown>;
 /** A pass retains only its captured joins; routes and individual receipts are fresh. */
 export declare function pendingFacts(facts: SquareRead, scan: PendingScan, heads: readonly DirectedHead[]): {

package/dist/delivery.js

@@ -1,6 +1,7 @@
 import { renderAttentionPreview, renderSquareReminder } from './attention-presentation.js';
 import { parseActivityId } from './square-core.js';
 import { deliveryDeferralExpiry } from './delivery-deferral.js';
+import { automaticDispatchEligible, presentationBlocksDispatch } from './delivery-attempts.js';
 import { matchesCatchSelection } from './catch-selection.js';
 /** Exact stored activity projection for transports that send an awareness reminder. */
 export function wakePreview(facts, request) {
@@ -8,7 +9,7 @@ export function wakePreview(facts, request) {
     const head = index === undefined ? undefined : pendingHead(facts, request.participant, index);
     const item = index === undefined ? undefined : facts.activity(index);
     const seat = facts.seat(request.participant);
-    if (head === undefined || item?.kind !== 'say' || seat === undefined
+    if (head === undefined || item?.kind !== 'say' || seat === undefined || seat.attachment !== 'attached'
         || deliveryDeferralExpiry(facts, request.seat, item.index, Date.now()) !== undefined)
         return undefined;
     return renderSquareReminder([renderAttentionPreview({
@@ -16,16 +17,16 @@ export function wakePreview(facts, request) {
             actor: item.actor, route: head.route, body: item.body ?? '(structured activity)',
         })]);
 }
+function custody(evidence) {
+    return evidence.map(row => ({ purpose: row.kind === 'wake' ? 'dispatch' : 'presentation', outcome: row.outcome, expiresAt: row.expiresAt }));
+}
 /** Presentation custody blocks a wake, independently of native wake acceptance. */
 export function presentationBlocksWake(evidence, now) {
-    return evidence.some((row) => row.kind === 'presentation'
-        && (row.outcome === 'presented' || row.outcome === 'clipped' || row.outcome === 'unknown'
-            || row.outcome === 'dispatching' && (row.expiresAt === undefined || row.expiresAt > now)));
+    return presentationBlocksDispatch(custody(evidence), now);
 }
 /** Preselection only: an expired wake dispatch is uncertain, never safe automatic replay. */
 export function automaticWakeEligible(evidence, now) {
-    return !presentationBlocksWake(evidence, now) && !evidence.some((row) => row.kind === 'wake'
-        && (row.outcome === 'accepted' || row.outcome === 'unknown' || row.outcome === 'dispatching'));
+    return automaticDispatchEligible(custody(evidence), now);
 }
 /** Notification pending is not cursor suffix or historical catch membership. */
 export function pendingHead(facts, name, index) {