@astrosheep/square 0.3.106 → 0.4.1

package/dist/delivery-effects.js

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

@@ -1,51 +0,0 @@
-import { type DirectedNotificationRoute } from './delivery.js';
-import type { DeliveryEvidence } from './ports.js';
-export interface WakeAttempt {
-    readonly nativeObservations?: readonly NonNullable<DeliveryEvidence['nativeObservations']>[number][];
-    readonly at: number;
-    readonly attention: {
-        readonly squarePath: string;
-        readonly recipient: string;
-        readonly actIndex: number;
-    };
-    readonly routeKind: import('./model.js').WakeRouteKind;
-    readonly outcome: 'accepted' | 'unknown' | 'failed';
-    readonly signature?: string;
-    readonly attemptN: number;
-    readonly message?: string;
-    readonly diagnostic?: unknown;
-}
-export interface WakeReleaseDiagnostic {
-    readonly at: number;
-    readonly attention: {
-        readonly squarePath: string;
-        readonly recipient: string;
-        readonly actIndex: number;
-    };
-    readonly routeKind?: import('./model.js').WakeRouteKind;
-    readonly attemptN?: number;
-    readonly session?: string;
-    readonly signature?: string;
-    readonly message?: string;
-    readonly diagnostic?: unknown;
-}
-export type DeliveryHealthKind = 'awaiting' | 'wake-accepted' | 'wake-unknown' | 'presented-not-delivered' | 'unreachable';
-export interface DeliveryHealthItem {
-    squarePath: string;
-    recipient: string;
-    actIndex: number;
-    actor: string;
-    at: number;
-    ageMs: number;
-    route: DirectedNotificationRoute;
-    kind: DeliveryHealthKind;
-    attempt?: WakeAttempt;
-}
-/** Classify current pending attention from the artifact's seats and delivery evidence. */
-export declare function classifyDeliveryHealth(squarePath: string, opts: {
-    graceMs: number;
-    now?: number;
-    env?: NodeJS.ProcessEnv;
-}): Promise<DeliveryHealthItem[]>;
-export declare function renderDeliveryHealth(items: readonly DeliveryHealthItem[], releases?: readonly WakeReleaseDiagnostic[], now?: number, nativeAttempts?: readonly WakeAttempt[]): string[];
-export declare function doctorDeliveryHealth(squarePath: string, graceMs: number, now?: number, env?: NodeJS.ProcessEnv): Promise<string[]>;

package/dist/delivery-health.js

@@ -1,173 +0,0 @@
-import { collectPending } from './delivery.js';
-import { formatActivityId } from './square-core.js';
-import { participantIdentity, truncateChars } from './presentation.js';
-import { formatDuration } from './time.js';
-import { InternalSquareError, SquareError } from './model.js';
-import { createArtifactPort } from './artifact.js';
-const DISPLAY_ORDER = [
-    'awaiting',
-    'wake-accepted',
-    'wake-unknown',
-    'presented-not-delivered',
-    'unreachable',
-];
-const ACTIONABLE = new Set(['wake-unknown', 'unreachable']);
-const DETAIL_LIMIT = 20;
-const DISPLAY_FIELD_LIMIT = 160;
-/** Classify current pending attention from the artifact's seats and delivery evidence. */
-export async function classifyDeliveryHealth(squarePath, opts) {
-    const now = opts.now ?? Date.now();
-    const artifact = createArtifactPort(squarePath);
-    try {
-        const { pending } = await collectPending(artifact);
-        const current = (await artifact.read((facts) => pending.map((note) => {
-            const seat = facts.seat(note.recipient);
-            const evidence = seat === undefined ? [] : facts.deliveryEvidence(seat.participant, seat.generation, formatActivityId(note.index));
-            return { note, seat, evidence };
-        }))).value;
-        const items = [];
-        for (const { note, seat, evidence } of current) {
-            const ageMs = Math.max(0, now - note.at);
-            const presentation = evidence.some((row) => row.kind === 'presentation' && (row.outcome === 'presented' || row.outcome === 'clipped' || row.outcome === 'unknown'
-                || row.outcome === 'dispatching'));
-            const terminal = evidence.findLast((row) => row.kind === 'wake' && (row.outcome === 'accepted' || row.outcome === 'unknown'));
-            const attemptRow = evidence.findLast((row) => row.kind === 'wake' && (row.outcome === 'accepted' || row.outcome === 'unknown' || row.outcome === 'failed'));
-            const attempt = attemptRow === undefined || seat === undefined ? undefined : deliveryAttempt(squarePath, attemptRow, { squarePath, recipient: seat.participant, actIndex: note.index });
-            const kind = presentation
-                ? 'presented-not-delivered'
-                : terminal?.outcome === 'accepted'
-                    ? 'wake-accepted'
-                    : terminal?.outcome === 'unknown'
-                        ? 'wake-unknown'
-                        : ageMs > opts.graceMs && seat?.wakeAddress === undefined
-                            ? 'unreachable'
-                            : 'awaiting';
-            items.push({
-                squarePath,
-                recipient: note.recipient,
-                actIndex: note.index,
-                actor: note.actor,
-                at: note.at,
-                ageMs,
-                route: note.route,
-                kind,
-                ...(attempt === undefined ? {} : { attempt }),
-            });
-        }
-        // The captured pending set is the ownership boundary: a candidate that was
-        // not pending at the scan cannot become a health item during this read.
-        return items;
-    }
-    catch (error) {
-        if (error instanceof InternalSquareError && error.code === 'not_found')
-            throw new SquareError('unavailable', `Square is unavailable at ${squarePath}`);
-        throw error;
-    }
-    finally {
-        await artifact.close();
-    }
-}
-function displayField(value) {
-    const truncated = truncateChars(value, DISPLAY_FIELD_LIMIT - 1);
-    return truncated.remaining === 0 ? truncated.text : `${truncated.text}…`;
-}
-export function renderDeliveryHealth(items, releases = [], now = Date.now(), nativeAttempts = []) {
-    const out = items.length === 0 ? ['✓ no pending delivery attention'] : [`· delivery attention · ${items.length} pending`];
-    if (items.length > 0) {
-        let displayed = 0;
-        for (const kind of DISPLAY_ORDER) {
-            const group = items.filter((item) => item.kind === kind);
-            if (group.length === 0)
-                continue;
-            out.push(`${ACTIONABLE.has(kind) ? '✕' : '○'} ${kind}: ${group.length}`);
-            const details = group.slice(0, DETAIL_LIMIT - displayed);
-            out.push(...details.map((item) => {
-                const evidence = item.attempt?.signature === undefined ? '' : ` · ${displayField(item.attempt.signature)}`;
-                return `  · ${formatActivityId(item.actIndex)} → ${displayField(participantIdentity(item.recipient))} from ${displayField(participantIdentity(item.actor))} · ${formatDuration(item.ageMs)}${evidence}`;
-            }));
-            displayed += details.length;
-        }
-        if (items.length > DETAIL_LIMIT)
-            out.push(`${DETAIL_LIMIT} of ${items.length} pending details shown`);
-    }
-    if (nativeAttempts.length > 0) {
-        out.push(`· Claude native custody · ${nativeAttempts.length}`);
-        out.push(...nativeAttempts.slice(0, DETAIL_LIMIT).map((attempt) => {
-            const observations = [...attempt.nativeObservations ?? []].sort((a, b) => a.observedAt - b.observedAt);
-            const last = observations.at(-1);
-            const states = observations.map((observation) => `${observation.state}${observation.reason ? ` (${observation.reason})` : ''}`).join(' → ');
-            return `  · ${formatActivityId(attempt.attention.actIndex)} → ${displayField(participantIdentity(attempt.attention.recipient))} · ${attempt.outcome} · native ${displayField(states)} · ${formatDuration(Math.max(0, now - last.observedAt))} · message ${displayField(last.messageId)}`;
-        }));
-        if (nativeAttempts.length > DETAIL_LIMIT)
-            out.push(`${DETAIL_LIMIT} of ${nativeAttempts.length} native custody details shown`);
-    }
-    if (releases.length > 0) {
-        out.push(`· recent wake releases · ${releases.length}`);
-        out.push(...releases.slice(0, DETAIL_LIMIT).map((release) => formatRelease(release, now)));
-        if (releases.length > DETAIL_LIMIT)
-            out.push(`${DETAIL_LIMIT} of ${releases.length} wake releases shown`);
-    }
-    return out;
-}
-function formatRelease(release, now) {
-    const route = displayField(release.routeKind ?? 'unknown route');
-    const reason = displayField(release.signature ?? 'reason not recorded');
-    const age = formatDuration(Math.max(0, now - release.at));
-    const message = release.message === undefined ? '' : ` — ${displayField(release.message)}`;
-    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, attention = { squarePath, recipient: row.participant, actIndex: Number(row.activity.slice(4)) }) {
-    if (row.route?.kind === undefined || row.outcome === 'released' || row.outcome === 'dispatching')
-        return undefined;
-    return {
-        at: row.at,
-        attention,
-        routeKind: row.route.kind,
-        outcome: row.outcome,
-        attemptN: row.attemptN,
-        ...(row.signature === undefined ? {} : { signature: row.signature }),
-        ...(row.message === undefined ? {} : { message: row.message }),
-        ...(row.diagnostic === undefined ? {} : { diagnostic: row.diagnostic }),
-        ...(row.nativeObservations === undefined ? {} : { nativeObservations: row.nativeObservations }),
-    };
-}
-function deliveryRelease(squarePath, row) {
-    return {
-        at: row.at,
-        attention: { squarePath, recipient: row.participant, actIndex: Number(row.activity.slice(4)) },
-        routeKind: row.route?.kind,
-        attemptN: row.attemptN,
-        ...(row.signature === undefined ? {} : { signature: row.signature }),
-        ...(row.message === undefined ? {} : { message: row.message }),
-        ...(row.diagnostic === undefined ? {} : { diagnostic: row.diagnostic }),
-    };
-}
-export async function doctorDeliveryHealth(squarePath, graceMs, now = Date.now(), env = process.env) {
-    const items = await classifyDeliveryHealth(squarePath, { graceMs, now, env });
-    const artifact = createArtifactPort(squarePath);
-    try {
-        const { value: rows } = await artifact.read((facts) => facts.roster().flatMap((participant) => {
-            const seat = facts.seat(participant.name);
-            return seat === undefined ? [] : facts.deliveryEvidence(seat.participant, seat.generation);
-        }));
-        const releases = rows.filter((row) => row.kind === 'wake' && row.outcome === 'released')
-            .map((row) => deliveryRelease(squarePath, row))
-            .sort((left, right) => right.at - left.at);
-        const nativeAttempts = rows.flatMap((row) => {
-            if (row.kind !== 'wake' || row.nativeObservations?.length === 0)
-                return [];
-            const attempt = deliveryAttempt(squarePath, row);
-            return attempt?.nativeObservations?.length ? [attempt] : [];
-        }).sort((a, b) => Math.max(...b.nativeObservations.map((row) => row.observedAt)) - Math.max(...a.nativeObservations.map((row) => row.observedAt)));
-        return renderDeliveryHealth(items, releases, now, nativeAttempts);
-    }
-    catch (error) {
-        if (error instanceof InternalSquareError && error.code === 'not_found')
-            throw new SquareError('unavailable', `Square is unavailable at ${squarePath}`);
-        throw error;
-    }
-    finally {
-        await artifact.close();
-    }
-}

package/dist/delivery-operations.d.ts

@@ -1,9 +0,0 @@
-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;
-    readonly now: number;
-    readonly graceMs: number;
-    readonly limit: number;
-}): Promise<number[]>;

package/dist/delivery-operations.js

@@ -1,168 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { formatActivityId, parseActivityId } from './square-core.js';
-import { pendingHead, pendingHeads, pendingRecipients, presentationBlocksWake } from './delivery.js';
-import { asSeatRef } from './seats.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.attachment !== 'attached' || seat.wakeAddress === undefined)
-        return undefined;
-    return {
-        location, participant: seat.participant,
-        kind: seat.wakeAddress.kind, address: { ...seat.wakeAddress.address }, updatedAt: now,
-    };
-}
-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.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);
-        const head = pendingHead(facts, request.participant, index);
-        const activityPending = seatCurrent && head !== undefined;
-        const cancelledThrough = facts.cancelledThrough(request.participant, request.seat.generation);
-        const cancelled = cancelledThrough !== undefined && index <= cancelledThrough;
-        const evidence = facts.deliveryEvidence(request.participant, request.seat.generation, formatActivityId(index));
-        const presented = presentationBlocksWake(evidence, now);
-        const lease = freshWatchLease(facts, request.participant, now);
-        const caught = head !== undefined && lease !== undefined && leaseOwnsNotification(lease, {
-            actor: request.actor, route: head.route, recipient: request.participant,
-        });
-        const deferred = deliveryDeferralExpiry(facts, request.seat, index, now) !== undefined;
-        return { current: activityPending && !cancelled && !presented && !caught && !deferred, activityPending, seatCurrent, cancelled, presented };
-    });
-    return value;
-}
-async function candidates(artifact, requested, now = Date.now()) {
-    const { value } = await artifact.read((facts) => {
-        const heads = requested === undefined
-            ? facts.roster().flatMap((participant) => participant.joined ? pendingHeads(facts, participant.name) : [])
-            : pendingRecipients(facts, requested);
-        return heads.flatMap((head) => {
-            const seat = facts.seat(head.recipient);
-            return seat === undefined || seat.attachment !== 'attached' || deliveryDeferralExpiry(facts, seat, head.index, now) !== undefined ? [] : [{ seat, head }];
-        });
-    });
-    return value;
-}
-function safeJson(value) {
-    if (value === null || typeof value === 'string' || typeof value === 'boolean' || typeof value === 'number')
-        return value;
-    if (Array.isArray(value))
-        return value.map(safeJson);
-    if (typeof value === 'object')
-        return Object.fromEntries(Object.entries(value)
-            .filter(([, item]) => item !== undefined).map(([key, item]) => [key, safeJson(item)]));
-    return String(value);
-}
-export async function deliverPending(input) {
-    // 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;
-    const pending = await candidates(input.artifact, requested, input.now ?? Date.now());
-    // 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)
-            return;
-        const request = {
-            location, participant: seat.participant, activity: formatActivityId(head.index), actor: head.actor,
-            seat: asSeatRef(seat), route,
-            artifact: input.artifact,
-        };
-        if (input.transport.probe !== undefined) {
-            try {
-                const probe = await input.transport.probe(route);
-                if (probe === false || typeof probe === 'object' && probe.outcome === 'not-capable')
-                    return;
-            }
-            catch {
-                return;
-            }
-        }
-        const claimToken = randomUUID();
-        const leaseMs = input.timeoutMs ?? 5000;
-        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)
-        return [];
-    const pending = await candidates(input.artifact, undefined, input.now);
-    const selected = [];
-    for (const { head } of pending) {
-        if (input.now - head.at <= input.graceMs)
-            continue;
-        if (!selected.includes(head.index))
-            selected.push(head.index);
-        if (selected.length >= input.limit)
-            break;
-    }
-    return selected;
-}

package/dist/delivery-primitives.d.ts

@@ -1,5 +0,0 @@
-/** 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

@@ -1,3 +0,0 @@
-/** 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

@@ -1,45 +0,0 @@
-import type { DirectedNotificationRoute, WatchLease } from './model.js';
-import type { DeliveryEvidence, DirectedHead, ParticipantFact, SquareArtifactPort, SquareRead, WakeRequest } from './ports.js';
-export type { DirectedNotificationRoute } from './model.js';
-/** Exact stored activity projection for transports that send an awareness reminder. */
-export declare function wakePreview(facts: SquareRead, request: WakeRequest): string | undefined;
-export interface RoutedNotification {
-    actor: string;
-    route: DirectedNotificationRoute;
-    recipient: string;
-}
-/** Presentation custody blocks a wake, independently of native wake acceptance. */
-export declare function presentationBlocksWake(evidence: readonly DeliveryEvidence[], now: number): boolean;
-/** Preselection only: an expired wake dispatch is uncertain, never safe automatic replay. */
-export declare function automaticWakeEligible(evidence: readonly DeliveryEvidence[], now: number): boolean;
-/** Notification pending is not cursor suffix or historical catch membership. */
-export declare function pendingHead(facts: SquareRead, name: string, index: number): DirectedHead | undefined;
-/** One activity's landed recipients that still owe a wake; the rest of the roster is untouched. */
-export declare function pendingRecipients(facts: SquareRead, index: number): DirectedHead[];
-/** Still-pending directed heads for one recipient, oldest first. Bodies belong to presentation. */
-export declare function pendingHeads(facts: SquareRead, name: string): DirectedHead[];
-export interface PendingScan {
-    readonly roster: readonly ParticipantFact[];
-    readonly throughIndex: number;
-}
-export declare function capturePendingScan(facts: SquareRead): PendingScan;
-export declare function sameJoin(facts: SquareRead, captured: ParticipantFact): boolean;
-/** Finite bodyless pass: unrelated revisions never rewind the last examined group. */
-export declare function pendingPages(artifact: SquareArtifactPort, scan: PendingScan, afterIndex?: number): AsyncGenerator<{
-    index: number;
-    at: number;
-    actor: string;
-    recipient: string;
-    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[]): {
-    pending: DirectedHead[];
-};
-/** Global discovery alone sweeps pendingAudience; exact dispatch uses pendingRecipients. */
-export declare function collectPending(artifact: SquareArtifactPort): Promise<{
-    pending: DirectedHead[];
-    scan: PendingScan;
-}>;
-/** A live catch owns every matching notification, independent of its page size. */
-export declare function leaseOwnsNotification(lease: WatchLease, notification: RoutedNotification): boolean;