@astrosheep/square 0.4.4 → 0.4.5

package/dist/plugins/opencode-shared/delivery.js

@@ -5,12 +5,13 @@ import { harnessOwner, decodeHarnessOwner } from '../../owner.js';
 import { attachDeliverySessionRoutes, detachDeliverySession, markDeliverySessionDeleted } from '../../session-lifecycle.js';
 const routeKind = 'opencode-server';
 const ownerFor = (sessionId) => harnessOwner({ channel: 'opencode', session: sessionId });
-const open = (env) => DeliveryLedger.open(env.SQUARE_DELIVERY ? { location: env.SQUARE_DELIVERY } : {});
+const open = (env, signal) => DeliveryLedger.open({ location: env.SQUARE_DELIVERY, signal });
 const payloadHash = (payload) => createHash('sha256').update(payload).digest('hex');
-export async function listOpenCodeSessions(env) {
-    const ledger = await open(env);
+export async function listOpenCodeSessions(env, signal) {
+    signal ??= AbortSignal.timeout(5000);
+    const ledger = await open(env, signal);
     try {
-        return (await ledger.sessions()).flatMap(session => {
+        return (await ledger.sessions(signal)).flatMap(session => {
             const coordinate = decodeHarnessOwner(session.owner);
             return session.state !== 'deleted' && coordinate?.channel === 'opencode' ? [coordinate.session] : [];
         });
@@ -20,8 +21,9 @@ export async function listOpenCodeSessions(env) {
     }
 }
 /** The file observer is a hint; callers must always reread the ledger after an edge. */
-export async function observeOpenCodeSessions(env) {
-    const ledger = await open(env);
+export async function observeOpenCodeSessions(env, signal) {
+    signal ??= AbortSignal.timeout(5000);
+    const ledger = await open(env, signal);
     const observer = await ledger.observe(ownerFor('discovery'));
     return { observer, close: async () => { observer.close(); await ledger.close(); } };
 }
@@ -29,25 +31,29 @@ export async function publishOpenCodeAddress(sessionId, env, signal) {
     const session = await attachDeliverySessionRoutes(ownerFor(sessionId), env, [{ kind: routeKind, address: { sessionId } }], signal);
     return session ? session.generation : undefined;
 }
-export async function currentOpenCodeGeneration(sessionId, env) {
-    const ledger = await open(env);
+export async function currentOpenCodeGeneration(sessionId, env, signal) {
+    signal ??= AbortSignal.timeout(5000);
+    const ledger = await open(env, signal);
     try {
-        return (await ledger.session(ownerFor(sessionId)))?.generation;
+        return (await ledger.session(ownerFor(sessionId), signal))?.generation;
     }
     finally {
         await ledger.close();
     }
 }
-export async function detachOpenCodeSession(sessionId, generation, env) {
-    await detachDeliverySession(ownerFor(sessionId), generation, env);
+export async function detachOpenCodeSession(sessionId, generation, env, signal) {
+    signal ??= AbortSignal.timeout(5000);
+    await detachDeliverySession(ownerFor(sessionId), generation, env, signal);
 }
-export async function endOpenCodeSession(sessionId, generation, env) {
-    await markDeliverySessionDeleted(ownerFor(sessionId), generation, env);
+export async function endOpenCodeSession(sessionId, generation, env, signal) {
+    signal ??= AbortSignal.timeout(5000);
+    await markDeliverySessionDeleted(ownerFor(sessionId), generation, env, signal);
 }
-export async function cancelOpenCodeDeliveries(sessionId, generation, env) {
-    const ledger = await open(env);
+export async function cancelOpenCodeDeliveries(sessionId, generation, env, signal) {
+    signal ??= AbortSignal.timeout(5000);
+    const ledger = await open(env, signal);
     try {
-        return await ledger.cancel({ owner: ownerFor(sessionId), generation });
+        return await ledger.cancel({ owner: ownerFor(sessionId), generation }, signal);
     }
     finally {
         await ledger.close();
@@ -66,15 +72,15 @@ export async function observeOpenCodeContext(sessionId, generation, messages, en
     }));
     if (!observed.size || signal.aborted)
         return;
-    const ledger = await open(env);
+    const ledger = await open(env, signal);
     try {
-        for (const attempt of await ledger.handoffs(ownerFor(sessionId), { generation })) {
+        for (const attempt of await ledger.handoffs(ownerFor(sessionId), { generation }, signal)) {
             if (signal.aborted)
                 return;
             const { correlation } = attempt;
             if (attempt.routeKind === routeKind && correlation.token === attempt.token && correlation.messageId !== undefined
                 && correlation.payloadHash !== undefined && observed.get(correlation.messageId) === correlation.payloadHash)
-                await ledger.observePresentation({ token: attempt.token, owner: ownerFor(sessionId), generation, routeKind, payloadHash: correlation.payloadHash }, { requireCurrent: true });
+                await ledger.observePresentation({ token: attempt.token, owner: ownerFor(sessionId), generation, routeKind, payloadHash: correlation.payloadHash }, { requireCurrent: true }, signal);
         }
     }
     finally {
@@ -83,13 +89,13 @@ export async function observeOpenCodeContext(sessionId, generation, messages, en
 }
 export async function receiveOpenCodePending(sessionId, generation, transport, env, signal) {
     const owner = ownerFor(sessionId);
-    const ledger = await open(env);
+    const ledger = await open(env, signal);
     const lifetime = retainDeliveryLedger(ledger);
     const observer = await ledger.observe(owner);
     try {
         while (!signal.aborted) {
             const baseline = observer.generation;
-            for (const card of await ledger.pending(owner, { generation })) {
+            for (const card of await ledger.pending(owner, { generation }, signal)) {
                 if (signal.aborted)
                     return;
                 lifetime.track(await ledger.dispatchHandoff(owner, card.key, transport, { generation, timeoutMs: 5000, signal }));

package/dist/plugins/opencode-v1/runtime.js

@@ -4,8 +4,8 @@ import { legacyTransport } from './transport.js';
 export async function startReceiver(ctx) {
     const env = { ...process.env };
     const directory = await canonicalPath(ctx.directory);
-    const discovery = await observeOpenCodeSessions(env);
     const lifetime = new AbortController();
+    const discovery = await observeOpenCodeSessions(env, lifetime.signal);
     const receivers = new Map();
     const terminal = new Set();
     const interrupting = new Set();
@@ -28,7 +28,7 @@ export async function startReceiver(ctx) {
             && await canonicalPath(info.directory) === directory;
     };
     const reconcile = async (active) => {
-        const candidates = new Set(await listOpenCodeSessions(env));
+        const candidates = new Set(await listOpenCodeSessions(env, lifetime.signal));
         if (active)
             candidates.add(active);
         for (const id of candidates) {
@@ -40,7 +40,7 @@ export async function startReceiver(ctx) {
                 const receiver = receivers.get(id);
                 stop(id);
                 if (receiver)
-                    await detachOpenCodeSession(id, receiver.generation, env);
+                    await detachOpenCodeSession(id, receiver.generation, env, lifetime.signal);
                 continue;
             }
             const existing = receivers.get(id);

package/dist/ports.d.ts

@@ -153,7 +153,3 @@ export interface SquareArtifactPort {
     changed(sinceVersion: number, timeoutMs: number, signal?: AbortSignal): Promise<boolean>;
     close(): Promise<void>;
 }
-export interface SquareResourceOwner {
-    artifact(location: string): SquareArtifactPort;
-    close(): Promise<void>;
-}

package/dist/presentation.d.ts

@@ -41,7 +41,7 @@ interface WatchStatusOptions extends ParticipantOutputOptions {
         participants: readonly ParticipantSummary[];
         now: number;
     };
-    showCatchHint?: boolean;
+    showPerceiveHint?: boolean;
     ownActivityCount?: number;
     hardCap?: number | null;
 }

package/dist/presentation.js

@@ -82,7 +82,7 @@ export function renderPresenceLines(recent, now, limit = 5) {
             ? (p.lastActiveAt === undefined ? 'stepped out of the square' : `stepped out of the square · ${formatRelativeTime(p.lastActiveAt, now)}`)
             : p.presence === 'away' ? 'is away'
                 : p.presence === 'watching'
-                    ? (p.lastActiveAt === undefined ? 'is nearby · catching' : `is nearby · catching · ${formatRelativeTime(p.lastActiveAt, now)}`)
+                    ? (p.lastActiveAt === undefined ? 'is nearby · perceiving' : `is nearby · perceiving · ${formatRelativeTime(p.lastActiveAt, now)}`)
                     : p.lastActiveAt === undefined ? 'is nearby · quiet'
                         : p.activityCount > 0 ? `is nearby · ${formatRelativeTime(p.lastActiveAt, now)}` : `is nearby · quiet · ${formatRelativeTime(p.lastActiveAt, now)}`;
         return `  ${glyph === '○' ? style('dim', glyph) : glyph} ${participantIdentity(p.name)}${style('dim', ` ${text}`)}`;
@@ -237,7 +237,7 @@ function renderUnreadSummary(activitySummaries) {
     ];
 }
 export function renderActivityBlocked(opts) {
-    const readNowCommand = `${participantCommandPrefix(opts.squarePath, opts.name, opts.owner)} catch`;
+    const readNowCommand = `${participantCommandPrefix(opts.squarePath, opts.name, opts.owner)} perceive`;
     return withPathOutput(opts.squarePath, [
         `${style('blocked', '✕')} your activity hasn't landed — someone spoke while you were away`,
         ...renderUnreadSummary(opts.activitySummaries),
@@ -339,20 +339,20 @@ export function renderActivityLimit(opts) {
 }
 export function renderWatchAlreadyActive(opts) {
     return [
-        `${style('blocked', '✕')} you are already catching`,
-        `  · an active catch is already running for ${participantIdentity(opts.name)}`,
-        '  · --replace lets a new catch take over',
-        `${participantCommandPrefix(opts.squarePath, opts.name, opts.owner)} catch --idle 30m --replace`,
+        `${style('blocked', '✕')} you are already perceiving`,
+        `  · an active perceive is already running for ${participantIdentity(opts.name)}`,
+        '  · --replace lets a new perceive take over',
+        `${participantCommandPrefix(opts.squarePath, opts.name, opts.owner)} perceive --idle 30m --replace`,
     ].join('\n');
 }
 export function renderWatchForceTakeover(_opts) {
-    return '✓ your new catch takes over';
+    return '✓ your new perceive takes over';
 }
 export function renderWatchReplaceMissing(_opts) {
-    return '· no catch stood here — yours takes the spot';
+    return '· no perceive stood here — yours takes the spot';
 }
 export function renderWatchReplaced(_opts) {
-    return '✕ a newer catch took over';
+    return '✕ a newer perceive took over';
 }
 export function renderWatchStatus(opts) {
     const others = opts.presence === undefined
@@ -365,18 +365,18 @@ export function renderWatchStatus(opts) {
         case 'idle':
         case 'drained': {
             const prefix = participantCommandPrefix(opts.squarePath, opts.name, opts.owner);
-            // Quiet graduates with the idle length; an empty catch has no idle budget to report.
+            // Quiet graduates with the idle length; an empty perceive has no idle budget to report.
             const idleMs = opts.idleMs;
             const quiet = idleMs !== undefined && idleMs >= 60 * 60 * 1000
                 ? style('dim', `○ dust lies thick — ${formatDuration(idleMs)} of quiet`)
                 : idleMs !== undefined && idleMs >= 60 * 1000
                     ? style('dim', `○ dust settles on the flagstones — ${formatDuration(idleMs)} of quiet`)
                     : style('dim', '○ only footsteps in the square — nothing new for you');
-            // The quiet report never repeats the catch just run.
-            const hints = [`${prefix} catch --idle 30m`];
+            // The quiet report never repeats the perceive just run.
+            const hints = [`${prefix} perceive --idle 30m`];
             return [
                 quiet,
-                ...(opts.showCatchHint === false ? [] : hints),
+                ...(opts.showPerceiveHint === false ? [] : hints),
                 ...presenceLines,
             ].join('\n');
         }

package/dist/session-lifecycle.d.ts

@@ -4,5 +4,5 @@ import type { Owner } from './owner.js';
 export declare function attachDeliverySession(owner: Owner, env?: NodeJS.ProcessEnv, routes?: readonly DeliveryRoute[], signal?: AbortSignal): Promise<DeliverySession | false>;
 /** Replace the supplied route kinds while preserving every other registered route. */
 export declare function attachDeliverySessionRoutes(owner: Owner, env: NodeJS.ProcessEnv | undefined, routes: readonly DeliveryRoute[], signal?: AbortSignal): Promise<DeliverySession | false>;
-export declare function detachDeliverySession(owner: Owner, generation: string, env?: NodeJS.ProcessEnv): Promise<boolean>;
-export declare function markDeliverySessionDeleted(owner: Owner, generation: string, env?: NodeJS.ProcessEnv): Promise<boolean>;
+export declare function detachDeliverySession(owner: Owner, generation: string, env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<boolean>;
+export declare function markDeliverySessionDeleted(owner: Owner, generation: string, env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<boolean>;

package/dist/session-lifecycle.js

@@ -1,6 +1,6 @@
 import { DeliveryLedger, deliveryLedgerLocation } from './delivery-ledger.js';
-function openLedger(env) {
-    return DeliveryLedger.open({ location: deliveryLedgerLocation(env) });
+function openLedger(env, signal) {
+    return DeliveryLedger.open({ location: deliveryLedgerLocation(env), signal });
 }
 /** Rotate the captured session generation; omitted routes retain its registrations. */
 export async function attachDeliverySession(owner, env = process.env, routes, signal) {
@@ -13,31 +13,31 @@ export async function attachDeliverySessionRoutes(owner, env = process.env, rout
 async function attach(owner, env, routes, merge, signal) {
     if (signal?.aborted)
         return false;
-    const ledger = await openLedger(env);
+    const ledger = await openLedger(env, signal);
     try {
-        const previous = await ledger.session(owner);
+        const previous = await ledger.session(owner, signal);
         if (signal?.aborted)
             return false;
         const selected = merge && routes ? [...(previous?.routes ?? []).filter(old => !routes.some(route => route.kind === old.kind)), ...routes] : routes ?? previous?.routes ?? [];
-        return await ledger.attach({ owner, expectedGeneration: previous?.generation ?? null, routes: selected });
+        return await ledger.attach({ owner, expectedGeneration: previous?.generation ?? null, routes: selected }, signal);
     }
     finally {
         await ledger.close();
     }
 }
-export async function detachDeliverySession(owner, generation, env = process.env) {
-    const ledger = await openLedger(env);
+export async function detachDeliverySession(owner, generation, env = process.env, signal) {
+    const ledger = await openLedger(env, signal);
     try {
-        return await ledger.detach({ owner, generation });
+        return await ledger.detach({ owner, generation }, signal);
     }
     finally {
         await ledger.close();
     }
 }
-export async function markDeliverySessionDeleted(owner, generation, env = process.env) {
-    const ledger = await openLedger(env);
+export async function markDeliverySessionDeleted(owner, generation, env = process.env, signal) {
+    const ledger = await openLedger(env, signal);
     try {
-        return await ledger.markDeleted({ owner, generation });
+        return await ledger.markDeleted({ owner, generation }, signal);
     }
     finally {
         await ledger.close();

package/dist/sqlite-square.d.ts

@@ -1,10 +1,9 @@
 import { type Owner } from './model.js';
 import type { HistoryQuery, HistoryResult, JoinOptions, JoinResult, ObservationOptions, OperationControl, Participant, SquareAtInput, SquareBuildInput, SquareLocation, StatusOptions, StatusResult, ParticipantsResult, RecoveryResult, DiscoveryOptions, InboxOptions, InboxResult, StreamOptions, StreamRecord, Activity, PerceivedActivity, SendInput, SendResult } from './square-facade.js';
 export type * from './square-facade.js';
-export { createSquareResourceOwner } from './artifact.js';
 export { squareClock } from './operation-control.js';
 export { formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE } from './square-core.js';
-export { CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT } from './catch-decisions.js';
+export { PERCEIVE_DEFAULT_LIMIT, PERCEIVE_MAX_LIMIT } from './perceive-decisions.js';
 export { HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT } from './views.js';
 export { DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT } from './list.js';
 /** One concrete local resource, including its entry-resolved dependencies and lifetime. */
@@ -13,14 +12,13 @@ export declare class SqliteSquare {
     private readonly artifact;
     private readonly clock;
     private readonly env;
-    private readonly closesArtifact;
     private readonly deliveryLocation;
     private constructor();
     private reconcile;
     private flush;
     static at(input: SquareAtInput, control?: OperationControl): Promise<SqliteSquare>;
     static build(input: SquareBuildInput, control?: OperationControl): Promise<SqliteSquare>;
-    static inMemory(input: Omit<SquareBuildInput, 'path' | 'resources'>): SqliteSquare;
+    static inMemory(input: Omit<SquareBuildInput, 'path'>): SqliteSquare;
     /** Join establishes membership and local producer custody in one transaction. */
     private joinSeat;
     private requiredSeat;

package/dist/sqlite-square.js

@@ -10,11 +10,11 @@ import { validateMetadataMatch } from './delivery-deferral.js';
 import { flushSquarePosts, reconcileSquareDelivery, readSquareSessions, ensureInitialDeliverySession } from './square-posting.js';
 import { attentionChange, coreDone, coreListening, decideAct, decideJoin, resolveKnownName, validateDoneBody } from './decisions.js';
 import { WATCH_HEARTBEAT_MS, inSquareCount, presenceAnchor } from './runtime.js';
-import { catchLimit, decideCatch, observeCatchSelection, selectCatchPage } from './catch-decisions.js';
+import { perceiveLimit, decidePerceive, observePerceiveSelection, selectPerceivePage } from './perceive-decisions.js';
 import { expressionContext } from './activity-feed.js';
 import { expressHint } from './hints.js';
 import { asSeatRef, participantAuthority, requireJoinName, requireOwner } from './seats.js';
-import { recoveryObservation, entryPresentation, queryStatus, queryParticipants, catchPresence, parseRequiredActivityId, toPublicActivity, toPerceivedActivity, publicActivities, selectHistory, NON_READ, HISTORY_MAX_LIMIT, HISTORY_DEFAULT_LIMIT } from './views.js';
+import { recoveryObservation, entryPresentation, queryStatus, queryParticipants, perceivePresence, parseRequiredActivityId, toPublicActivity, toPerceivedActivity, publicActivities, selectHistory, NON_READ, HISTORY_MAX_LIMIT, HISTORY_DEFAULT_LIMIT } from './views.js';
 import { sessionInboxCounts } from './inbox.js';
 import { participantIdentity } from './participant-identity.js';
 import { joinRecoveryCommand } from './presentation.js';
@@ -23,10 +23,9 @@ import { createArtifactPort, createSquare, diagnoseSquareFile, prepareSquareBuil
 import { activityQueryFilter } from './activity-query.js';
 import { discoverSquares } from './list.js';
 import { streamSquare } from './stream.js';
-export { createSquareResourceOwner } from './artifact.js';
 export { squareClock } from './operation-control.js';
 export { formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE } from './square-core.js';
-export { CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT } from './catch-decisions.js';
+export { PERCEIVE_DEFAULT_LIMIT, PERCEIVE_MAX_LIMIT } from './perceive-decisions.js';
 export { HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT } from './views.js';
 export { DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT } from './list.js';
 function rejectUnsentActivity(operation) {
@@ -45,32 +44,27 @@ export class SqliteSquare {
     artifact;
     clock;
     env;
-    closesArtifact;
     deliveryLocation;
-    constructor(location, artifact, clock, env, closesArtifact = true, deliveryLocation = location) {
+    constructor(location, artifact, clock, env, deliveryLocation = location) {
         this.location = location;
         this.artifact = artifact;
         this.clock = clock;
         this.env = env;
-        this.closesArtifact = closesArtifact;
         this.deliveryLocation = deliveryLocation;
     }
-    reconcile() { return reconcileSquareDelivery(this.artifact, this.deliveryLocation, this.env, this.clock); }
+    reconcile(signal) { return reconcileSquareDelivery(this.artifact, this.deliveryLocation, this.env, this.clock, signal); }
     // Posting is retryable after commit; a delivery failure cannot make a landed write unsent.
-    async flush() { await flushSquarePosts(this.artifact, this.deliveryLocation, this.env, this.clock).catch(() => undefined); }
+    async flush(signal) { await flushSquarePosts(this.artifact, this.deliveryLocation, this.env, this.clock, signal).catch(() => undefined); }
     static async at(input, control) {
         const env = { ...(input.env ?? process.env) }, location = squareLocation({ ...input, env });
         const clock = squareClock(env, input.clock);
-        // A request can abort its own borrowed reads, never the owner's connection lifetime.
-        const borrowed = input.resources?.artifact(location);
-        const artifact = borrowed ?? createArtifactPort(location, undefined, control?.signal);
+        const artifact = createArtifactPort(location, undefined, control?.signal);
         try {
             await artifact.read(facts => facts.header(), control?.signal);
-            return new SqliteSquare(location, artifact, clock, env, borrowed === undefined, await canonicalPath(location));
+            return new SqliteSquare(location, artifact, clock, env, await canonicalPath(location));
         }
         catch (error) {
-            if (borrowed === undefined)
-                await artifact.close();
+            await artifact.close();
             if (error instanceof InternalSquareError && error.code === 'not_found')
                 throw new SquareError('unavailable', `Square is unavailable at ${location}`);
             throw error;
@@ -156,7 +150,7 @@ export class SqliteSquare {
     async withHostPresence(select, control) {
         const seats = (await this.artifact.read(facts => facts.roster().filter(person => person.joined)
             .flatMap(person => { const seat = facts.seat(person.name); return seat === undefined ? [] : [seat]; }), control?.signal)).value;
-        const sessions = await readSquareSessions(seats, this.env);
+        const sessions = await readSquareSessions(seats, this.env, control?.signal);
         const captured = new Map(seats.map(seat => [nameKey(seat.participant), seat]));
         return (await this.artifact.read(facts => {
             const seat = (name) => {
@@ -197,14 +191,14 @@ export class SqliteSquare {
             let landedId;
             try {
                 checkControl(control);
-                await square.reconcile();
+                await square.reconcile(control?.signal);
                 name = (await square.artifact.read(facts => resolveKnownName(facts, this.name), control?.signal)).value;
                 const seat = this.seat;
                 const context = !options.observe ? undefined : (await square.artifact.read(facts => expressionContext(facts, name), control?.signal)).value;
                 while (true) {
                     checkControl(control);
                     try {
-                        await square.reconcile();
+                        await square.reconcile(control?.signal);
                         effect = 'unknown';
                         const now = square.clock();
                         const reply = rejectUnsentActivity(() => {
@@ -240,7 +234,7 @@ export class SqliteSquare {
                         }, control?.signal)).value;
                         landedId = formatActivityId(committed.stored.index);
                         effect = 'landed';
-                        await square.flush();
+                        await square.flush(control?.signal);
                         const { stored, standingCount, ownActivityCount, hardCap, ...metadata } = committed;
                         const hint = expressHint(ownActivityCount);
                         return { activity: toPublicActivity(stored), ...metadata,
@@ -267,7 +261,7 @@ export class SqliteSquare {
         async listener(verb, target, options, control) {
             const square = this.owner;
             checkControl(control);
-            await square.reconcile();
+            await square.reconcile(control?.signal);
             const name = (await square.artifact.read(facts => resolveKnownName(facts, this.name), control?.signal)).value;
             const seat = this.seat, now = square.clock();
             const result = (await square.artifact.transactAs(participantAuthority(seat), facts => {
@@ -278,7 +272,7 @@ export class SqliteSquare {
                             target: activity?.target ?? target,
                         } }) };
             }, control?.signal)).value;
-            await square.flush();
+            await square.flush(control?.signal);
             return result;
         }
         listen(target, options = {}, control) { return this.listener('listen', target, options, control); }
@@ -292,27 +286,27 @@ export class SqliteSquare {
             }, control?.signal)).value;
         }
         /** Receipt selection rechecks the lease inside the writer, not at its last heartbeat. */
-        async catchPage(name, seat, options, control, leaseId) {
-            await this.owner.reconcile();
+        async perceivePage(name, seat, options, control, leaseId) {
+            await this.owner.reconcile(control?.signal);
             return (await this.owner.artifact.transactAs(participantAuthority(seat), facts => {
                 if (leaseId !== undefined && facts.lease(name)?.leaseId !== leaseId)
                     return null;
-                return decideCatch(facts, name, options, this.owner.clock());
+                return decidePerceive(facts, name, options, this.owner.clock());
             }, control?.signal)).value;
         }
-        async catch(options = {}, control) {
+        async perceive(options = {}, control) {
             const square = this.owner;
             let name = this.name, subject = 'caller';
             let leaseId, seat;
             let selection = options;
             const idle = options.idle ?? 0;
-            const complete = async (caught, reason = 'drained') => {
-                const view = caught ?? (await square.artifact.read(facts => observeCatchSelection(facts, name, [], {
+            const complete = async (perceived, reason = 'drained') => {
+                const view = perceived ?? (await square.artifact.read(facts => observePerceiveSelection(facts, name, [], {
                     unseenOnly: true, senders: selection.from, ...(selection.mention === true ? { attentionOnly: true } : {}),
                 }, square.clock()))).value;
                 if (reason === 'drained')
                     reason = view.terminalStatus ?? reason;
-                await square.flush();
+                await square.flush(control?.signal);
                 if (leaseId !== undefined) {
                     await releaseWatchLease(square.artifact, seat, leaseId).catch(() => undefined);
                     leaseId = undefined;
@@ -321,7 +315,7 @@ export class SqliteSquare {
                 if (options.observe) {
                     try {
                         const observed = await square.withHostPresence((facts, available) => {
-                            const data = catchPresence(facts, square.clock());
+                            const data = perceivePresence(facts, square.clock());
                             return { presence: { ...data, participants: data.participants.map(person => ({ ...person, deliveryAvailable: available(person.name) })) },
                                 deliveryAvailable: available(view.participant) };
                         }, control);
@@ -340,15 +334,15 @@ export class SqliteSquare {
             };
             try {
                 checkControl(control);
-                await square.reconcile();
+                await square.reconcile(control?.signal);
                 validateName(name);
                 if (!Number.isFinite(idle) || idle < 0)
-                    throw new SquareError('invalid_args', 'Catch idle duration must be a non-negative number');
+                    throw new SquareError('invalid_args', 'Perceive idle duration must be a non-negative number');
                 if (options.id !== undefined && ['idle', 'from', 'mention', 'limit', 'replace'].some(key => Object.hasOwn(options, key)))
-                    throw new SquareError('invalid_args', 'Catch id cannot be combined with idle, from, mention, limit or replace');
+                    throw new SquareError('invalid_args', 'Perceive id cannot be combined with idle, from, mention, limit or replace');
                 if (Object.hasOwn(options, 'replace') && idle === 0)
-                    throw new SquareError('invalid_args', 'Catch replacement requires a positive idle duration');
-                catchLimit(options.limit);
+                    throw new SquareError('invalid_args', 'Perceive replacement requires a positive idle duration');
+                perceiveLimit(options.limit);
                 const probe = (await square.artifact.read(facts => {
                     name = resolveKnownName(facts, this.name);
                     seat = this.seat;
@@ -359,11 +353,11 @@ export class SqliteSquare {
                     subject = 'caller';
                     if (idle !== 0 || options.id !== undefined)
                         return undefined;
-                    const page = selectCatchPage(facts, name, selection);
-                    return page.indexes.length === 0 ? observeCatchSelection(facts, page.participant, [], page.filter, square.clock()) : undefined;
+                    const page = selectPerceivePage(facts, name, selection);
+                    return page.indexes.length === 0 ? observePerceiveSelection(facts, page.participant, [], page.filter, square.clock()) : undefined;
                 }, control?.signal)).value;
                 if (idle === 0) {
-                    const data = probe ?? (await this.catchPage(name, seat, selection, control));
+                    const data = probe ?? (await this.perceivePage(name, seat, selection, control));
                     return await complete(data);
                 }
                 const watch = {
@@ -374,7 +368,7 @@ export class SqliteSquare {
                 if (start.type === 'active')
                     return await complete(undefined, 'already-active');
                 leaseId = start.leaseId;
-                control?.onProgress?.({ kind: 'catch-started', participant: name, idleMs: idle, replacementRequested: options.replace ?? false, replaced: start.replaced });
+                control?.onProgress?.({ kind: 'perceive-started', participant: name, idleMs: idle, replacementRequested: options.replace ?? false, replaced: start.replaced });
                 const quietSince = square.clock();
                 let nextHeartbeat = start.heartbeatAt + WATCH_HEARTBEAT_MS;
                 while (true) {
@@ -388,11 +382,11 @@ export class SqliteSquare {
                         return await complete(undefined, pulse.status);
                     if (pulse.heartbeatAt !== undefined)
                         nextHeartbeat = pulse.heartbeatAt + WATCH_HEARTBEAT_MS;
-                    const caught = await this.catchPage(name, seat, selection, control, leaseId);
-                    if (caught === null)
+                    const perceived = await this.perceivePage(name, seat, selection, control, leaseId);
+                    if (perceived === null)
                         return await complete(undefined, 'replaced');
-                    if (caught.activities.length > 0)
-                        return await complete(caught);
+                    if (perceived.activities.length > 0)
+                        return await complete(perceived);
                     if (square.clock() - quietSince >= idle) {
                         const owns = await ownsWatchLease(square.artifact, seat, square.clock(), leaseId, control?.signal);
                         return await complete(undefined, owns ? 'idle' : 'replaced');
@@ -402,7 +396,7 @@ export class SqliteSquare {
                 }
             }
             catch (error) {
-                throw failure(error, { operation: 'catch', subject, participant: name });
+                throw failure(error, { operation: 'perceive', subject, participant: name });
             }
             finally {
                 // Cancellation releases only this captured generation and this lease.
@@ -459,7 +453,7 @@ export class SqliteSquare {
             validateDoneBody(body);
             checkControl(control);
             const square = this.owner;
-            await square.reconcile();
+            await square.reconcile(control?.signal);
             const name = (await square.artifact.read(facts => resolveKnownName(facts, this.name), control?.signal)).value;
             const seat = this.seat, now = square.clock();
             const result = (await square.artifact.transactAs(participantAuthority(seat), facts => {
@@ -467,15 +461,15 @@ export class SqliteSquare {
                 return { activity: toPublicActivity(stored), ...(!options.observe ? {} : { observation: square.observation(inSquareCount(facts), name, now),
                     }) };
             }, control?.signal)).value;
-            await square.flush();
+            await square.flush(control?.signal);
             return result;
         }
     };
     async send(input, control) {
         checkControl(control);
-        await this.reconcile();
+        await this.reconcile(control?.signal);
         const result = (await this.artifact.transactAs({ kind: 'send', actor: input.from }, facts => facts.insertNotice(input, this.clock()), control?.signal)).value;
-        await this.flush();
+        await this.flush(control?.signal);
         return result;
     }
     async participant(name, options) {
@@ -489,11 +483,11 @@ export class SqliteSquare {
             const last = options.last ?? HISTORY_DEFAULT_LIMIT;
             if (!Number.isSafeInteger(last) || last < 1 || last > HISTORY_MAX_LIMIT)
                 throw new SquareError('invalid_args', 'Join history limit must be between 1 and 100');
-            if (!await ensureInitialDeliverySession(requireOwner(options.owner), this.env, options.wakeAddress))
+            if (!await ensureInitialDeliverySession(requireOwner(options.owner), this.env, options.wakeAddress, control?.signal))
                 throw new SquareError('already_joined', `${participantIdentity(name)} is away; resume the host session first`, { reason: 'needs_seat' });
-            await this.reconcile();
+            await this.reconcile(control?.signal);
             const committed = await this.joinSeat(name, options, control);
-            await this.flush();
+            await this.flush(control?.signal);
             const participant = this.handle(committed.seat);
             const result = { participant, activity: committed.activity, kind: committed.kind,
                 ...(committed.observation === undefined ? {} : { observation: committed.observation }) };
@@ -579,14 +573,13 @@ export class SqliteSquare {
             .filter(seat => facts.participant(seat.participant)?.joined && seat.attachment === 'attached')
             .map(seat => ({ name: seat.participant, generation: seat.generation })))).value;
     }
-    close() { return this.closesArtifact ? this.artifact.close() : Promise.resolve(); }
+    close() { return this.artifact.close(); }
 }
 export function diagnoseSquare(input, control) { checkControl(control); return diagnoseSquareFile(squareLocation(input)); }
 export function discover(input, options = {}, control) {
-    if (input.path !== undefined || (input.env ?? process.env).SQUARE_LOCATION)
+    if (input.path !== undefined)
         squareLocation(input);
-    const env = { ...(input.env ?? process.env) };
-    return discoverSquares(input.cwd ?? process.cwd(), options, control, { clock: squareClock(env, input.clock) });
+    return discoverSquares(input.cwd ?? process.cwd(), options, control);
 }
 export async function inbox(input, owner, options = {}, control) {
     checkControl(control);

package/dist/sqlite-transaction.d.ts

@@ -1,5 +1,7 @@
 import type { DatabaseSync } from 'node:sqlite';
 /** Yield rather than blocking the process while another connection owns SQLite. */
 export declare function retrySqliteBusy<T>(operation: () => T, signal?: AbortSignal, retryMs?: number | (() => number)): Promise<T>;
+/** Cancel a queued caller promptly without releasing its place in the connection's serial chain. */
+export declare function awaitSqliteQueue<T>(result: Promise<T>, signal: AbortSignal | undefined, started: () => boolean): Promise<T>;
 /** Acquisition may retry; COMMIT retries retain the callback's result and transaction. */
 export declare function inSqliteTransaction<T, V>(db: DatabaseSync, write: boolean, validate: () => V, change: (validated: V) => T, signal?: AbortSignal): Promise<T>;