@astrosheep/square 0.3.63 → 0.3.65

package/dist/inbox.js

@@ -1,39 +1,42 @@
-import { hostLedgerRoot } from './host-ledger-root.js';
+import { nameKey } from './model.js';
 import { openSquareArtifact, observeSquareChanges } from './square-file-adapter.js';
-import { createHostLedgerPort } from './host-ledger-file-adapter.js';
-import { canonicalFilePath } from './file-changes.js';
-import { pendingAtBoundary, presentationSuppressesWake, projectPresentation, projectPresentationEvidence, projectSessionBindings } from './square-projections.js';
-import { formatActivityId } from './square-core.js';
+import { hostLedgerForEnv } from './registry.js';
+import { canonicalPath } from './canonical-path.js';
+import { projectBoundaryEligibility, projectPresentation, projectSessionBindings } from './square-projections.js';
 import { WATCH_STALE_MS } from './runtime.js';
-export function hostLedgerForEnv(env) {
-    return createHostLedgerPort({ rootPath: hostLedgerRoot(env) });
-}
 function notificationKey(membership, actIndex) {
     return membership.squarePath + '\0' + membership.name.toLocaleLowerCase() + '\0' + actIndex;
 }
+async function readInboxMembership(binding, signal) {
+    const artifact = openSquareArtifact(binding.location, signal);
+    try {
+        const projection = await projectPresentation({ artifact, binding, now: Date.now() });
+        if (!projection.joined)
+            return undefined;
+        return { name: projection.binding.participant, squarePath: projection.binding.location,
+            notifications: [...projection.notifications],
+            ...(projection.catchLease === undefined ? {} : { catchLease: projection.catchLease }) };
+    }
+    finally {
+        await artifact.close();
+    }
+}
 export async function sessionInbox(sessionId, env = process.env, signal) {
     const inbox = [];
     const hostLedger = hostLedgerForEnv(env);
     for (const binding of await projectSessionBindings({ hostLedger, sessionId })) {
         if (signal?.aborted)
             throw signal.reason;
-        const artifact = openSquareArtifact(binding.location, signal);
         try {
-            const projection = await projectPresentation({ artifact, binding, now: Date.now() });
-            if (!projection.joined)
-                continue;
-            inbox.push({ name: projection.binding.participant, squarePath: projection.binding.location,
-                notifications: [...projection.notifications],
-                ...(projection.catchLease === undefined ? {} : { catchLease: projection.catchLease }) });
+            const membership = await readInboxMembership(binding, signal);
+            if (membership !== undefined)
+                inbox.push(membership);
         }
         catch (error) {
             if (signal?.aborted)
                 throw signal.reason ?? error;
             // A stale or unreadable membership cannot disable delivery for other memberships.
         }
-        finally {
-            await artifact.close();
-        }
     }
     return inbox;
 }
@@ -41,13 +44,28 @@ async function capture(observer, kind, signal) {
     const generation = observer.generation;
     try {
         const value = await observer.read(signal);
-        return { kind, wait: (timeout, abort) => observer.changed(value, timeout, abort) };
+        return { kind, value, wait: (timeout, abort) => observer.changed(value, timeout, abort) };
     }
     catch (error) {
         if (signal.aborted)
             throw signal.reason ?? error;
-        // Keep watching an unreadable/missing artifact so repair can restore delivery.
-        return { kind, wait: (timeout, abort) => observer.hinted(generation, timeout, abort) };
+        // Failed revision reads are not changes; only a successful retry wakes projection.
+        return { kind, wait: async (timeout, abort) => {
+                const deadline = Date.now() + Math.max(0, timeout);
+                let since = generation;
+                while (await observer.hinted(since, Math.max(0, deadline - Date.now()), abort)) {
+                    since = observer.generation;
+                    try {
+                        await observer.read(abort);
+                        return true;
+                    }
+                    catch (error) {
+                        if (abort.aborted)
+                            throw abort.reason ?? error;
+                    }
+                }
+                return false;
+            } };
     }
 }
 /** Session-scoped projection over process-shared storage change detectors. */
@@ -71,11 +89,11 @@ export async function observeSessionPending(sessionId, suppliedEnv = process.env
                 while (!signal.aborted) {
                     // Subscribe/capture the ledger BEFORE discovering bindings; a concurrent join cannot fall in a gap.
                     const sources = await Promise.all([capture(ledger.presence, 'presence', signal), capture(ledger.evidence, 'evidence', signal)]);
-                    const bindings = await projectSessionBindings({ hostLedger, sessionId });
-                    const paths = new Set(await Promise.all(bindings.map((binding) => canonicalFilePath(binding.location))));
-                    for (const [file, observer] of artifacts) {
+                    const bindings = await Promise.all((await projectSessionBindings({ hostLedger, sessionId })).map(async (binding) => ({ ...binding, location: await canonicalPath(binding.location) })));
+                    const paths = new Set(bindings.map((binding) => binding.location));
+                    for (const [file, entry] of artifacts) {
                         if (!paths.has(file)) {
-                            observer.close();
+                            entry.observer.close();
                             artifacts.delete(file);
                         }
                     }
@@ -87,22 +105,52 @@ export async function observeSessionPending(sessionId, suppliedEnv = process.env
                             observer.close();
                             return [];
                         }
-                        artifacts.set(file, observer);
+                        artifacts.set(file, { observer, inbox: new Map() });
                     }
-                    sources.push(...await Promise.all([...artifacts.values()].map((observer) => capture(observer, 'artifact', signal))));
-                    const inbox = await sessionInbox(sessionId, env, signal);
-                    const pending = [];
-                    for (const membership of pendingAtBoundary(inbox)) {
-                        const evidence = await projectPresentationEvidence({ hostLedger, location: membership.squarePath, participant: membership.name, sessionId });
-                        const notifications = membership.notifications.filter((notification) => !options.excludeKeys?.has(notificationKey(membership, notification.actIndex)) &&
-                            !presentationSuppressesWake(evidence.filter((row) => row.activity === formatActivityId(notification.actIndex))));
-                        if (notifications.length > 0)
-                            pending.push({ ...membership, notifications });
+                    for (const [file, entry] of artifacts) {
+                        const source = await capture(entry.observer, 'artifact', signal);
+                        sources.push(source);
+                        if (source.value === undefined || source.value !== entry.revision)
+                            entry.inbox.clear();
+                        entry.revision = source.value;
+                        const names = new Set(bindings.filter((binding) => binding.location === file).map((binding) => nameKey(binding.participant)));
+                        for (const name of entry.inbox.keys())
+                            if (!names.has(name))
+                                entry.inbox.delete(name);
                     }
-                    const eligible = JSON.stringify(pending.flatMap((membership) => membership.notifications.map((note) => notificationKey(membership, note.actIndex))).sort());
-                    if (previousEligible !== undefined && previousEligible !== eligible)
+                    const inbox = [];
+                    for (const binding of bindings) {
+                        if (signal.aborted)
+                            return [];
+                        const entry = artifacts.get(binding.location);
+                        const name = nameKey(binding.participant);
+                        try {
+                            if (!entry.inbox.has(name))
+                                entry.inbox.set(name, await readInboxMembership(binding, signal));
+                            const membership = entry.inbox.get(name);
+                            if (membership === undefined)
+                                continue;
+                            const { catchLease, ...rest } = membership;
+                            const now = Date.now();
+                            inbox.push(catchLease !== undefined && catchLease.expiresAt > now && now - catchLease.heartbeatAt <= WATCH_STALE_MS
+                                ? membership : rest);
+                        }
+                        catch (error) {
+                            if (signal.aborted)
+                                throw signal.reason ?? error;
+                            // Unreadable projections are retried, never cached as current.
+                        }
+                    }
+                    const eligible = await projectBoundaryEligibility({ hostLedger, sessionId, inbox });
+                    const excludeKeys = options.excludeKeys;
+                    const pending = excludeKeys === undefined ? eligible : eligible.flatMap((membership) => {
+                        const notifications = membership.notifications.filter((notification) => !excludeKeys.has(notificationKey(membership, notification.actIndex)));
+                        return notifications.length === 0 ? [] : [{ ...membership, notifications }];
+                    });
+                    const eligibleKeys = JSON.stringify(pending.flatMap((membership) => membership.notifications.map((note) => notificationKey(membership, note.actIndex))).sort());
+                    if (previousEligible !== undefined && previousEligible !== eligibleKeys)
                         canReturn = true;
-                    previousEligible = eligible;
+                    previousEligible = eligibleKeys;
                     if (signal.aborted)
                         return [];
                     if (canReturn && pending.length > 0)
@@ -161,19 +209,9 @@ export async function observeSessionPending(sessionId, suppliedEnv = process.env
             lifetime.abort();
             ledger.presence.close();
             ledger.evidence.close();
-            for (const observer of artifacts.values())
-                observer.close();
+            for (const entry of artifacts.values())
+                entry.observer.close();
             artifacts.clear();
         },
     };
 }
-/** Finite one-shot consumers retain their API; Pi owns a long-lived observer instead. */
-export async function waitForSessionPending(sessionId, timeoutMs, options = {}, env = process.env) {
-    const observer = await observeSessionPending(sessionId, env);
-    try {
-        return await observer.wait(timeoutMs, options);
-    }
-    finally {
-        observer.close();
-    }
-}

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { Square } from './square-wiring.js';
 export { createSquareApplication } from './square-application.js';
 export { SquareError } from './model.js';
-export { bindCurrentParticipant, squareAssignedParticipantName, unbindCurrentParticipant } from './registry.js';
+export { squareAssignedParticipantName } from './registry.js';
 export { createDefaultWakeTransport } from './notifications.js';
 export { createHostLedgerPort, FileHostLedgerPort } from './host-ledger-file-adapter.js';
 export type { HostLedgerPort, PresenceRecord, EvidenceRecord } from './host-ledger.js';

package/dist/index.js

@@ -1,6 +1,6 @@
 export { Square } from './square-wiring.js';
 export { createSquareApplication } from './square-application.js';
 export { SquareError } from './model.js';
-export { bindCurrentParticipant, squareAssignedParticipantName, unbindCurrentParticipant } from './registry.js';
+export { squareAssignedParticipantName } from './registry.js';
 export { createDefaultWakeTransport } from './notifications.js';
 export { createHostLedgerPort, FileHostLedgerPort } from './host-ledger-file-adapter.js';

package/dist/list.js

@@ -15,9 +15,6 @@ const CONTEXT_PREVIEW_LINES = 2;
 const PARTICIPANT_PREVIEW_COUNT = 3;
 const DISPLAY_CHARACTER_LIMIT = 160;
 const LIST_SKIP_DIRS = new Set(['.git', 'node_modules', 'dist']);
-function contextLines(lines) {
-    return lines.map((line) => line.trim()).filter(Boolean);
-}
 async function readSquareListItem(filePath, root) {
     let stat;
     try {
@@ -34,7 +31,7 @@ async function readSquareListItem(filePath, root) {
     return {
         path: relative,
         lastActiveAt: stat.mtimeMs,
-        context: contextLines([...projection.context]),
+        context: [...projection.context].map((line) => line.trim()).filter(Boolean),
         participants: [...projection.participants],
         activities: projection.activities,
     };

package/dist/mcp.js

@@ -3,45 +3,23 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { z } from 'zod/v4';
 import { SquareError, isSquareError } from './model.js';
 import { createSquareApplication } from './square-application.js';
-const activityIdSchema = { type: 'string', pattern: '^act/(0|[1-9][0-9]*)$' };
-const stringArraySchema = { type: 'array', items: { type: 'string' } };
-function objectSchema(properties, required = []) { return { properties, required }; }
+import { toPublicActivity } from './views.js';
+const activityId = z.string().regex(/^act\/(0|[1-9][0-9]*)$/);
+const stringArray = z.array(z.string());
 const TOOL_DEFINITIONS = [
-    { name: 'join', description: 'Join the square as the configured participant.', inputSchema: objectSchema({ takeover: { type: 'boolean' } }) },
-    { name: 'express', description: 'Express a message or embodied action in the square.', inputSchema: objectSchema({ body: { type: 'string' }, mentions: stringArraySchema, reach: { type: 'string', enum: ['bell'] }, reply: activityIdSchema, force: { type: 'boolean' }, noWait: { type: 'boolean' } }, ['body']) },
-    { name: 'catch', description: 'Catch and consume activities perceptible to the configured participant.', inputSchema: objectSchema({ id: activityIdSchema, idle: { type: 'number', minimum: 0 }, from: stringArraySchema, mention: { type: 'boolean' }, limit: { type: 'integer', minimum: 1 } }) },
-    { name: 'history', description: 'Read the activity stream using stable activity-id cursors.', inputSchema: objectSchema({ limit: { type: 'integer', minimum: 1 }, order: { type: 'string', enum: ['asc', 'desc'] }, before: activityIdSchema, after: activityIdSchema, grep: { type: 'string' }, fixed: { type: 'string' }, from: stringArraySchema, mention: { type: 'string' } }) },
-    { name: 'listen', description: 'Listen for future activity from a participant.', inputSchema: objectSchema({ target: { type: 'string' } }, ['target']) },
-    { name: 'ignore', description: 'Stop listening for future activity from a participant.', inputSchema: objectSchema({ target: { type: 'string' } }, ['target']) },
-    { name: 'listening', description: 'List participants this participant is listening to.', inputSchema: objectSchema({}) },
-    { name: 'hold', description: 'Raise a hand to hold the square.', inputSchema: objectSchema({ reason: { type: 'string' } }) },
-    { name: 'resume', description: 'Release the current hold.', inputSchema: objectSchema({}) },
-    { name: 'done', description: 'Leave the square without adding a message.', inputSchema: objectSchema({}) },
-    { name: 'status', description: 'Read the public status of the square.', inputSchema: objectSchema({}) },
-    { name: 'participants', description: 'List participants standing in or done with the square.', inputSchema: objectSchema({}) },
+    { name: 'join', description: 'Join the square as the configured participant.', inputSchema: z.object({ takeover: z.boolean().optional() }).strict() },
+    { name: 'express', description: 'Express a message or embodied action in the square.', inputSchema: z.object({ body: z.string(), mentions: stringArray.optional(), reach: z.enum(['bell']).optional(), reply: activityId.optional(), force: z.boolean().optional(), noWait: z.boolean().optional() }).strict() },
+    { name: 'catch', description: 'Catch and consume activities perceptible to the configured participant.', inputSchema: z.object({ id: activityId.optional(), idle: z.number().finite().min(0).optional(), from: stringArray.optional(), mention: z.boolean().optional(), limit: z.number().int().min(1).optional() }).strict() },
+    { name: 'history', description: 'Read the activity stream using stable activity-id cursors.', inputSchema: z.object({ limit: z.number().int().min(1).optional(), order: z.enum(['asc', 'desc']).optional(), before: activityId.optional(), after: activityId.optional(), grep: z.string().optional(), fixed: z.string().optional(), from: stringArray.optional(), mention: z.string().optional() }).strict() },
+    { name: 'listen', description: 'Listen for future activity from a participant.', inputSchema: z.object({ target: z.string() }).strict() },
+    { name: 'ignore', description: 'Stop listening for future activity from a participant.', inputSchema: z.object({ target: z.string() }).strict() },
+    { name: 'listening', description: 'List participants this participant is listening to.', inputSchema: z.object({}).strict() },
+    { name: 'hold', description: 'Raise a hand to hold the square.', inputSchema: z.object({ reason: z.string().optional() }).strict() },
+    { name: 'resume', description: 'Release the current hold.', inputSchema: z.object({}).strict() },
+    { name: 'done', description: 'Leave the square without adding a message.', inputSchema: z.object({}).strict() },
+    { name: 'status', description: 'Read the public status of the square.', inputSchema: z.object({}).strict() },
+    { name: 'participants', description: 'List participants standing in or done with the square.', inputSchema: z.object({}).strict() },
 ];
-function zodInputSchema(schema) {
-    const shape = {};
-    for (const [key, property] of Object.entries(schema.properties)) {
-        let field;
-        if (property.type === 'string' && property.enum !== undefined)
-            field = z.enum(property.enum);
-        else if (property.type === 'string')
-            field = property.pattern === undefined ? z.string() : z.string().regex(new RegExp(property.pattern));
-        else if (property.type === 'boolean')
-            field = z.boolean();
-        else if (property.type === 'number')
-            field = z.number().finite().min(property.minimum ?? -Infinity);
-        else if (property.type === 'integer')
-            field = z.number().int().min(property.minimum ?? -Infinity);
-        else if (property.type === 'array')
-            field = z.array(z.string());
-        else
-            throw new Error(`Unsupported input schema type: ${property.type}`);
-        shape[key] = schema.required.includes(key) ? field : field.optional();
-    }
-    return z.object(shape).strict();
-}
 function isObject(value) { return value !== null && typeof value === 'object' && !Array.isArray(value); }
 function publicActivity(activity) { return { ...activity }; }
 function publicResult(name, value) {
@@ -56,13 +34,13 @@ function publicResult(name, value) {
             doneCount: rest.doneCount,
             hold: rest.holdActive ? { by: rest.holdActor, ...(rest.holdReason === undefined ? {} : { reason: rest.holdReason }), ...(rest.holdAt === undefined ? {} : { at: rest.holdAt }) } : null,
             participants: participants.filter((participant) => participant.state !== 'not joined').map((participant) => ({ name: participant.name, state: participant.state, presence: participant.presence, activityCount: participant.activityCount, ...(participant.lastActiveAt === undefined ? {} : { lastActiveAt: participant.lastActiveAt }), unreadActivityCount: participant.unreadActivityCount, pendingMentionCount: participant.pendingMentionCount, listening: participant.listening })),
-            ...(latestAct === undefined ? {} : { latestActivity: publicActivity({ id: `act/${latestAct.index}`, at: latestAct.at, kind: latestAct.kind, actor: latestAct.actor ?? '', ...('body' in latestAct && latestAct.body !== undefined ? { body: latestAct.body } : {}), mentions: 'mentions' in latestAct ? latestAct.mentions ?? [] : [], ...('target' in latestAct ? { target: latestAct.target } : {}), ...(latestAct.kind === 'say' && latestAct.reach !== undefined ? { reach: latestAct.reach } : {}), ...(latestAct.kind === 'say' && latestAct.reply !== undefined ? { reply: `act/${latestAct.reply}` } : {}) }) }),
+            ...(latestAct === undefined ? {} : { latestActivity: publicActivity(toPublicActivity(latestAct)) }),
             now: rest.now,
         };
     }
     if (name === 'express' || name === 'hold' || name === 'resume' || name === 'done') {
         const result = value;
-        return { ...(result.activity === undefined ? {} : { activity: result.activity === null ? null : publicActivity(result.activity) }), ...(result.waited === undefined ? {} : { waited: result.waited }) };
+        return { ...(result.activity === undefined ? {} : { activity: result.activity === null ? null : publicActivity(result.activity) }), ...(result.waited === undefined ? {} : { waited: result.waited }), ...(result.replyAuthorNotHere === undefined ? {} : { replyAuthorNotHere: result.replyAuthorNotHere }) };
     }
     if (name === 'history')
         return { activities: value };
@@ -98,7 +76,7 @@ export function createSquareMcpServer(options) {
         instructions: 'The catch tool consumes activities. Use history with act/<index> cursors for read-only archive access.',
     });
     for (const tool of TOOL_DEFINITIONS) {
-        server.registerTool(tool.name, { description: tool.description, inputSchema: zodInputSchema(tool.inputSchema) }, async (args, extra) => {
+        server.registerTool(tool.name, { description: tool.description, inputSchema: tool.inputSchema }, async (args, extra) => {
             try {
                 const value = await operation(app, tool.name, args, { signal: extra.signal });
                 const projected = publicResult(tool.name, value);
@@ -118,5 +96,10 @@ export function createSquareMcpServer(options) {
     return server;
 }
 export async function runSquareMcpStdio(options) {
-    await createSquareMcpServer(options).connect(new StdioServerTransport());
+    const server = createSquareMcpServer(options);
+    const transport = new StdioServerTransport();
+    const close = () => { void server.close(); };
+    process.stdin.once('end', close);
+    process.stdin.once('close', close);
+    await server.connect(transport);
 }

package/dist/mention-parse.js

@@ -54,14 +54,6 @@ function codeSpanRanges(body) {
     }
     return ranges;
 }
-function codePointBefore(body, index) {
-    if (index <= 0)
-        return undefined;
-    const unit = body.charCodeAt(index - 1);
-    if (unit >= 0xdc00 && unit <= 0xdfff && index >= 2)
-        return String.fromCodePoint(body.codePointAt(index - 2));
-    return String.fromCodePoint(unit);
-}
 export function scanMentionCandidates(body) {
     const spans = codeSpanRanges(body);
     const found = [];
@@ -70,7 +62,9 @@ export function scanMentionCandidates(body) {
         const start = match.index;
         if (spans.some(([from, to]) => start >= from && start < to))
             continue;
-        const previous = codePointBefore(body, start);
+        const unit = start <= 0 ? undefined : body.charCodeAt(start - 1);
+        const previous = unit === undefined ? undefined
+            : unit >= 0xdc00 && unit <= 0xdfff && start >= 2 ? String.fromCodePoint(body.codePointAt(start - 2)) : String.fromCodePoint(unit);
         if (previous !== undefined && BOUNDARY_BLOCKER.test(previous))
             continue;
         const token = match[1];

package/dist/model.d.ts

@@ -1,10 +1,12 @@
 import type { Act, ActivityId } from './square-core.js';
 export { formatActivityId, parseActivityId } from './square-core.js';
 export type { Act, ActivityId, Audience, Reach } from './square-core.js';
-export declare const WAKE_ROUTE_KINDS: readonly ["opencode-server", "codex-queue", "claude-native", "pi-extension", "paseo"];
+export declare const WAKE_ROUTE_KINDS: readonly ["opencode-server", "codex-queue", "claude-native", "paseo"];
 export type WakeRouteKind = typeof WAKE_ROUTE_KINDS[number];
 export declare function isWakeRouteKind(value: unknown): value is WakeRouteKind;
 export interface WakeRoute {
+    /** Ownership generation, when the receiver publishes a fenced route. */
+    epoch?: number;
     location: string;
     participant: string;
     sessionId: string;
@@ -20,6 +22,13 @@ export type InternalSquareErrorCode = SquareErrorCode | 'not_found' | 'cap_reach
 export interface SquareErrorFacts {
     /** Express admission rejected before any activity was committed. */
     activityUnsent?: true;
+    /** Why a name could not be resolved: never in the roster, no longer standing in it, a bell
+     * colliding with a mention, an @name that matches nobody, or an activity catch cannot address. */
+    reason?: 'never_joined' | 'not_standing' | 'bell_mention_conflict' | 'unmatched_mention' | 'not_addressed';
+    /** The activity id a `catch --id` refusal named. */
+    activityId?: string;
+    /** Whether the artifact holds that activity at all; an unknown id needs an ordinary page. */
+    activityExists?: boolean;
     pending?: number;
     holder?: string;
     holdReason?: string;
@@ -62,7 +71,7 @@ export interface WatchLease {
     expiresAt: number;
     filter?: WatchLeaseFilter;
 }
-export type DirectedNotificationRoute = 'mention' | 'attention' | 'bell';
+export type DirectedNotificationRoute = 'mention' | 'reply' | 'attention' | 'bell';
 export interface InboxNotification {
     actIndex: number;
     actor: string;

package/dist/model.js

@@ -1,6 +1,6 @@
 // Shared model and constants for Square.
 export { formatActivityId, parseActivityId } from './square-core.js';
-export const WAKE_ROUTE_KINDS = ['opencode-server', 'codex-queue', 'claude-native', 'pi-extension', 'paseo'];
+export const WAKE_ROUTE_KINDS = ['opencode-server', 'codex-queue', 'claude-native', 'paseo'];
 export function isWakeRouteKind(value) {
     return typeof value === 'string' && WAKE_ROUTE_KINDS.includes(value);
 }

package/dist/notifications.d.ts

@@ -1,27 +1,16 @@
-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 WakeAdapter } from './delivery.js';
 import type { WakeTransportPort } from './ports.js';
 export type { PlannedNotification } from './delivery.js';
-export { planActNotifications, matchesMentionTarget };
-export { notificationMessageId } from './delivery.js';
 export declare const PRIVILEGED_HOOK_BUDGET_MS = 3000;
 export declare function wakeGraceMs(env?: NodeJS.ProcessEnv): number;
-export declare function hasDeliveredNotification(squarePath: string, name: string, ref: number | ActivityId): Promise<boolean>;
-export declare function hasAttentionNotification(squarePath: string, name: string, ref: number | ActivityId, env?: NodeJS.ProcessEnv): Promise<boolean>;
-export declare function waitForDeliveredNotification(squarePath: string, name: string, ref: number | ActivityId, opts?: {
-    timeoutMs?: number;
-    signal?: AbortSignal;
-}): Promise<boolean>;
 interface ProcessNotificationOptions {
     adapters?: WakeAdapter[];
     env?: NodeJS.ProcessEnv;
     now?: () => number;
 }
 export declare function defaultWakeAdapters(): Promise<WakeAdapter[]>;
-export declare function createDefaultWakeTransport(hostLedger: import('./host-ledger.js').HostLedgerPort, clock: () => number, env?: NodeJS.ProcessEnv): Promise<WakeTransportPort>;
-export declare function createWakeTransport(adapters: readonly WakeAdapter[], hostLedger: import('./host-ledger.js').HostLedgerPort, clock: () => number): WakeTransportPort;
+export declare function createDefaultWakeTransport(hostLedger: import('./host-ledger.js').HostLedgerPort, clock: () => number, env?: NodeJS.ProcessEnv, suppliedAdapters?: readonly WakeAdapter[]): Promise<WakeTransportPort>;
+export declare function createWakeTransport(adapters: readonly WakeAdapter[], hostLedger: import('./host-ledger.js').HostLedgerPort, clock: () => number, nativePorts?: Readonly<Partial<Record<import('./model.js').WakeRouteKind, WakeTransportPort>>>): WakeTransportPort;
 export declare function processActNotificationsOnce(squarePath: string, actIndex: number, opts?: ProcessNotificationOptions): Promise<import("./ports.js").DeliveryResult>;
 /** Privileged hook fallback: sweep indexed squares plus the current cwd's local squares within one boundary budget. */
 export declare function sweepPrivilegedPending(cwd: string, env?: NodeJS.ProcessEnv, suppliedAdapters?: WakeAdapter[], deadline?: number, signal?: AbortSignal): Promise<void>;
@@ -31,7 +20,5 @@ export interface SweepPendingNotificationsOptions {
     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: 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[]>;