@astrosheep/square 0.4.0 → 0.4.1

package/dist/delivery-health.js

@@ -1,173 +0,0 @@
-import { collectPending } from './delivery.js';
-import { formatMessageId, parseMessageId } from './message.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, formatMessageId(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, messageIndex: 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,
-                messageIndex: 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 `  · ${formatMessageId(item.messageIndex)} → ${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 `  · ${formatMessageId(attempt.attention.messageIndex)} → ${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 `  · ${formatMessageId(release.attention.messageIndex)} → ${displayField(participantIdentity(release.attention.recipient))} · ${route} · ${reason} · ${age}${message}${diagnostic}`;
-}
-function deliveryAttempt(squarePath, row, attention = { squarePath, recipient: row.participant, messageIndex: parseMessageId(row.message) ?? 0 }) {
-    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.messageText === undefined ? {} : { message: row.messageText }),
-        ...(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, messageIndex: parseMessageId(row.message) ?? 0 },
-        routeKind: row.route?.kind,
-        attemptN: row.attemptN,
-        ...(row.signature === undefined ? {} : { signature: row.signature }),
-        ...(row.messageText === undefined ? {} : { message: row.messageText }),
-        ...(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,22 +0,0 @@
-import type { ChannelArtifact } from './channel-ports.js';
-import type { WakeProjection, WakeProjectionContext, WakeRequest, WakeTransportPort } from './channel-transport.js';
-interface DeliverPendingInput {
-    readonly artifact: ChannelArtifact;
-    readonly preparePresentation?: WakeProjection;
-    readonly transport: WakeTransportPort;
-    readonly location: string;
-    readonly timeoutMs?: number;
-    readonly now?: number;
-    readonly message?: string | number;
-}
-/** Standalone Channel projection; final send currentness is still checked by the dispatcher. */
-export declare function channelWakePreview(artifact: ChannelArtifact, request: WakeProjectionContext, signal?: AbortSignal): Promise<NonNullable<WakeRequest['presentation']> | undefined>;
-export declare function deliverPending(input: DeliverPendingInput): Promise<void>;
-export declare function sweepPending(input: {
-    readonly artifact: ChannelArtifact;
-    readonly location: string;
-    readonly now: number;
-    readonly graceMs: number;
-    readonly limit: number;
-}): Promise<number[]>;
-export {};

package/dist/delivery-operations.js

@@ -1,198 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { formatMessageId, parseMessageId } from './message.js';
-import { pendingAddresses, pendingHeadAt, pendingMessageHeads, presentationBlocksWake } from './channel-delivery.js';
-import { deliveryDeferralExpiry } from './delivery-deferral.js';
-import { dispatchEffect } from './delivery-effects.js';
-import { projectChannelNotification, renderSquareReminder } from './channel-presentation.js';
-/** Standalone Channel projection; final send currentness is still checked by the dispatcher. */
-export async function channelWakePreview(artifact, request, signal) {
-    const index = parseMessageId(request.message);
-    if (index === undefined)
-        return undefined;
-    return (await artifact.read(facts => {
-        const seat = facts.endpoint(request.participant);
-        const now = Date.now();
-        if (seat === undefined || seat.attachment !== 'attached' || seat.owner !== request.seat.owner
-            || seat.generation !== request.seat.generation || pendingHeadAt(facts, request.participant, index, now) === undefined
-            || deliveryDeferralExpiry(facts, request.seat, index, now) !== undefined)
-            return undefined;
-        const item = facts.message(index);
-        if (item === undefined)
-            return undefined;
-        const projected = projectChannelNotification({ squarePath: request.location, recipient: request.participant,
-            actor: item.from, body: item.body, ...(item.preview === undefined ? {} : { preview: item.preview }) });
-        return { payload: renderSquareReminder([projected.text]), coverage: projected.clipped ? 'clipped' : 'full' };
-    }, signal)).value;
-}
-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 = parseMessageId(request.message);
-    const { value } = await artifact.read((facts) => {
-        const currentSeat = facts.endpoint(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 = pendingHeadAt(facts, request.participant, index, now);
-        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, formatMessageId(index));
-        const presented = presentationBlocksWake(evidence, now);
-        const deferred = deliveryDeferralExpiry(facts, request.seat, index, now) !== undefined;
-        return { current: activityPending && !cancelled && !presented && !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.endpoints().filter(endpoint => endpoint.attachment === 'attached').flatMap(endpoint => pendingMessageHeads(facts, endpoint.participant, now))
-            : pendingAddresses(facts, requested, now);
-        return heads.flatMap(head => {
-            const seat = facts.endpoint(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 named = input.message;
-    const requested = named === undefined ? undefined : typeof named === 'number' ? named : parseMessageId(named);
-    if (named !== 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, message: formatMessageId(head.index), actor: head.from,
-            seat: { participant: seat.participant, owner: seat.owner, generation: seat.generation }, route,
-        };
-        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, message: request.message, 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, message: request.message, claimToken: claim.token,
-                    outcome: completion.outcome, at: Date.now(),
-                    ...(fields.signature === undefined ? {} : { signature: fields.signature }),
-                    ...(fields.message === undefined ? {} : { messageText: fields.message }),
-                    ...(fields.diagnostic === undefined ? {} : { diagnostic: safeJson(fields.diagnostic) }),
-                }).catch(() => false);
-            },
-        }, async ({ claim, deadline, beforeSend }) => {
-            const { location, participant, message, actor, seat, route } = request;
-            const prepared = input.preparePresentation === undefined
-                ? await channelWakePreview(input.artifact, request)
-                : await input.preparePresentation({ location, participant, message, actor, seat, route });
-            if (prepared === undefined)
-                return { outcome: 'not-capable', data: { diagnostic: 'The pending presentation is no longer current.' } };
-            const remaining = deadline - Date.now();
-            if (remaining <= 0)
-                return { outcome: 'not-capable', data: { diagnostic: 'The presentation budget elapsed before transport.' } };
-            const presentation = prepared;
-            const preparationSeat = Object.freeze({ ...request.seat });
-            const channel = { prepare: (details, signal) => input.artifact.prepareDelivery({
-                    seat: preparationSeat, claimToken: claim.token, correlation: details.correlation,
-                    coverage: details.coverage, description: details.description,
-                }, signal) };
-            const outcome = await input.transport.attempt({ ...request, seat: { ...request.seat }, channel, claimToken: claim.token, attemptN: claim.ordinal,
-                ...(presentation === undefined ? {} : { presentation }) }, remaining, 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,56 +0,0 @@
-import type { DirectedNotificationRoute, Owner, WakeAddress } from './model.js';
-import type { SquareArtifactPort, SquareRead, EndpointGeneration } from './ports.js';
-import { formatMessageId } from './message.js';
-export type { DirectedNotificationRoute } from './model.js';
-/** One lower pending message plus its upper reason when an Agora say created it. */
-export interface PendingMessage {
-    readonly index: number;
-    readonly at: number;
-    readonly actor: string;
-    readonly recipient: string;
-    readonly generation?: EndpointGeneration;
-    /** Agora activity that shares this message, when one exists. */
-    readonly activityIndex?: number;
-    readonly route?: DirectedNotificationRoute;
-}
-export { pendingHeadAt, pendingMessageHeads, pendingAddresses, presentationBlocksWake, automaticWakeEligible } from './channel-delivery.js';
-/** Notification pending is not cursor suffix or historical catch membership. */
-export declare function pendingHead(facts: SquareRead, name: string, index: number, now?: number): PendingMessage | undefined;
-/** Current native eligibility shared by wake selection, preview and ACK. */
-export interface NativePendingInput {
-    readonly location: string;
-    readonly participant: string;
-    readonly generation: EndpointGeneration;
-    readonly owner?: Owner;
-    readonly index: number;
-    readonly route: WakeAddress;
-    readonly now: number;
-    readonly cancelledThrough?: number;
-}
-export declare function nativePendingHead(facts: SquareRead, input: NativePendingInput): PendingMessage | undefined;
-/** Still-pending directed messages for one recipient, oldest first. Bodies belong to presentation. */
-export declare function pendingHeads(facts: SquareRead, name: string, now?: number, suppress?: boolean): PendingMessage[];
-export interface PendingScan {
-    readonly roster: readonly {
-        readonly name: string;
-        readonly generation?: string;
-    }[];
-    readonly throughIndex: number;
-}
-export declare function capturePendingScan(facts: SquareRead): PendingScan;
-export declare function sameJoin(facts: SquareRead, captured: {
-    readonly name: string;
-    readonly generation?: string;
-}): boolean;
-/** Finite bodyless pass: unrelated revisions never rewind the last examined message. */
-export declare function pendingPages(artifact: SquareArtifactPort, scan: PendingScan, afterIndex?: number): AsyncGenerator<PendingMessage[], 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 PendingMessage[]): {
-    pending: PendingMessage[];
-};
-/** Global discovery alone sweeps every endpoint; exact dispatch uses pendingAddresses. */
-export declare function collectPending(artifact: SquareArtifactPort): Promise<{
-    pending: PendingMessage[];
-    scan: PendingScan;
-}>;
-export { formatMessageId };

package/dist/delivery.js

@@ -1,80 +0,0 @@
-import { formatMessageId } from './message.js';
-import { deliveryDeferralExpiry } from './delivery-deferral.js';
-export { pendingHeadAt, pendingMessageHeads, pendingAddresses, presentationBlocksWake, automaticWakeEligible } from './channel-delivery.js';
-import { pendingHeadAt, pendingMessageHeads } from './channel-delivery.js';
-/** Upper enrichment: the reason this recipient was reached, when an Agora say owns the message. */
-function enriched(facts, head) {
-    const relation = facts.activityByMessage(head.index);
-    return { index: head.index, at: head.at, actor: head.from, recipient: head.recipient,
-        ...(head.generation === undefined ? {} : { generation: head.generation }),
-        ...(relation === undefined ? {} : { activityIndex: relation.index, route: facts.directedAt(head.recipient, relation.index)?.route }) };
-}
-/** Notification pending is not cursor suffix or historical catch membership. */
-export function pendingHead(facts, name, index, now = Date.now()) {
-    const head = pendingHeadAt(facts.channel, name, index, now);
-    return head === undefined ? undefined : enriched(facts, head);
-}
-export function nativePendingHead(facts, input) {
-    const seat = facts.channel.endpoint(input.participant);
-    if (seat === undefined || seat.attachment !== 'attached' || seat.generation !== input.generation
-        || input.owner !== undefined && seat.owner !== input.owner
-        || !sameWakeAddress(seat.wakeAddress, input.route))
-        return undefined;
-    const cancelledThrough = facts.channel.cancelledThrough(seat.participant, seat.generation);
-    if (input.index <= Math.max(input.cancelledThrough ?? -1, cancelledThrough ?? -1))
-        return undefined;
-    if (deliveryDeferralExpiry(facts.channel, seat, input.index, input.now) !== undefined)
-        return undefined;
-    return pendingHead(facts, seat.participant, input.index, input.now);
-}
-/** Still-pending directed messages for one recipient, oldest first. Bodies belong to presentation. */
-export function pendingHeads(facts, name, now = Date.now(), suppress = true) {
-    return pendingMessageHeads(facts.channel, name, now, suppress).map(head => enriched(facts, head));
-}
-export function capturePendingScan(facts) {
-    return { roster: facts.channel.endpoints().filter(endpoint => endpoint.attachment === 'attached').map(endpoint => ({ name: endpoint.participant, generation: endpoint.generation })),
-        throughIndex: facts.channel.header().lastMessageIndex };
-}
-export function sameJoin(facts, captured) {
-    const current = facts.channel.endpoint(captured.name);
-    return current?.attachment === 'attached' && current.generation === captured.generation;
-}
-/** Finite bodyless pass: unrelated revisions never rewind the last examined message. */
-export async function* pendingPages(artifact, scan, afterIndex = -1) {
-    const captured = new Map(scan.roster.map((participant) => [participant.name, participant]));
-    let cursor = afterIndex;
-    while (cursor < scan.throughIndex) {
-        const { value: page } = await artifact.read((facts) => {
-            const items = facts.channel.endpoints().filter(endpoint => endpoint.attachment === 'attached' && captured.has(endpoint.participant)).flatMap(endpoint => facts.channel.directed(endpoint.participant, { afterIndex: cursor, throughIndex: scan.throughIndex, unseenOnly: true, currentGeneration: true }, { edge: 'oldest', limit: 100 }).items
-                .filter(() => sameJoin(facts, captured.get(endpoint.participant)))
-                .map(head => enriched(facts, head)));
-            return { items, next: items.at(-1)?.index, done: items.length === 0 };
-        });
-        yield page.items;
-        if (page.done || page.next === undefined)
-            break;
-        cursor = page.next;
-    }
-}
-/** A pass retains only its captured joins; routes and individual receipts are fresh. */
-export function pendingFacts(facts, scan, heads) {
-    const joined = new Set(scan.roster.filter((participant) => sameJoin(facts, participant)).map((participant) => participant.name));
-    return { pending: heads.filter((head) => joined.has(head.recipient)
-            && pendingHeadAt(facts.channel, head.recipient, head.index) !== undefined) };
-}
-/** Global discovery alone sweeps every endpoint; exact dispatch uses pendingAddresses. */
-export async function collectPending(artifact) {
-    const { value: scan } = await artifact.read(capturePendingScan);
-    const pending = [];
-    for await (const page of pendingPages(artifact, scan))
-        pending.push(...page);
-    const { value } = await artifact.read((facts) => ({ scan, ...pendingFacts(facts, scan, pending) }));
-    return value;
-}
-function sameWakeAddress(left, right) {
-    if (left === undefined || right === undefined || left.kind !== right.kind)
-        return false;
-    const keys = Object.keys(left.address);
-    return keys.length === Object.keys(right.address).length && keys.every(key => left.address[key] === right.address[key]);
-}
-export { formatMessageId };

package/dist/plugins/opencode/delivery.d.ts

@@ -1,19 +0,0 @@
-import { type OpenCodeNativeSession } from '../../packages/agent-delivery/src/opencode-native.js';
-export interface OpenCodeContextMessage {
-    readonly id?: string;
-    readonly role: string;
-    readonly content: readonly {
-        readonly type: string;
-        readonly text?: string;
-    }[];
-}
-export declare function indexedOpenCodeSessions(env: NodeJS.ProcessEnv): Promise<readonly string[]>;
-export declare function discoverOpenCodeSeats(sessionId: string, env: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<import("../../model.js").LocatedSeat[]>;
-/** The exact prepared native message can authorize artifact-backed presentation once. */
-export declare function observeOpenCodeContext(sessionId: string, messages: readonly OpenCodeContextMessage[], env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void>;
-/** The native receiver owns no claims outside the artifact; HOME is used only for discovery. */
-export declare function receiveOpenCodePending(target: OpenCodeNativeSession, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void>;
-/** Publish the native address into current artifact seats; the legacy route projection is not read. */
-export declare function publishOpenCodeAddress(sessionId: string, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<boolean>;
-export declare function cancelOpenCodeDeliveries(sessionId: string, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void>;
-export declare function endOpenCodeSession(sessionId: string, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void>;