@astrosheep/square 0.3.106 → 0.4.0

package/dist/cli/program.js

@@ -9,7 +9,7 @@ async function handleSquareError(error, context) {
         throw error;
     const detail = error.operation;
     const squarePath = context?.squarePath;
-    const recovery = error.facts?.reason === 'migration_required' || context === undefined || squarePath === undefined ? undefined
+    const recovery = context === undefined || squarePath === undefined ? undefined
         : await withSquare({ ...context, name: detail?.participant ?? context.name }, (square) => square.recovery(detail?.participant ?? context.name)).catch(() => undefined);
     const name = detail?.participant ?? recovery?.participant ?? context?.name;
     const lines = renderFailureLines(error, { squarePath, name, owner: context?.owner ?? context?.env.SQUARE_OWNER });

package/dist/cli/registry.js

@@ -1,5 +1,5 @@
 import { buildCommand, doneCommand, expressCommand, ignoreCommand, joinCommand, listenCommand, listeningCommand, unlistenCommand } from './square-commands.js';
-import { doctorCommand, migrateCommand } from './maintenance-commands.js';
+import { doctorCommand } from './maintenance-commands.js';
 import { harnessCommand, installCommand, uninstallCommand } from './harness-command.js';
 import { helpCommand, versionCommand } from './meta-commands.js';
 import { mcpServerCommand } from './mcp-server-command.js';
@@ -25,7 +25,6 @@ export const commandRegistry = [
     { names: ['uninstall'], spec: uninstallCommand },
     { names: ['harness'], spec: harnessCommand },
     { names: ['doctor'], spec: doctorCommand },
-    { names: ['migrate'], spec: migrateCommand },
     { names: ['history'], spec: historyCommand },
     { names: ['status'], spec: statusCommand },
     { names: ['participants'], spec: participantsCommand },

package/dist/codex-address.d.ts

@@ -1,3 +1,3 @@
-import type { WakeAddress } from './model.js';
+import type { WakeAddress } from './channel-values.js';
 /** Capture the receiver's CLI configuration when its seat is established, not at send time. */
 export declare function codexWakeAddress(threadId: string, env: NodeJS.ProcessEnv): WakeAddress;

package/dist/codex-queue.d.ts

@@ -1,8 +1,8 @@
 import { type CodexCliAgent, type CodexCliConnectOptions } from './packages/agent-delivery/src/index.js';
 export { sendCodexQueue, CodexQueueSendError } from './packages/agent-delivery/src/codex-queue.js';
 export type { CodexQueueRequest, CodexQueueFailureKind } from './packages/agent-delivery/src/codex-queue.js';
-import type { WakeRequest, WakeOutcome, WakeTransportPort } from './ports.js';
-import type { WakeRoute } from './model.js';
+import type { WakeRequest, WakeOutcome, WakeTransportPort } from './channel-transport.js';
+import type { WakeRoute } from './channel-values.js';
 export interface CodexQueueTransportOptions {
     env?: NodeJS.ProcessEnv;
     connect?: (options: CodexCliConnectOptions) => Promise<CodexCliAgent>;

package/dist/codex-queue.js

@@ -1,7 +1,6 @@
 import { connect, DeliveryError } from './packages/agent-delivery/src/index.js';
 export { sendCodexQueue, CodexQueueSendError } from './packages/agent-delivery/src/codex-queue.js';
 import { codexBoundaryStore } from './codex-boundary-state.js';
-import { wakePreview } from './delivery.js';
 export class CodexQueueTransport {
     opts;
     constructor(opts = {}) {
@@ -15,8 +14,7 @@ export class CodexQueueTransport {
             return { outcome: 'failed', signature: 'invalid_address', message: 'Codex route has no thread id.' };
         }
         const env = this.opts.env ?? process.env;
-        const payload = request.artifact === undefined ? undefined
-            : (await request.artifact.read((facts) => wakePreview(facts, request))).value;
+        const payload = request.presentation?.payload;
         if (payload === undefined)
             return { outcome: 'not-capable', diagnostic: 'No pending Square activity to preview.' };
         if (!(await beforeSend()))

package/dist/decisions.js

@@ -51,7 +51,7 @@ export function unreadActivitySummaries(facts, name, now) {
     let afterIndex = readCursor(facts, name);
     const summaries = new Map();
     while (true) {
-        const page = facts.directed(name, { afterIndex }, { edge: 'oldest', limit: FACT_PAGE_SIZE });
+        const page = facts.directed(name, { afterIndex, kinds: ['say'] }, { edge: 'oldest', limit: FACT_PAGE_SIZE });
         for (const item of page.items) {
             const summary = summaries.get(item.actor) ?? { count: 0, latestAt: -Infinity, lastIndex: item.index };
             summary.count++;
@@ -194,8 +194,8 @@ export function coreParticipants(facts, now) {
             activityCount: current.sayCount, lastActiveAt,
             presence: current.done ? 'done' : !current.joined ? 'never-joined' : facts.seat(current.name)?.attachment === 'detached' ? 'away'
                 : freshWatchLease(facts, current.name, now) !== undefined ? 'watching' : 'active',
-            unreadActivityCount: current.joined ? facts.directedCount(current.name, { afterIndex: readCursor(facts, current.name) }) : 0,
-            pendingMentionCount: current.joined ? facts.directedCount(current.name, { afterIndex: current.lastJoinIndex ?? -1, unseenOnly: true }) : 0,
+            unreadActivityCount: current.joined ? facts.directedCount(current.name, { kinds: ['say'], afterIndex: readCursor(facts, current.name) }) : 0,
+            pendingMentionCount: current.joined ? facts.directedCount(current.name, { kinds: ['say'], afterIndex: current.lastJoinIndex ?? -1, unseenOnly: true }) : 0,
         };
     }).sort(compareParticipantActivity);
 }

package/dist/delivery-deferral.d.ts

@@ -1,19 +1,10 @@
-import { type ActivityMetadata, type ActivityId } from './model.js';
-import type { SeatRef, SquareRead } from './ports.js';
-export type MetadataScalar = null | boolean | number | string;
-export interface MetadataMatch {
-    readonly fields: readonly Readonly<{
-        path: readonly string[];
-        equals: MetadataScalar;
-    }>[];
-}
-export interface DeliveryDeferral {
-    readonly id: string;
-    readonly expiresAt: string;
-}
+import type { MessageMetadata } from './channel-values.js';
+import type { ChannelRead, EndpointRef } from './channel-ports.js';
+import type { MetadataMatch } from './channel-metadata.js';
+export type { MetadataMatch, MetadataScalar, DeliveryDeferral } from './channel-metadata.js';
 export interface DeliveryDeferralFact {
     readonly participant: string;
-    readonly generation: ActivityId;
+    readonly generation: string;
     readonly id: string;
     readonly match: MetadataMatch;
     readonly expiresAt: number;
@@ -22,7 +13,7 @@ export declare const MAX_DELIVERY_DEFERRAL_MS: number;
 export declare function validateMetadataMatch(value: unknown): MetadataMatch;
 export declare function validateDeferralDuration(value: unknown): number;
 export declare function validateDeferralId(value: unknown): string;
-export declare function matchesMetadata(metadata: ActivityMetadata | undefined, match: MetadataMatch): boolean;
-export declare function matchingDeferrals(deferrals: readonly DeliveryDeferralFact[], metadata: ActivityMetadata | undefined, now: number): readonly DeliveryDeferralFact[];
-export declare function deliveryDeferralExpiry(facts: SquareRead, captured: SeatRef, index: number, now: number): number | undefined;
-export declare function earliestMatchingDeferralExpiry(deferrals: readonly DeliveryDeferralFact[], metadata: ActivityMetadata | undefined, now: number): number | undefined;
+export declare function matchesMetadata(metadata: MessageMetadata | undefined, match: MetadataMatch): boolean;
+export declare function matchingDeferrals(deferrals: readonly DeliveryDeferralFact[], metadata: MessageMetadata | undefined, now: number): readonly DeliveryDeferralFact[];
+export declare function deliveryDeferralExpiry(facts: ChannelRead, captured: EndpointRef, index: number, now: number): number | undefined;
+export declare function earliestMatchingDeferralExpiry(deferrals: readonly DeliveryDeferralFact[], metadata: MessageMetadata | undefined, now: number): number | undefined;

package/dist/delivery-deferral.js

@@ -1,4 +1,4 @@
-import { SquareError } from './model.js';
+import { SquareError } from './neutral.js';
 export const MAX_DELIVERY_DEFERRAL_MS = 24 * 60 * 60 * 1000;
 export function validateMetadataMatch(value) {
     const fail = () => { throw new SquareError('invalid_args', 'Invalid metadata match.'); };
@@ -68,14 +68,14 @@ export function matchingDeferrals(deferrals, metadata, now) {
     return deferrals.filter((lease) => lease.expiresAt > now && matchesMetadata(metadata, lease.match));
 }
 export function deliveryDeferralExpiry(facts, captured, index, now) {
-    const seat = facts.seat(captured.participant);
+    const seat = facts.endpoint(captured.participant);
     if (seat === undefined || seat.generation !== captured.generation || seat.owner !== captured.owner)
         return undefined;
     const leases = facts.deliveryDeferrals(seat.participant, seat.generation);
     if (!leases.some(lease => lease.expiresAt > now))
         return undefined;
-    const activity = facts.activity(index);
-    return activity?.kind === 'say' ? earliestMatchingDeferralExpiry(leases, activity.metadata, now) : undefined;
+    const message = facts.message(index);
+    return message === undefined ? undefined : earliestMatchingDeferralExpiry(leases, message.metadata, now);
 }
 export function earliestMatchingDeferralExpiry(deferrals, metadata, now) {
     const matches = matchingDeferrals(deferrals, metadata, now);

package/dist/delivery-health.d.ts

@@ -6,7 +6,7 @@ export interface WakeAttempt {
     readonly attention: {
         readonly squarePath: string;
         readonly recipient: string;
-        readonly actIndex: number;
+        readonly messageIndex: number;
     };
     readonly routeKind: import('./model.js').WakeRouteKind;
     readonly outcome: 'accepted' | 'unknown' | 'failed';
@@ -20,7 +20,7 @@ export interface WakeReleaseDiagnostic {
     readonly attention: {
         readonly squarePath: string;
         readonly recipient: string;
-        readonly actIndex: number;
+        readonly messageIndex: number;
     };
     readonly routeKind?: import('./model.js').WakeRouteKind;
     readonly attemptN?: number;
@@ -33,11 +33,11 @@ export type DeliveryHealthKind = 'awaiting' | 'wake-accepted' | 'wake-unknown' |
 export interface DeliveryHealthItem {
     squarePath: string;
     recipient: string;
-    actIndex: number;
+    messageIndex: number;
     actor: string;
     at: number;
     ageMs: number;
-    route: DirectedNotificationRoute;
+    route?: DirectedNotificationRoute;
     kind: DeliveryHealthKind;
     attempt?: WakeAttempt;
 }

package/dist/delivery-health.js

@@ -1,5 +1,5 @@
 import { collectPending } from './delivery.js';
-import { formatActivityId } from './square-core.js';
+import { formatMessageId, parseMessageId } from './message.js';
 import { participantIdentity, truncateChars } from './presentation.js';
 import { formatDuration } from './time.js';
 import { InternalSquareError, SquareError } from './model.js';
@@ -22,7 +22,7 @@ export async function classifyDeliveryHealth(squarePath, opts) {
         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));
+            const evidence = seat === undefined ? [] : facts.deliveryEvidence(seat.participant, seat.generation, formatMessageId(note.index));
             return { note, seat, evidence };
         }))).value;
         const items = [];
@@ -32,7 +32,7 @@ export async function classifyDeliveryHealth(squarePath, opts) {
                 || 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 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'
@@ -45,7 +45,7 @@ export async function classifyDeliveryHealth(squarePath, opts) {
             items.push({
                 squarePath,
                 recipient: note.recipient,
-                actIndex: note.index,
+                messageIndex: note.index,
                 actor: note.actor,
                 at: note.at,
                 ageMs,
@@ -83,7 +83,7 @@ export function renderDeliveryHealth(items, releases = [], now = Date.now(), nat
             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}`;
+                return `  · ${formatMessageId(item.messageIndex)} → ${displayField(participantIdentity(item.recipient))} from ${displayField(participantIdentity(item.actor))} · ${formatDuration(item.ageMs)}${evidence}`;
             }));
             displayed += details.length;
         }
@@ -96,7 +96,7 @@ export function renderDeliveryHealth(items, releases = [], now = Date.now(), nat
             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)}`;
+            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`);
@@ -115,9 +115,9 @@ function formatRelease(release, now) {
     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}`;
+    return `  · ${formatMessageId(release.attention.messageIndex)} → ${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)) }) {
+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 {
@@ -127,7 +127,7 @@ function deliveryAttempt(squarePath, row, attention = { squarePath, recipient: r
         outcome: row.outcome,
         attemptN: row.attemptN,
         ...(row.signature === undefined ? {} : { signature: row.signature }),
-        ...(row.message === undefined ? {} : { message: row.message }),
+        ...(row.messageText === undefined ? {} : { message: row.messageText }),
         ...(row.diagnostic === undefined ? {} : { diagnostic: row.diagnostic }),
         ...(row.nativeObservations === undefined ? {} : { nativeObservations: row.nativeObservations }),
     };
@@ -135,11 +135,11 @@ function deliveryAttempt(squarePath, row, attention = { squarePath, recipient: r
 function deliveryRelease(squarePath, row) {
     return {
         at: row.at,
-        attention: { squarePath, recipient: row.participant, actIndex: Number(row.activity.slice(4)) },
+        attention: { squarePath, recipient: row.participant, messageIndex: parseMessageId(row.message) ?? 0 },
         routeKind: row.route?.kind,
         attemptN: row.attemptN,
         ...(row.signature === undefined ? {} : { signature: row.signature }),
-        ...(row.message === undefined ? {} : { message: row.message }),
+        ...(row.messageText === undefined ? {} : { message: row.messageText }),
         ...(row.diagnostic === undefined ? {} : { diagnostic: row.diagnostic }),
     };
 }

package/dist/delivery-operations.d.ts

@@ -1,9 +1,22 @@
-import type { SquareArtifactPort, DeliverPendingInput } from './ports.js';
+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: SquareArtifactPort;
+    readonly artifact: ChannelArtifact;
     readonly location: string;
     readonly now: number;
     readonly graceMs: number;
     readonly limit: number;
 }): Promise<number[]>;
+export {};

package/dist/delivery-operations.js

@@ -1,11 +1,29 @@
 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 { formatMessageId, parseMessageId } from './message.js';
+import { pendingAddresses, pendingHeadAt, pendingMessageHeads, presentationBlocksWake } from './channel-delivery.js';
 import { deliveryDeferralExpiry } from './delivery-deferral.js';
-import { leaseOwnsNotification } from './delivery.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;
@@ -15,37 +33,34 @@ function routeFor(location, seat, now) {
     };
 }
 async function currentness(artifact, request, now) {
-    const index = parseActivityId(request.activity);
+    const index = parseMessageId(request.message);
     const { value } = await artifact.read((facts) => {
-        const currentSeat = facts.seat(request.participant);
+        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 = pendingHead(facts, request.participant, index);
+        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, formatActivityId(index));
+        const evidence = facts.deliveryEvidence(request.participant, request.seat.generation, formatMessageId(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 { 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.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 }];
+            ? 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;
@@ -63,9 +78,9 @@ function safeJson(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)
+    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.
@@ -81,9 +96,8 @@ export async function deliverPending(input) {
         if (route === undefined)
             return;
         const request = {
-            location, participant: seat.participant, activity: formatActivityId(head.index), actor: head.actor,
-            seat: asSeatRef(seat), route,
-            artifact: input.artifact,
+            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 {
@@ -100,7 +114,7 @@ export async function deliverPending(input) {
         let snapshot;
         await dispatchEffect({
             async claim() {
-                const claim = await input.artifact.claimDelivery({ seat: request.seat, activity: request.activity, kind: 'wake',
+                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;
             },
@@ -128,15 +142,31 @@ export async function deliverPending(input) {
                     };
                 else if (completion.reason === 'returned')
                     fields = completion.data;
-                return input.artifact.completeDelivery({ seat: request.seat, activity: request.activity, claimToken: claim.token,
+                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 ? {} : { message: fields.message }),
+                    ...(fields.message === undefined ? {} : { messageText: 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);
+        }, 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 });
     };

package/dist/delivery.d.ts

@@ -1,45 +1,56 @@
-import type { DirectedNotificationRoute, WatchLease } from './model.js';
-import type { DeliveryEvidence, DirectedHead, ParticipantFact, SquareArtifactPort, SquareRead, WakeRequest } from './ports.js';
+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';
-/** 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;
+/** 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;
 }
-/** 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;
+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): 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 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 ParticipantFact[];
+    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: 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>;
+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 DirectedHead[]): {
-    pending: DirectedHead[];
+export declare function pendingFacts(facts: SquareRead, scan: PendingScan, heads: readonly PendingMessage[]): {
+    pending: PendingMessage[];
 };
-/** Global discovery alone sweeps pendingAudience; exact dispatch uses pendingRecipients. */
+/** Global discovery alone sweeps every endpoint; exact dispatch uses pendingAddresses. */
 export declare function collectPending(artifact: SquareArtifactPort): Promise<{
-    pending: DirectedHead[];
+    pending: PendingMessage[];
     scan: PendingScan;
 }>;
-/** A live catch owns every matching notification, independent of its page size. */
-export declare function leaseOwnsNotification(lease: WatchLease, notification: RoutedNotification): boolean;
+export { formatMessageId };