@astrosheep/square 0.3.106 → 0.4.1

package/dist/channel.d.ts

@@ -1,74 +0,0 @@
-import { type HarnessSessionChannel } from './participant-identity.js';
-import type { SquareResourceOwner, WakeTransportPort } from './ports.js';
-import type { ActivityId, ChannelSendInput, ChannelSendResult, DeliveryDeferral, HeldSeat, MetadataMatch, OperationControl, Owner, Participant, WakeAddress, PendingOptions, PendingResult, AckResult } from './square-facade.js';
-export { harnessOwner, decodeHarnessOwner, localUserOwner } from './owner.js';
-export type { ActivityDelivery, ActivityMetadata, ActivityQuery, ActivitySearch, ActivityCursor, ChannelTruncate, PerceivedActivity, PendingOptions, PendingResult, AckResult } from './square-facade.js';
-export type { ActivityId, ChannelSendInput, ChannelSendResult, DeliveryDeferral, HeldSeat, MetadataMatch, OperationControl, Owner, WakeAddress, SquareResourceOwner, WakeTransportPort, HarnessSessionChannel };
-export interface ResolvedHarnessSession {
-    readonly channel: HarnessSessionChannel;
-    readonly sessionId: string;
-    readonly agentId?: string;
-    readonly owner: Owner;
-    readonly wakeAddress?: WakeAddress;
-}
-export declare function resolveHarnessSession(env?: NodeJS.ProcessEnv): ResolvedHarnessSession | undefined;
-export interface ChannelOpenInput {
-    readonly path: string;
-    readonly cwd?: string;
-    readonly env?: NodeJS.ProcessEnv;
-    readonly clock?: () => number;
-    readonly wakeTransport?: WakeTransportPort | false;
-    readonly resources?: SquareResourceOwner;
-}
-export interface ChannelCreateInput extends ChannelOpenInput {
-    readonly force?: boolean;
-    readonly description?: string;
-}
-type EndpointOptions = {
-    readonly owner: Owner;
-    readonly wakeAddress?: WakeAddress;
-};
-type EndpointIdentity = {
-    readonly owner: Owner;
-    readonly generation: ActivityId;
-};
-/** A scoped direct-messaging vocabulary over the shared Square resource. */
-export declare class Channel {
-    private readonly square;
-    private constructor();
-    get location(): string;
-    static open(input: ChannelOpenInput, control?: OperationControl): Promise<Channel>;
-    static create(input: ChannelCreateInput, control?: OperationControl): Promise<Channel>;
-    static inMemory(input?: Omit<ChannelCreateInput, 'path' | 'resources' | 'force'>): Channel;
-    attach(name: string, options: EndpointOptions & {
-        readonly takeover?: boolean;
-    }, control?: OperationControl): Promise<ChannelEndpoint>;
-    reattach(name: string, options: EndpointOptions, control?: OperationControl): Promise<ChannelEndpoint | null>;
-    endpoint(name: string, options: {
-        readonly owner: Owner;
-    }): Promise<ChannelEndpoint>;
-    endpointsOf(owner: Owner): Promise<readonly HeldSeat[]>;
-    detach(name: string, identity: EndpointIdentity): Promise<true | null>;
-    remove(name: string, identity: EndpointIdentity): Promise<boolean>;
-    cancelDeliveries(name: string, identity: EndpointIdentity): Promise<boolean>;
-    send(input: ChannelSendInput, control?: OperationControl): Promise<ChannelSendResult>;
-    close(): Promise<void>;
-}
-/** Captures one recipient generation through its existing Participant handle. */
-export declare class ChannelEndpoint {
-    private readonly channel;
-    private readonly participant;
-    constructor(channel: Channel, participant: Participant);
-    get name(): string;
-    get generation(): ActivityId;
-    pending(options?: PendingOptions, control?: OperationControl): Promise<PendingResult>;
-    ack(ids: readonly ActivityId[], control?: OperationControl): Promise<AckResult>;
-    leave(control?: OperationControl): Promise<void>;
-    deferDelivery(input: Readonly<{
-        match: MetadataMatch;
-        durationMs: number;
-    }>, control?: OperationControl): Promise<DeliveryDeferral>;
-    renewDeliveryDeferral(id: string, durationMs: number, control?: OperationControl): Promise<DeliveryDeferral | null>;
-    releaseDeliveryDeferral(id: string, control?: OperationControl): Promise<boolean>;
-    send(input: Omit<ChannelSendInput, 'from'>, control?: OperationControl): Promise<ChannelSendResult>;
-}

package/dist/channel.js

@@ -1,92 +0,0 @@
-import { codexWakeAddress } from './codex-address.js';
-import { SquareError } from './model.js';
-import { harnessOwner } from './owner.js';
-import { harnessSessionSources } from './participant-identity.js';
-import { Square } from './square-api.js';
-import { squareLocation } from './square-location.js';
-export { harnessOwner, decodeHarnessOwner, localUserOwner } from './owner.js';
-export function resolveHarnessSession(env = process.env) {
-    for (const { variable, channel } of harnessSessionSources) {
-        const sessionId = env[variable]?.trim();
-        if (!sessionId)
-            continue;
-        const agentId = channel === 'claude-code' && env.CLAUDE_CODE_CHILD_SESSION?.trim() === '1'
-            ? env.CLAUDE_CODE_AGENT_ID?.trim() || undefined : undefined;
-        const wakeAddress = channel === 'codex' ? codexWakeAddress(sessionId, env)
-            : channel === 'paseo' ? { kind: 'paseo', address: { agentId: sessionId } } : undefined;
-        return { channel, sessionId, ...(agentId === undefined ? {} : { agentId }),
-            owner: harnessOwner({ channel, session: sessionId, ...(agentId === undefined ? {} : { agent: agentId }) }),
-            ...(wakeAddress === undefined ? {} : { wakeAddress }) };
-    }
-    return undefined;
-}
-function explicitLocation(input) {
-    if (typeof input?.path !== 'string' || input.path.trim() === '')
-        throw new SquareError('invalid_args', 'Channel path is required.');
-    return squareLocation(input);
-}
-/** A scoped direct-messaging vocabulary over the shared Square resource. */
-export class Channel {
-    square;
-    constructor(square) {
-        this.square = square;
-    }
-    get location() { return this.square.location; }
-    static async open(input, control) {
-        const path = explicitLocation(input);
-        return new Channel(await Square.at({ ...input, path }, control));
-    }
-    static async create(input, control) {
-        const path = explicitLocation(input);
-        return new Channel(await Square.build({ ...input, path, hardCap: null, markdown: input.description ?? '# Channel\n' }, control));
-    }
-    static inMemory(input = {}) {
-        return new Channel(Square.inMemory({ ...input, hardCap: null, markdown: input.description ?? '# Channel\n' }));
-    }
-    async attach(name, options, control) {
-        return new ChannelEndpoint(this, (await this.square.join(name, options, control)).participant);
-    }
-    async reattach(name, options, control) {
-        const participant = await this.square.reattach(name, options, control);
-        return participant === null ? null : new ChannelEndpoint(this, participant);
-    }
-    async endpoint(name, options) {
-        return new ChannelEndpoint(this, await this.square.participant(name, options));
-    }
-    endpointsOf(owner) { return this.square.seatsOf(owner); }
-    detach(name, identity) { return this.square.detach(name, identity); }
-    async remove(name, identity) { return await this.square.endHeld(name, identity) !== null; }
-    cancelDeliveries(name, identity) { return this.square.cancelDeliveries(name, identity); }
-    send(input, control) { return this.square.send(input, control); }
-    close() { return this.square.close(); }
-}
-/** Captures one recipient generation through its existing Participant handle. */
-export class ChannelEndpoint {
-    channel;
-    participant;
-    constructor(channel, participant) {
-        this.channel = channel;
-        this.participant = participant;
-    }
-    get name() { return this.participant.name; }
-    get generation() { return this.participant.generation; }
-    pending(options, control) {
-        return this.participant.pending(options, control);
-    }
-    ack(ids, control) {
-        return this.participant.ack(ids, control);
-    }
-    async leave(control) { await this.participant.done(undefined, {}, control); }
-    deferDelivery(input, control) {
-        return this.participant.deferDelivery(input, control);
-    }
-    renewDeliveryDeferral(id, durationMs, control) {
-        return this.participant.renewDeliveryDeferral(id, durationMs, control);
-    }
-    releaseDeliveryDeferral(id, control) {
-        return this.participant.releaseDeliveryDeferral(id, control);
-    }
-    send(input, control) {
-        return this.channel.send({ ...input, from: this.name }, control);
-    }
-}

package/dist/claude-delivery-status.d.ts

@@ -1,13 +0,0 @@
-export interface ClaudeDeliveryObservation {
-    readonly eventId: string;
-    readonly messageId: string;
-    readonly state: 'held' | 'released' | 'dropped';
-    readonly reason?: string;
-    readonly observedAt: number;
-}
-export interface ClaudeDeliveryStatus extends ClaudeDeliveryObservation {
-    readonly provider: 'claude';
-    readonly sessionId: string;
-}
-/** This receiver-owned observation is not a model tool and grants no delivery authority. */
-export declare function recordClaudeDeliveryStatus(input: ClaudeDeliveryStatus, env?: NodeJS.ProcessEnv): Promise<boolean>;

package/dist/claude-delivery-status.js

@@ -1,46 +0,0 @@
-import { createArtifactPort } from './artifact.js';
-import { decodeHarnessOwner } from './owner.js';
-import { indexedSquareEntries } from './square-index.js';
-const holdReasons = new Set(['explicit-setting', 'managed-setting', 'repo-setting', 'invalid-setting', 'bypass-default', 'mode-unknown', 'mode-mismatch', 'no-mode-asserted']);
-const dropReasons = new Set(['expired', 'refused', 'dropped', 'discarded']);
-const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-/** This receiver-owned observation is not a model tool and grants no delivery authority. */
-export async function recordClaudeDeliveryStatus(input, env = process.env) {
-    if (!input || input.provider !== 'claude' || typeof input.sessionId !== 'string' || !input.sessionId
-        || typeof input.messageId !== 'string' || !uuid.test(input.messageId)
-        || typeof input.eventId !== 'string' || !uuid.test(input.eventId)
-        || !Number.isFinite(input.observedAt) || input.observedAt < 0
-        || !['held', 'released', 'dropped'].includes(input.state)
-        || (input.state === 'held' ? !holdReasons.has(input.reason ?? '')
-            : input.state === 'dropped' ? !dropReasons.has(input.reason ?? '') : input.reason !== undefined))
-        return false;
-    const paths = new Set((await indexedSquareEntries({}, env)).filter(entry => {
-        const coordinate = decodeHarnessOwner(entry.owner);
-        return coordinate?.channel === 'claude-code' && coordinate.session === input.sessionId;
-    }).map(entry => entry.location));
-    for (const location of paths) {
-        const artifact = createArtifactPort(location);
-        try {
-            const { value: match } = await artifact.read((facts) => facts.roster().flatMap((participant) => {
-                const seat = facts.seat(participant.name);
-                if (seat === undefined || seat.attachment !== 'attached' || seat.wakeAddress?.kind !== 'claude-native'
-                    || seat.wakeAddress.address.sessionId !== input.sessionId)
-                    return [];
-                const evidence = facts.deliveryEvidence(seat.participant, seat.generation).find((row) => row.correlation?.harness === 'claude' && row.correlation.messageId === input.messageId && row.claimToken !== undefined);
-                return evidence === undefined ? [] : [{ seat, evidence }];
-            }));
-            if (match.length === 0)
-                continue;
-            const { seat, evidence } = match[0];
-            const ref = { participant: seat.participant, owner: seat.owner, generation: seat.generation };
-            return (await artifact.transactAs({ kind: 'participant', seat: ref }, (facts) => facts.observeNativeDelivery({ seat: ref, claimToken: evidence.claimToken, observation: {
-                    eventId: input.eventId, messageId: input.messageId, state: input.state,
-                    ...(input.reason === undefined ? {} : { reason: input.reason }), observedAt: input.observedAt,
-                } }))).value;
-        }
-        finally {
-            await artifact.close();
-        }
-    }
-    return false;
-}

package/dist/cmd/notify-once.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/cmd/notify-once.js

@@ -1,29 +0,0 @@
-#!/usr/bin/env node
-import { resolve } from 'node:path';
-import { setTimeout as sleep } from 'node:timers/promises';
-import { processActNotificationsOnce, wakeGraceMs } from '../notifications.js';
-function args(argv) {
-    let squarePath;
-    let actIndex;
-    for (let index = 0; index < argv.length; index += 1) {
-        if (argv[index] === '--location' && argv[index + 1] !== undefined)
-            squarePath = resolve(argv[++index]);
-        else if (argv[index] === '--act-index' && /^\d+$/.test(argv[index + 1] ?? ''))
-            actIndex = Number(argv[++index]);
-        else
-            throw new Error(`Unknown notify-once argument: ${argv[index]}`);
-    }
-    if (squarePath === undefined || actIndex === undefined)
-        throw new Error('notify-once requires --location and --act-index.');
-    return { squarePath, actIndex };
-}
-async function main() {
-    if (process.env.SQUARE_DISABLE_PASEO_WAKE === '1')
-        return;
-    const { squarePath, actIndex } = args(process.argv.slice(2));
-    await sleep(wakeGraceMs());
-    await processActNotificationsOnce(squarePath, actIndex);
-}
-main().catch(() => {
-    process.exitCode = 0;
-});

package/dist/delivery-attempts.d.ts

@@ -1,52 +0,0 @@
-export type DeliveryPurpose = 'dispatch' | 'presentation';
-export type AttemptOutcome = 'dispatching' | 'accepted' | 'failed' | 'unknown' | 'released' | 'presented' | 'clipped';
-export interface Attempt<D> {
-    readonly purpose: DeliveryPurpose;
-    readonly token: string;
-    readonly ordinal: number;
-    readonly outcome: AttemptOutcome;
-    readonly at: number;
-    readonly expiresAt?: number;
-    readonly data: D;
-}
-/** One item/recipient/authority/purpose series, bound inside the caller's transaction.
- * The caller owns token uniqueness, isolation and rollback; replacements retain coordinates.
- */
-export interface AttemptRows<D> {
-    list(): readonly Attempt<D>[];
-    byToken(token: string): Attempt<D> | undefined;
-    insert(attempt: Attempt<D>): void;
-    replace(attempt: Attempt<D>): void;
-}
-export type AttemptClaim<D> = {
-    readonly status: 'acquired';
-    readonly token: string;
-    readonly ordinal: number;
-} | {
-    readonly status: 'busy' | 'terminal';
-    readonly evidence: Attempt<D>;
-    readonly interrupted?: true;
-};
-export declare function claimAttempt<D>(rows: AttemptRows<D>, input: {
-    purpose: DeliveryPurpose;
-    token: string;
-    at: number;
-    leaseMs: number;
-    data: D;
-}): AttemptClaim<D>;
-export declare function prepareAttempt<D>(rows: AttemptRows<D>, input: {
-    token: string;
-    data: D;
-}): boolean;
-export declare function settleAttempt<D>(rows: AttemptRows<D>, input: {
-    token: string;
-    outcome: Exclude<AttemptOutcome, 'dispatching'>;
-    at: number;
-    data: D;
-}): boolean;
-type Custody = Pick<Attempt<unknown>, 'purpose' | 'outcome' | 'expiresAt'>;
-/** Presentation custody suppresses dispatch independently of dispatch acceptance. */
-export declare function presentationBlocksDispatch(attempts: readonly Custody[], now: number): boolean;
-/** An expired dispatch is uncertain, not permission for automatic replay. */
-export declare function automaticDispatchEligible(attempts: readonly Custody[], now: number): boolean;
-export {};

package/dist/delivery-attempts.js

@@ -1,73 +0,0 @@
-function finite(value) {
-    if (typeof value !== 'number' || !Number.isFinite(value))
-        throw new RangeError('time must be finite');
-}
-function token(value) {
-    if (typeof value !== 'string' || value.length === 0)
-        throw new TypeError('token must be nonempty');
-}
-export function claimAttempt(rows, input) {
-    if (input.purpose !== 'dispatch' && input.purpose !== 'presentation')
-        throw new TypeError('unsupported purpose');
-    token(input.token);
-    finite(input.at);
-    if (!Number.isSafeInteger(input.leaseMs) || input.leaseMs <= 0)
-        throw new RangeError('leaseMs must be a positive safe integer');
-    const expiresAt = input.at + input.leaseMs;
-    finite(expiresAt);
-    const attempts = rows.list();
-    const terminal = attempts.find(row => row.outcome === 'unknown'
-        || row.outcome === (input.purpose === 'dispatch' ? 'accepted' : 'presented'));
-    if (terminal !== undefined)
-        return { status: 'terminal', evidence: terminal };
-    const dispatching = attempts.find(row => row.outcome === 'dispatching');
-    if (dispatching !== undefined) {
-        if (dispatching.expiresAt === undefined || dispatching.expiresAt > input.at)
-            return { status: 'busy', evidence: dispatching };
-        const { expiresAt: _expiry, ...previous } = dispatching;
-        const evidence = { ...previous, outcome: 'unknown', at: input.at };
-        rows.replace(evidence);
-        return { status: 'terminal', evidence, interrupted: true };
-    }
-    const ordinal = (attempts[0]?.ordinal ?? -1) + 1;
-    if (!Number.isSafeInteger(ordinal) || ordinal < 0)
-        throw new RangeError('attempt ordinal exhausted');
-    rows.insert({ purpose: input.purpose, token: input.token, ordinal, outcome: 'dispatching', at: input.at, expiresAt, data: input.data });
-    return { status: 'acquired', token: input.token, ordinal };
-}
-export function prepareAttempt(rows, input) {
-    token(input.token);
-    const previous = rows.byToken(input.token);
-    if (previous?.outcome !== 'dispatching')
-        return false;
-    rows.replace({ ...previous, data: input.data });
-    return true;
-}
-export function settleAttempt(rows, input) {
-    token(input.token);
-    finite(input.at);
-    if (!['accepted', 'failed', 'unknown', 'released', 'presented', 'clipped'].includes(input.outcome))
-        throw new TypeError('unsupported completion');
-    const previous = rows.byToken(input.token);
-    if (previous === undefined)
-        return false;
-    if (previous.outcome === 'accepted' && input.outcome === 'accepted')
-        return true;
-    if (previous.outcome !== 'dispatching' && !(previous.outcome === 'unknown' && input.outcome === 'accepted'))
-        return false;
-    const { expiresAt: _expiry, ...retained } = previous;
-    rows.replace({ ...retained, outcome: input.outcome, at: input.at, data: input.data });
-    return true;
-}
-/** Presentation custody suppresses dispatch independently of dispatch acceptance. */
-export function presentationBlocksDispatch(attempts, now) {
-    finite(now);
-    return attempts.some(row => row.purpose === 'presentation'
-        && (row.outcome === 'presented' || row.outcome === 'clipped' || row.outcome === 'unknown'
-            || row.outcome === 'dispatching'));
-}
-/** An expired dispatch is uncertain, not permission for automatic replay. */
-export function automaticDispatchEligible(attempts, now) {
-    return !presentationBlocksDispatch(attempts, now) && !attempts.some(row => row.purpose === 'dispatch'
-        && (row.outcome === 'accepted' || row.outcome === 'unknown' || row.outcome === 'dispatching'));
-}

package/dist/delivery-effects.d.ts

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