@astrosheep/square 0.4.0 → 0.4.2

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>;

package/dist/plugins/opencode/delivery.js

@@ -1,223 +0,0 @@
-import { createHash } from 'node:crypto';
-import { squareWakeProjection } from '../../wake-preview.js';
-import { channelArtifact, createArtifactPort } from '../../artifact.js';
-import { deliverPending } from '../../delivery-operations.js';
-import { nativePendingSource, observeSessionPending, projectSessionSeats } from '../../inbox.js';
-import { automaticWakeEligible, nativePendingHead, presentationBlocksWake } from '../../delivery.js';
-import { harnessOwner, decodeHarnessOwner } from '../../owner.js';
-import { formatMessageId, parseMessageId } from '../../message.js';
-import { indexedSquareEntries } from '../../square-index.js';
-import { asSeatRef } from '../../seats.js';
-import { restoreSessionSeats } from '../../session-lifecycle.js';
-import { presentPending } from '../../presentation-operations.js';
-import { createNativeInputId, sendNativeText } from '../../packages/agent-delivery/src/opencode-native.js';
-const routeKind = 'opencode-server';
-const ownerFor = (sessionId) => harnessOwner({ channel: 'opencode', session: sessionId });
-const payloadHash = (payload) => createHash('sha256').update(payload).digest('hex');
-export async function indexedOpenCodeSessions(env) {
-    return [...new Set((await indexedSquareEntries({}, env)).flatMap((entry) => {
-            const coordinate = decodeHarnessOwner(entry.owner);
-            return coordinate?.channel === 'opencode' ? [coordinate.session] : [];
-        }))];
-}
-export async function discoverOpenCodeSeats(sessionId, env, signal) {
-    return projectSessionSeats({ owner: ownerFor(sessionId), env }, signal);
-}
-function sameSeat(left, right) {
-    return left !== undefined && left.attachment === 'attached' && left.generation === right.generation && left.owner === right.owner;
-}
-function createOpenCodeWakeTransport(target, lifetime) {
-    return {
-        probe: async (route) => !lifetime.aborted && route.kind === routeKind
-            && route.address.sessionId === target.sessionId,
-        async attempt(request, timeoutMs, beforeSend) {
-            const presentation = request.presentation;
-            if (request.claimToken === undefined || parseMessageId(request.message) === undefined || presentation === undefined
-                || request.route.kind !== routeKind || request.route.address.sessionId !== target.sessionId) {
-                return { outcome: 'not-capable', diagnostic: 'OpenCode attention has no matching artifact claim or session.' };
-            }
-            const signal = AbortSignal.any([lifetime, AbortSignal.timeout(timeoutMs)]);
-            const started = Date.now();
-            if (signal.aborted || !await beforeSend())
-                return { outcome: 'not-capable', diagnostic: 'OpenCode attention changed before send.' };
-            const inputId = createNativeInputId();
-            const correlation = { harness: 'opencode', token: inputId, payloadHash: payloadHash(presentation.payload) };
-            if (!await request.channel.prepare({ correlation,
-                coverage: presentation.coverage, ...(presentation.description === undefined ? {} : { description: presentation.description }) }, signal))
-                return { outcome: 'not-capable', diagnostic: 'OpenCode delivery claim is no longer current.' };
-            if (signal.aborted || !await beforeSend())
-                return { outcome: 'not-capable', diagnostic: 'OpenCode attention was consumed before send.' };
-            const result = await sendNativeText(target, presentation.payload, {
-                inputId, delivery: 'steer', timeoutMs: Math.max(1, timeoutMs - (Date.now() - started)), signal,
-            });
-            if (result.state === 'accepted')
-                return { outcome: 'accepted' };
-            if (result.state === 'unavailable')
-                return { outcome: 'failed', signature: result.code };
-            return { outcome: 'unknown', signature: result.code };
-        },
-    };
-}
-function textMessage(message) {
-    if (message.role !== 'user' || message.id === undefined || !message.content.every((part) => part.type === 'text' && typeof part.text === 'string'))
-        return undefined;
-    return message.content.map((part) => part.text).join('');
-}
-/** The exact prepared native message can authorize artifact-backed presentation once. */
-export async function observeOpenCodeContext(sessionId, messages, env, signal) {
-    const observed = new Map(messages.flatMap((message) => {
-        const text = textMessage(message);
-        return text === undefined ? [] : [[message.id, payloadHash(text)]];
-    }));
-    if (observed.size === 0 || signal.aborted)
-        return;
-    for (const { location, seat } of await discoverOpenCodeSeats(sessionId, env, signal)) {
-        if (signal.aborted)
-            return;
-        const artifact = createArtifactPort(location, undefined, signal);
-        try {
-            const { value: matches } = await artifact.read((facts) => {
-                if (!sameSeat(facts.seat(seat.participant), seat))
-                    return [];
-                return facts.deliveryEvidence(seat.participant, seat.generation).flatMap((evidence) => {
-                    const token = evidence.correlation?.harness === 'opencode' ? evidence.correlation.token : undefined;
-                    const hash = token === undefined ? undefined : observed.get(token);
-                    const index = parseMessageId(evidence.message), now = Date.now();
-                    if (token === undefined || hash === undefined || evidence.claimToken === undefined || index === undefined
-                        || evidence.route === undefined || !['dispatching', 'unknown', 'accepted'].includes(evidence.outcome)
-                        || evidence.correlation?.payloadHash !== hash
-                        || evidence.route.kind !== routeKind
-                        || presentationBlocksWake(facts.deliveryEvidence(seat.participant, seat.generation, evidence.message), now))
-                        return [];
-                    const source = nativePendingSource(facts, { location, participant: seat.participant, generation: seat.generation,
-                        owner: seat.owner, index, route: evidence.route, now });
-                    if (source === undefined)
-                        return [];
-                    return [{ evidence, index, hash, clipped: evidence.coverage === 'clipped' }];
-                });
-            }, signal);
-            for (const { evidence, index, hash, clipped } of matches) {
-                if (signal.aborted || evidence.claimToken === undefined)
-                    return;
-                await presentPending({ artifact, location, participant: seat.participant,
-                    message: formatMessageId(index), seat: asSeatRef(seat), observationOf: evidence.claimToken, sink: { present() { } }, markSeen: !clipped, signal,
-                    current: (facts) => {
-                        const correlation = facts.deliveryByToken(evidence.claimToken);
-                        return nativePendingHead(facts, { location, participant: seat.participant, generation: seat.generation,
-                            owner: seat.owner, index, route: evidence.route, now: Date.now() }) !== undefined
-                            && ['dispatching', 'unknown', 'accepted'].includes(correlation?.outcome ?? '')
-                            && correlation?.correlation?.harness === 'opencode'
-                            && correlation.correlation.token !== undefined
-                            && correlation.correlation.payloadHash === hash;
-                    },
-                });
-            }
-        }
-        finally {
-            await artifact.close();
-        }
-    }
-}
-/** The native receiver owns no claims outside the artifact; HOME is used only for discovery. */
-export async function receiveOpenCodePending(target, env, signal) {
-    const observer = await observeSessionPending(ownerFor(target.sessionId), env);
-    const transport = createOpenCodeWakeTransport(target, signal);
-    let waiting;
-    try {
-        while (!signal.aborted) {
-            const armed = new Promise((resolve) => {
-                waiting = observer.wait(Infinity, { signal, skipImmediate: true, onChangeArmed: resolve });
-                void waiting.catch(() => resolve(false));
-            });
-            if (!await armed) {
-                await waiting;
-                break;
-            }
-            for (const membership of await observer.read({ signal })) {
-                const { location, seat } = membership;
-                if (signal.aborted)
-                    return;
-                const artifact = createArtifactPort(location, undefined, signal);
-                try {
-                    const { value: notifications } = await artifact.read((facts) => {
-                        if (!sameSeat(facts.seat(seat.participant), seat))
-                            return [];
-                        return membership.notifications.filter((note) => automaticWakeEligible(facts.deliveryEvidence(seat.participant, seat.generation, formatMessageId(note.messageIndex)), Date.now()));
-                    }, signal);
-                    for (const note of notifications) {
-                        if (signal.aborted)
-                            return;
-                        await deliverPending({ artifact: channelArtifact(artifact), preparePresentation: squareWakeProjection(artifact), transport, location, message: formatMessageId(note.messageIndex), now: Date.now() });
-                    }
-                }
-                catch (error) {
-                    if (signal.aborted)
-                        throw signal.reason ?? error;
-                    // A candidate that became unreadable cannot authorize sending; the shared observer
-                    // keeps its subscription and will reconsider the artifact after repair.
-                }
-                finally {
-                    await artifact.close();
-                }
-            }
-            await waiting;
-            waiting = undefined;
-        }
-    }
-    catch (error) {
-        if (!signal.aborted)
-            throw error;
-    }
-    finally {
-        observer.close();
-        await waiting?.catch(() => { });
-    }
-}
-/** Publish the native address into current artifact seats; the legacy route projection is not read. */
-export async function publishOpenCodeAddress(sessionId, env, signal) {
-    await restoreSessionSeats(ownerFor(sessionId), env, { kind: routeKind, address: { sessionId } }, signal);
-    const seats = (await discoverOpenCodeSeats(sessionId, env, signal)).filter(({ seat }) => seat.attachment === 'attached');
-    for (const { location, seat } of seats) {
-        if (signal.aborted)
-            return false;
-        const artifact = createArtifactPort(location, undefined, signal);
-        try {
-            await artifact.transactAs({ kind: 'participant', seat: asSeatRef(seat) }, (facts) => facts.updateWakeAddress(asSeatRef(seat), { kind: routeKind, address: { sessionId } }));
-        }
-        finally {
-            await artifact.close();
-        }
-    }
-    return seats.length > 0;
-}
-export async function cancelOpenCodeDeliveries(sessionId, env, signal) {
-    for (const { location, seat } of await discoverOpenCodeSeats(sessionId, env, signal)) {
-        if (signal.aborted)
-            return;
-        if (seat.attachment !== 'attached')
-            continue;
-        const artifact = createArtifactPort(location, undefined, signal);
-        try {
-            const { value: through } = await artifact.read((facts) => facts.channel.header().lastMessageIndex, signal);
-            if (through >= 0)
-                await artifact.cancelDeliveries(asSeatRef(seat), through, signal);
-        }
-        finally {
-            await artifact.close();
-        }
-    }
-}
-export async function endOpenCodeSession(sessionId, env, signal) {
-    for (const { location, seat } of await discoverOpenCodeSeats(sessionId, env, signal)) {
-        if (signal.aborted)
-            return;
-        const { Square } = await import('../../square-api.js');
-        const square = await Square.at({ path: location, env });
-        try {
-            await square.endHeld(seat.participant, { owner: seat.owner, generation: seat.generation });
-        }
-        finally {
-            await square.close();
-        }
-    }
-}

package/dist/presentation-operations.d.ts

@@ -1,5 +0,0 @@
-import type { PresentationResult, PresentPendingInput } from './ports.js';
-/** Prepare custody before any external effect. A batch prepares every included item first. */
-export declare function preparePendingPresentation(input: Omit<PresentPendingInput, 'sink'>): Promise<import("./delivery-effects.js").PreparedPresentation<import("./channel-ports.js").MessageFact> | undefined>;
-/** A sink error cannot prove that content was never injected. */
-export declare function presentPending(input: PresentPendingInput): Promise<PresentationResult>;