@astrosheep/square 0.3.29 → 0.3.31

package/dist/model.d.ts

@@ -5,8 +5,10 @@ export declare const WAKE_ROUTE_KINDS: readonly ["opencode-server", "codex-queue
 export type WakeRouteKind = typeof WAKE_ROUTE_KINDS[number];
 export declare function isWakeRouteKind(value: unknown): value is WakeRouteKind;
 export interface WakeRoute {
-    ownerId: string;
+    location: string;
+    participant: string;
     sessionId: string;
+    channel: string;
     kind: WakeRouteKind;
     address: Record<string, string>;
     updatedAt: number;
@@ -40,11 +42,10 @@ export type StoredAct = Act & {
     at: number;
 };
 export type StoredActHead = StoredAct extends infer T ? T extends StoredAct ? Omit<T, 'body' | 'through' | 'index'> : never : never;
-export type ObservationState = 'notified' | 'seen';
+export type ObservationState = 'seen';
 export interface ActivityObservation {
     state: ObservationState;
     at: number;
-    ownerId?: string;
 }
 export interface WatchLeaseFilter {
     participants?: string[];
@@ -52,8 +53,6 @@ export interface WatchLeaseFilter {
 }
 export interface WatchLease {
     leaseId: string;
-    /** Machine-local owner that may claim automatic delivery for this lease. */
-    ownerId?: string;
     heartbeatAt: number;
     expiresAt: number;
     filter?: WatchLeaseFilter;
@@ -69,22 +68,13 @@ export interface InboxNotification {
 export interface InboxMembership {
     name: string;
     squarePath: string;
-    ownerId?: string;
     notifications: InboxNotification[];
     catchLease?: WatchLease;
 }
-export interface NotifyLease {
-    leaseId: string;
-    expiresAt: number;
-    phase: 'claimed' | 'dispatching';
-    attemptN?: number;
-    routeKind?: WakeRouteKind;
-}
 export interface SquareRuntimeState {
     nextActIndex: number;
     observations: Record<string, Record<string, ActivityObservation>>;
     leases: Record<string, WatchLease>;
-    notifyLeases: Record<string, NotifyLease>;
 }
 export interface SquareState {
     hardCap: HardCap;
@@ -97,12 +87,12 @@ export interface SquareState {
 export interface ActivitiesOptions {
     lastN?: number | null;
     participants?: string[];
-    /** Exclusive upper bound on act.at (ms). */
-    before?: number;
     /** Exclusive lower bound on act.at (ms). Alias of --since. */
     after?: number;
     /** Exclusive lower bound on stable act index (--after act/<index>). */
     afterIndex?: number;
+    /** Exclusive upper bound on stable act index (--before act/<index>). */
+    beforeIndex?: number;
     /** Center act indexes for context windows (--at). */
     atIndexes?: number[];
     beforeContext?: number;
@@ -111,7 +101,6 @@ export interface ActivitiesOptions {
     /** Undelivered mention/bell items for viewer only (read-only; requires viewer). */
     pending?: boolean;
     viewer?: string;
-    full?: boolean;
     grep?: string;
     fixed?: string;
     order?: 'asc' | 'desc';

package/dist/notifications.d.ts

@@ -1,8 +1,7 @@
-import { planActNotifications, type DeliveryModel, type WakeAdapter } from './delivery.js';
+import { planActNotifications, type WakeAdapter } from './delivery.js';
 import { type SquareState } from './model.js';
 import { matchesMentionTarget } from './runtime.js';
 import { type ActivityId } from './square-core.js';
-import type { WakeNotifier } from './square-facade.js';
 export type { PlannedNotification } from './delivery.js';
 export { planActNotifications, matchesMentionTarget };
 export { notificationMessageId } from './delivery.js';
@@ -17,17 +16,14 @@ interface ProcessNotificationOptions {
     env?: NodeJS.ProcessEnv;
     now?: () => number;
 }
-export declare function processActNotificationsOnce(squarePath: string, actIndex: number, opts?: ProcessNotificationOptions): Promise<void>;
-interface WorkerLaunchOptions {
-    launchWorker?: (workerPath: string, args: string[]) => void;
+export declare function processActNotificationsOnce(squarePath: string, actIndex: number, opts?: ProcessNotificationOptions): Promise<import("./ports.js").DeliveryResult>;
+export interface SweepPendingNotificationsOptions {
     env?: NodeJS.ProcessEnv;
-}
-export declare function wakeNotifierForSquare(squarePath: string, env?: NodeJS.ProcessEnv): WakeNotifier;
-export interface SweepPendingNotificationsOptions extends WorkerLaunchOptions {
     now?: number;
     limit?: number;
+    dispatchCandidate?: (actIndex: number) => void | Promise<void>;
 }
 /** Select sweep candidates from one frozen snapshot and one delivery replay. */
-export declare function pendingNotificationSweepFromState(squarePath: string, state: SquareState, now: number, env: NodeJS.ProcessEnv, limit: number, deriveDelivery?: (snapshot: SquareState) => DeliveryModel): Promise<number[]>;
-/** Reconsider old pending attention at a bounded action boundary using the existing worker. */
+export declare function pendingNotificationSweepFromState(squarePath: string, state: SquareState, now: number, env: NodeJS.ProcessEnv, limit: number, deriveDelivery?: (snapshot: import('./model.js').SquareState) => ReturnType<typeof import('./delivery.js').deriveDeliveryModel>): Promise<number[]>;
+/** Select old pending attention at a bounded action boundary for an explicit executor. */
 export declare function sweepPendingNotifications(squarePath: string, opts?: SweepPendingNotificationsOptions): Promise<number[]>;

package/dist/notifications.js

@@ -1,25 +1,16 @@
-import { spawn } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
 import { setTimeout as sleep } from 'node:timers/promises';
-import { fileURLToPath } from 'node:url';
-import { deriveDeliveryModel, leaseOwnsNotification, planActNotifications, } from './delivery.js';
-import { sessionInbox } from './inbox.js';
-import { hasPresentedAttention } from './presented.js';
+import path from 'node:path';
+import { planActNotifications, } from './delivery.js';
 import { SquareError } from './model.js';
 import { SLEEP_MS, matchesMentionTarget } from './runtime.js';
-import { parseActivityId } from './square-core.js';
-import { displayAttentionPath, renderAttentionPreview } from './attention-presentation.js';
-import { lookupParticipant } from './registry.js';
-import { retireWakeRoute } from './routes.js';
+import { formatActivityId, parseActivityId } from './square-core.js';
+import { displayAttentionPath } from './attention-presentation.js';
 import { openSquare } from './square-file-adapter.js';
-import { markNotificationNotified } from './square-wiring.js';
 import { closeOpenSquare } from './open-square.js';
-import { entryPresentation, notificationDelivered, notificationForAct, pendingDeliveriesFromState, resolveParticipant } from './views.js';
-import { claimNotificationLease, releaseNotificationLease, transitionNotificationLease } from './wakes.js';
-import { nextWakeAttemptNumber, recordRecoveredUnknown, recordWakeAttempt, } from './wake-attempts.js';
-import { wakeEvidence, wakeEvidenceProjectionFromState, wakeIsEligible } from './wake-evidence.js';
-import { WakePort } from './wake-port.js';
-const NOTIFY_LEASE_MS = 5 * 60 * 1000;
+import { notificationDelivered, resolveParticipant } from './views.js';
+import { deliverPending, sweepPending, sweepPendingFromState } from './delivery-operations.js';
+import { projectPresentationEvidence } from './square-projections.js';
+import { createHostLedgerPort } from './host-ledger-file-adapter.js';
 export { planActNotifications, matchesMentionTarget };
 export { notificationMessageId } from './delivery.js';
 export function wakeGraceMs(env = process.env) {
@@ -36,48 +27,14 @@ function wakeLabel(kind) {
         return 'codex-queue';
     return kind;
 }
-function renderWakePayload(request, body, kind) {
+function renderWakePayload(request) {
     return [
-        `<system-reminder source="square" wake="${wakeLabel(kind)}">`,
-        `square: ${displayAttentionPath(request.squarePath)}`,
-        renderAttentionPreview({
-            squarePath: request.squarePath,
-            actIndex: request.actIndex,
-            recipient: request.recipient,
-            actor: request.actor,
-            route: request.route,
-            body,
-            compact: true,
-        }),
+        `<system-reminder source="square" wake="${wakeLabel(request.route.kind)}">`,
+        `square: ${displayAttentionPath(request.location)}`,
+        `attention: ${request.activity} for ${request.participant}`,
         '</system-reminder>',
     ].join('\n');
 }
-async function waitForCatch(route, request, body) {
-    const binding = (await lookupParticipant(request.squarePath, request.recipient))
-        .find((item) => item.ownerId === route.ownerId);
-    const activeCatch = binding && (await sessionInbox(binding.sessionId))
-        .find((item) => item.name === request.recipient)?.catchLease;
-    if (!activeCatch || !leaseOwnsNotification(activeCatch, {
-        actor: request.actor,
-        body,
-        route: request.route,
-        recipient: request.recipient,
-    }))
-        return false;
-    const deadline = Date.now() + 180_000;
-    while (Date.now() < deadline) {
-        if (await hasDeliveredNotification(request.squarePath, request.recipient, request.actIndex))
-            return true;
-        const currentBinding = (await lookupParticipant(request.squarePath, request.recipient))
-            .find((item) => item.ownerId === route.ownerId);
-        const lease = currentBinding && (await sessionInbox(currentBinding.sessionId))
-            .find((item) => item.name === request.recipient)?.catchLease;
-        if (!lease || lease.expiresAt <= Date.now())
-            return false;
-        await sleep(Math.min(250, lease.expiresAt - Date.now()));
-    }
-    return false;
-}
 function notificationIndex(ref) {
     if (typeof ref === 'number')
         return ref;
@@ -101,7 +58,11 @@ export async function hasAttentionNotification(squarePath, name, ref, env = proc
     try {
         const recipient = (await resolveParticipant(square, name)).name;
         const index = notificationIndex(ref);
-        return await notificationDelivered(square, recipient, index) || await hasPresentedAttention(squarePath, recipient, index, env);
+        if (await notificationDelivered(square, recipient, index))
+            return true;
+        const root = env.SQUARE_REGISTRY === undefined ? undefined : path.dirname(env.SQUARE_REGISTRY);
+        const hostLedger = createHostLedgerPort({ userPath: env.SQUARE_HOST_LEDGER_USER ?? root, localPath: env.SQUARE_HOST_LEDGER_LOCAL ?? root, readableScopes: ['user'], writableScope: 'user' });
+        return (await projectPresentationEvidence({ hostLedger, location: squarePath, participant: recipient, activity: formatActivityId(index), now: Date.now() })).some((row) => row.outcome === 'presented');
     }
     finally {
         await closeOpenSquare(square);
@@ -134,164 +95,82 @@ async function defaultWakeAdapters() {
     }
     return adapters;
 }
-async function claimNotifyLease(square, recipient, actIndex) {
-    const leaseId = randomUUID();
-    return claimNotificationLease(square, recipient, actIndex, leaseId, NOTIFY_LEASE_MS);
-}
-async function transitionNotifyLease(square, recipient, actIndex, leaseId, phase, routeKind, attemptN) {
-    return transitionNotificationLease(square, recipient, actIndex, leaseId, phase, NOTIFY_LEASE_MS, routeKind, attemptN);
-}
-async function releaseNotifyLease(square, recipient, actIndex, leaseId) {
-    await releaseNotificationLease(square, recipient, actIndex, leaseId);
+function createWakeTransport(adapters, hostLedger, clock) {
+    return {
+        attempt: async (request, _timeoutMs) => {
+            const adapter = adapters.find((candidate) => candidate.kind === request.route.kind);
+            if (adapter === undefined)
+                return { outcome: 'failed', message: 'wake adapter unavailable' };
+            try {
+                const result = await adapter.dispatch(request.route.address, renderWakePayload(request), async () => true);
+                if (result.outcome === 'accepted')
+                    return { outcome: 'accepted' };
+                if (result.outcome === 'failed')
+                    return { outcome: 'failed', message: result.message };
+                if (result.outcome === 'unavailable')
+                    return { outcome: 'failed', message: result.message, unavailable: true };
+                if (result.outcome === 'unknown')
+                    return { outcome: 'unknown', diagnostic: result.message };
+                return { outcome: 'unknown', diagnostic: 'wake dispatch cancelled' };
+            }
+            catch (error) {
+                return { outcome: 'unknown', diagnostic: error instanceof Error ? error.message : String(error) };
+            }
+        },
+        invalidate: async (request) => {
+            await hostLedger.ensurePresence({
+                location: request.route.location,
+                participant: request.route.participant,
+                session: request.route.sessionId,
+                channel: request.route.channel,
+                updatedAt: clock(),
+            }, 'user');
+        },
+    };
 }
-async function processNotification(squarePath, notification, opts) {
+export async function processActNotificationsOnce(squarePath, actIndex, opts = {}) {
     const env = opts.env ?? process.env;
     const now = opts.now ?? Date.now;
-    const attention = {
-        squarePath,
-        actIndex: notification.item.index,
-        recipient: notification.recipient,
-    };
-    const initialAt = now();
-    if (!wakeIsEligible(await wakeEvidence(squarePath, notification.recipient, notification.item.index, initialAt, env)))
-        return;
-    const square = await openSquare(squarePath, { clock: now });
-    const claim = await claimNotifyLease(square, notification.recipient, notification.item.index);
-    if (claim.type === 'busy' || claim.type === 'delivered') {
-        await closeOpenSquare(square);
-        return;
-    }
-    if (claim.type === 'ambiguous') {
-        const recovered = await recordRecoveredUnknown(attention, claim.lease, env);
-        if (recovered !== undefined) {
-            await releaseNotifyLease(square, notification.recipient, notification.item.index, claim.lease.leaseId);
-        }
-        await closeOpenSquare(square);
-        return;
-    }
-    const { leaseId } = claim;
-    let releaseLease = true;
+    const ledgerRoot = env.SQUARE_REGISTRY === undefined ? undefined : path.dirname(env.SQUARE_REGISTRY);
+    const hostLedger = createHostLedgerPort({
+        userPath: env.SQUARE_HOST_LEDGER_USER ?? ledgerRoot,
+        localPath: env.SQUARE_HOST_LEDGER_LOCAL ?? ledgerRoot,
+    });
+    const square = await openSquare(squarePath, { clock: now, hostLedger, env });
     try {
-        const dispatchAt = now();
-        const evidence = await wakeEvidence(squarePath, notification.recipient, notification.item.index, dispatchAt, env);
-        if (!wakeIsEligible(evidence))
-            return;
-        const port = new WakePort(opts.adapters ?? await defaultWakeAdapters());
-        const request = {
-            squarePath,
-            actIndex: notification.item.index,
-            recipient: notification.recipient,
-            actor: notification.item.actor,
-            route: notification.route,
-        };
-        await port.dispatch(evidence.attemptableRoutes, (route) => renderWakePayload(request, notification.item.body, route.kind), {
-            nextAttemptN: async () => nextWakeAttemptNumber(attention, { env, now: now() }),
-            beforeSend: async (route, attemptN) => {
-                if (await waitForCatch(route, request, notification.item.body))
-                    return false;
-                const currentAt = now();
-                if (!(await entryPresentation(square, notification.recipient)).joined)
-                    return false;
-                const current = await wakeEvidence(squarePath, notification.recipient, notification.item.index, currentAt, env);
-                if (!wakeIsEligible(current))
-                    return false;
-                if (!current.attemptableRoutes.some((candidate) => candidate.ownerId === route.ownerId && candidate.kind === route.kind && candidate.sessionId === route.sessionId))
-                    return false;
-                const dispatching = await transitionNotifyLease(square, notification.recipient, notification.item.index, leaseId, 'dispatching', route.kind, attemptN);
-                if (dispatching)
-                    releaseLease = false;
-                return dispatching;
-            },
-            record: async (route, attemptN, outcome) => {
-                if (outcome.outcome === 'failed') {
-                    await transitionNotifyLease(square, notification.recipient, notification.item.index, leaseId, 'claimed');
-                    releaseLease = true;
-                }
-                await recordWakeAttempt({
-                    attention,
-                    routeKind: route.kind,
-                    outcome: outcome.outcome,
-                    attemptN,
-                    at: now(),
-                    ...('signature' in outcome ? { signature: outcome.signature } : {}),
-                    ...('message' in outcome ? { message: outcome.message } : {}),
-                    ...('diagnostic' in outcome && outcome.diagnostic !== undefined ? { diagnostic: outcome.diagnostic } : {}),
-                }, env);
-                if (outcome.outcome === 'accepted') {
-                    await markNotificationNotified(square, notification.recipient, notification.item.index, route.ownerId, now());
-                }
-                if (outcome.outcome !== 'failed')
-                    releaseLease = true;
-            },
-            invalidate: async (route) => {
-                await retireWakeRoute(route, { env, at: now() });
-            },
-        });
+        const adapters = opts.adapters ?? await defaultWakeAdapters();
+        const transport = createWakeTransport(adapters, hostLedger, now);
+        return await deliverPending({ artifact: square.artifact, hostLedger, transport, location: squarePath, activity: actIndex, timeoutMs: Number(env.SQUARE_NOTIFY_DELIVERY_WAIT_MS ?? 5000), now: now() });
     }
     finally {
-        if (releaseLease) {
-            await releaseNotifyLease(square, notification.recipient, notification.item.index, leaseId);
-        }
         await closeOpenSquare(square);
     }
 }
-export async function processActNotificationsOnce(squarePath, actIndex, opts = {}) {
-    const square = await openSquare(squarePath);
-    const notifications = await notificationForAct(square, actIndex).finally(() => closeOpenSquare(square));
-    await Promise.all(notifications.map((notification) => processNotification(squarePath, notification, opts)));
-}
-function launchWorker(workerPath, args) {
-    const child = spawn(process.execPath, [workerPath, ...args], { detached: true, stdio: 'ignore', env: process.env });
-    child.unref();
-}
-export function wakeNotifierForSquare(squarePath, env = process.env) {
-    return {
-        wake(recipients, activity) {
-            if (env.SQUARE_DISABLE_PASEO_WAKE === '1' || recipients.length === 0)
-                return;
-            const actIndex = parseActivityId(activity.id);
-            if (actIndex === undefined)
-                return;
-            launchWorker(fileURLToPath(new URL('./cmd/notify-once.js', import.meta.url)), ['--location', squarePath, '--act-index', String(actIndex)]);
-        },
-    };
-}
 /** Select sweep candidates from one frozen snapshot and one delivery replay. */
-export async function pendingNotificationSweepFromState(squarePath, state, now, env, limit, deriveDelivery = deriveDeliveryModel) {
-    const delivery = deriveDelivery(state);
-    const pending = pendingDeliveriesFromState(state, delivery);
-    const evidence = await wakeEvidenceProjectionFromState(squarePath, state, now, env, delivery);
-    const indexes = new Set();
-    for (const recipient of pending) {
-        for (const note of recipient.notifications) {
-            if (now - note.item.at <= wakeGraceMs(env))
-                continue;
-            if (!wakeIsEligible(evidence.evidence(recipient.recipient, note.item.index)))
-                continue;
-            indexes.add(note.item.index);
-        }
-    }
-    return [...indexes].sort((left, right) => left - right).slice(0, Math.max(0, limit));
+export async function pendingNotificationSweepFromState(squarePath, state, now, env, limit, deriveDelivery) {
+    const ledger = createHostLedgerPort({ userPath: env.SQUARE_HOST_LEDGER_USER, writableScope: 'user', readableScopes: ['user'] });
+    return sweepPendingFromState({ state, hostLedger: ledger, location: squarePath, now, graceMs: wakeGraceMs(env), limit, deriveDelivery });
 }
-/** Reconsider old pending attention at a bounded action boundary using the existing worker. */
+/** Select old pending attention at a bounded action boundary for an explicit executor. */
 export async function sweepPendingNotifications(squarePath, opts = {}) {
     const env = opts.env ?? process.env;
     if (env.SQUARE_DISABLE_PASEO_WAKE === '1')
         return [];
     const now = opts.now ?? Date.now();
     const limit = opts.limit ?? 8;
-    const square = await openSquare(squarePath, { clock: () => now });
-    let state;
+    const ledgerRoot = env.SQUARE_REGISTRY === undefined ? undefined : path.dirname(env.SQUARE_REGISTRY);
+    const hostLedger = createHostLedgerPort({ userPath: env.SQUARE_HOST_LEDGER_USER ?? ledgerRoot, localPath: env.SQUARE_HOST_LEDGER_LOCAL ?? ledgerRoot });
+    const square = await openSquare(squarePath, { clock: () => now, hostLedger, env });
+    let selected;
     try {
-        ({ state } = await entryPresentation(square, ''));
+        selected = await sweepPending({ artifact: square.artifact, hostLedger, location: squarePath, now, graceMs: wakeGraceMs(env), limit });
     }
     finally {
         await closeOpenSquare(square);
     }
-    const selected = await pendingNotificationSweepFromState(squarePath, state, now, env, limit);
-    const workerPath = fileURLToPath(new URL('./cmd/notify-once.js', import.meta.url));
-    for (const actIndex of selected) {
-        (opts.launchWorker ?? launchWorker)(workerPath, ['--location', squarePath, '--act-index', String(actIndex)]);
+    if (opts.dispatchCandidate !== undefined) {
+        for (const actIndex of selected)
+            await opts.dispatchCandidate(actIndex);
     }
     return selected;
 }

package/dist/open-square.d.ts

@@ -1,11 +1,11 @@
-import type { StateCell } from './state-cell.js';
-import type { WakeNotifier } from './square-facade.js';
+import type { HostLedgerPort, SquareArtifactPort } from './ports.js';
 /** Private binding assembled by storage and consumed by the four concerns. */
 export interface OpenSquare {
-    readonly cell: StateCell;
+    readonly artifact: SquareArtifactPort;
     readonly clock: () => number;
-    readonly notifier?: WakeNotifier;
     readonly location: string;
+    readonly hostLedger?: HostLedgerPort;
+    readonly env?: NodeJS.ProcessEnv;
 }
 /** Package-private lifecycle boundary for bound squares. */
 export declare function closeOpenSquare(square: OpenSquare): Promise<void>;

package/dist/open-square.js

@@ -1,4 +1,4 @@
 /** Package-private lifecycle boundary for bound squares. */
 export function closeOpenSquare(square) {
-    return square.cell.close();
+    return square.artifact.close();
 }

package/dist/ports.d.ts

@@ -0,0 +1,127 @@
+import type { InboxNotification, SquareState, StoredAct, WakeRoute, WatchLease } from './model.js';
+import type { PlannedNotification } from './delivery.js';
+export type { ClaimResult, EvidenceClaim, EvidenceRelease, EvidenceGc, EvidenceLookup, EvidenceRecord, HostLedgerPort, HostLedgerScope, PresenceKey, PresenceLookup, PresenceRecord, PresenceChannel, PresenceResult, ReconcileBindingInput as HostLedgerReconcileBindingInput, ReconcileBindingResult, } from './host-ledger.js';
+import type { HostLedgerPort } from './host-ledger.js';
+/** Atomic artifact access. Never exposes framing, compression, locks, or storage schema. */
+export interface SquareArtifactPort {
+    read(): Promise<{
+        state: SquareState;
+        version: number;
+    }>;
+    transact<R>(fn: (state: SquareState, version: number) => {
+        state?: SquareState;
+        result: R;
+    }): Promise<R>;
+    changed(sinceVersion: number, timeoutMs: number): Promise<boolean>;
+    close(): Promise<void>;
+}
+/** Capability-neutral wake transport. Unused by this Contract's activity operations. */
+export interface WakeTransportPort {
+    attempt(request: WakeRequest, timeoutMs: number): Promise<WakeOutcome>;
+    /** Optional route retirement supplied by the concrete executor adapter. */
+    invalidate?(request: WakeRequest): Promise<void>;
+}
+export interface WakeRequest {
+    readonly location: string;
+    readonly participant: string;
+    readonly activity: string;
+    readonly route: WakeRoute;
+}
+/** Executor-neutral presentation capability; intentionally separate from wake transport. */
+export interface PresentationSinkPort {
+    present(activity: StoredAct): void | Promise<void>;
+}
+/** Stable projection of a host binding; storage rows never cross this boundary. */
+export interface SessionBindingProjection {
+    readonly location: string;
+    readonly participant: string;
+    readonly sessionId: string;
+    readonly channel: import('./host-ledger.js').PresenceChannel;
+    readonly route?: WakeRoute;
+    readonly updatedAt: number;
+}
+/** Pending boundary presentation projected for one bound session. */
+export interface PresentationProjection {
+    readonly binding: SessionBindingProjection;
+    readonly joined: boolean;
+    readonly notifications: readonly InboxNotification[];
+    readonly catchLease?: WatchLease;
+}
+/** Read-only presentation evidence projection for diagnostics and migration callers. */
+export interface PresentationEvidenceProjection {
+    readonly location: string;
+    readonly participant: string;
+    readonly sessionId: string;
+    readonly activity: string;
+    readonly outcome: string;
+    readonly at?: number;
+}
+export type WakeOutcome = {
+    readonly outcome: 'accepted';
+    readonly signature?: string;
+    readonly attemptN?: number;
+} | {
+    readonly outcome: 'failed';
+    readonly message?: string;
+    readonly attemptN?: number;
+    readonly unavailable?: boolean;
+} | {
+    readonly outcome: 'unknown';
+    readonly diagnostic?: string;
+    readonly attemptN?: number;
+};
+export interface SquareObservation {
+    readonly location?: string;
+    readonly version: number;
+    readonly state: SquareState;
+    readonly pending: readonly {
+        readonly recipient: string;
+        readonly notifications: readonly PlannedNotification[];
+    }[];
+    readonly bindings: readonly SessionBindingProjection[];
+}
+export interface ObserveSquareInput {
+    readonly artifact: SquareArtifactPort;
+    readonly hostLedger?: HostLedgerPort;
+    readonly location?: string;
+    readonly now?: number;
+}
+export interface ReconcileBindingInput {
+    readonly artifact: SquareArtifactPort;
+    readonly hostLedger: HostLedgerPort;
+    readonly location?: string;
+    readonly scopes?: readonly import('./host-ledger.js').HostLedgerScope[];
+    readonly now?: number;
+}
+export interface DeliveryResult {
+    readonly attempted: number;
+    readonly accepted: number;
+    readonly failed: number;
+    readonly unknown: number;
+}
+export interface DeliverPendingInput {
+    readonly artifact: SquareArtifactPort;
+    readonly hostLedger: HostLedgerPort;
+    readonly transport: WakeTransportPort;
+    readonly location: string;
+    readonly timeoutMs?: number;
+    readonly now?: number;
+    readonly activity?: string | number;
+}
+export interface PresentationResult {
+    readonly presented: boolean;
+    readonly activity?: StoredAct;
+}
+export interface PresentPendingInput {
+    readonly artifact: SquareArtifactPort;
+    readonly location: string;
+    readonly participant: string;
+    readonly activity: string | number;
+    readonly sink: PresentationSinkPort;
+    readonly hostLedger?: HostLedgerPort;
+    readonly session?: string;
+    readonly now?: number;
+    readonly timeoutMs?: number;
+    /** Boundary previews that were clipped remain pending for a later full presentation. */
+    readonly markSeen?: boolean;
+}

package/dist/ports.js

@@ -0,0 +1 @@
+export {};

package/dist/presence.d.ts

@@ -3,5 +3,4 @@ import type { OpenSquare } from './open-square.js';
 import type { CatchOptions, CatchResult } from './square-facade.js';
 export declare function catchUp(square: OpenSquare, name: string, options?: CatchOptions, deriveDelivery?: (state: import('./model.js').SquareState) => DeliveryModel): Promise<CatchResult>;
 /** Commit seen only for complete, actually rendered boundary bodies. */
-export declare function markBoundarySeen(squarePath: string, name: string, ownerId: string | undefined, actIndexes: readonly number[], at?: number): Promise<void>;
-export declare function markNotificationNotified(square: OpenSquare, name: string, actIndex: number, ownerId: string | undefined, at?: number): Promise<void>;
+export declare function markBoundarySeen(squarePath: string, name: string, actIndexes: readonly number[], at?: number): Promise<void>;