@astrosheep/square 0.3.94 → 0.3.95

package/dist/presentation.js

@@ -4,7 +4,6 @@ import path from 'node:path';
 import { participantIdentity } from './participant-identity.js';
 export { participantIdentity } from './participant-identity.js';
 import { formatActivityId, MAX_IDENTITY_SET_SIZE } from './square-core.js';
-import { HELD_WAIT_BUDGET_MS } from './runtime.js';
 import { formatDuration, formatRelativeTime, formatTimestamp } from './time.js';
 import { grepSnippet } from './search.js';
 import { style } from './tty-style.js';
@@ -27,8 +26,7 @@ export function displayPath(squarePath, cwd = process.cwd()) {
 }
 export function withPathOutput(squarePath, body = '', opts = {}) {
     const count = opts.participantCount ?? 0;
-    const heldSuffix = opts.held ? ' — a hand is raised' : '';
-    const line = `· ${displayPath(squarePath)} — ${count} in the square${heldSuffix}`;
+    const line = `· ${displayPath(squarePath)} — ${count} in the square`;
     return [opts.plain === true ? line : style('dim', line), ...(body === '' ? [] : ['', body])].join('\n') + '\n';
 }
 /** The same header/blank/body layout as withPathOutput, for refusal bodies written to stderr. */
@@ -123,10 +121,6 @@ export function renderRoomChangeText(event) {
             return `${identity} stepped into the square`;
         case 'done':
             return `${identity} stepped out of the square`;
-        case 'hold':
-            return `${identity} raised a hand${event.body ? ` — ${event.body}` : ''}`;
-        case 'resume':
-            return `${identity} lowered the hand`;
         case 'listen':
             return `${identity} turned an ear toward ${participantIdentity(event.target ?? 'someone')}`;
         case 'ignore':
@@ -159,10 +153,6 @@ function renderEventCliFacts(event, opts = {}) {
     switch (event.kind) {
         case 'join':
             return { text: `· ${renderRoomChangeText(event)}`, bodyClipped: false };
-        case 'hold':
-            return { text: `· ${renderRoomChangeText(event)}`, bodyClipped: false };
-        case 'resume':
-            return { text: `${style('release', '✓')} ${renderRoomChangeText(event)}`, bodyClipped: false };
         case 'listen':
         case 'ignore':
         case 'unlisten':
@@ -254,7 +244,7 @@ export function renderActivityBlocked(opts) {
         `${readNowCommand}`,
         '  · take it in, then retry:',
         withDraftInput(opts.retryCommand, opts.draftPath),
-    ].join('\n'), { participantCount: opts.participantCount, held: opts.held });
+    ].join('\n'), { participantCount: opts.participantCount });
 }
 /** An indeterminate or already-committed send only points to inspection, never resend. */
 export function renderActivityUncertain(opts) {
@@ -268,47 +258,22 @@ export function renderActivityUncertain(opts) {
         `${commandPrefix(opts.squarePath)} history${opts.landedId === undefined ? ' --limit 10' : ` --at ${opts.landedId}`} --no-truncate`,
     ], opts);
 }
-/** A blank or whitespace hold reason is absent, never an empty sensory line. */
-function holdReasonLines(reason) {
-    const text = reason?.trim() ?? '';
-    return text === '' ? [] : [style('dim', `  · ${text}`)];
-}
-function heldMainLine(holder, styled) {
-    const glyph = styled ? style('blocked', '✕') : '·';
-    const who = holder === undefined ? 'a hand is raised' : `${participantIdentity(holder)} has a hand raised`;
-    return `${glyph} ${who} — voices drop, yours too`;
-}
 export function renderExpressWaiting(opts) {
-    if (opts.reason === 'throttled') {
-        return [
-            '· the square is packed — your activity is waiting',
-            `  · a lull opens in ${formatDuration(opts.delayMs)}`,
-            '  · --no-wait saves a draft and returns now',
-        ].join('\n');
-    }
     return [
-        heldMainLine(opts.holder, false),
-        ...holdReasonLines(opts.holdReason),
-        `  · your activity is waiting — after ${formatDuration(HELD_WAIT_BUDGET_MS)} it saves a draft and stops`,
+        '· the square is packed — your activity is waiting',
+        `  · a lull opens in ${formatDuration(opts.delayMs)}`,
         '  · --no-wait saves a draft and returns now',
     ].join('\n');
 }
 export function renderExpressNoWait(opts) {
     const retryCommand = opts.retryCommand;
-    const lines = opts.reason === 'throttled'
-        ? [
-            `${style('blocked', '✕')} the square is packed — shoulder to shoulder`,
-            `  · a lull opens in ${formatDuration(opts.delayMs)}`,
-            ...draftSavedLines(opts.draftPath),
-            `${withDraftInput(retryCommand, opts.draftPath)}`,
-        ]
-        : [
-            heldMainLine(opts.holder, true),
-            ...holdReasonLines(opts.holdReason),
-            ...draftSavedLines(opts.draftPath),
-            `${withDraftInput(retryCommand, opts.draftPath)}`,
-        ];
-    return withPathOutput(opts.squarePath, lines.join('\n'), { participantCount: opts.participantCount, held: opts.held });
+    const lines = [
+        `${style('blocked', '✕')} the square is packed — shoulder to shoulder`,
+        `  · a lull opens in ${formatDuration(opts.delayMs)}`,
+        ...draftSavedLines(opts.draftPath),
+        `${withDraftInput(retryCommand, opts.draftPath)}`,
+    ];
+    return withPathOutput(opts.squarePath, lines.join('\n'), { participantCount: opts.participantCount });
 }
 export function renderPresenceAnchor(names) {
     const visibleNames = names.slice(0, MAX_IDENTITY_SET_SIZE);
@@ -327,7 +292,7 @@ export function renderGrepActivitiesView(visible, totalMatches, noTruncate, squa
     let truncated = false;
     for (const act of publicVisible) {
         const rawBody = act.body ?? '';
-        const header = `${style('dim', formatActivityId(act.index))} · ${act.actor === undefined ? 'unknown' : participantIdentity(act.actor)} · ${style('dim', formatTimestamp(act.at))}`;
+        const header = `${style('dim', formatActivityId(act.index))} · ${participantIdentity(act.actor)} · ${style('dim', formatTimestamp(act.at))}`;
         if (perception?.(act) === 'presence') {
             chunks.push(header);
             continue;
@@ -369,7 +334,7 @@ export function renderActivityLimit(opts) {
         ...draftSavedLines(opts.draftPath),
         '  · your draft stays unsent; done only steps out',
         doneCommand,
-    ].join('\n'), { participantCount: opts.participantCount, held: opts.held });
+    ].join('\n'), { participantCount: opts.participantCount });
 }
 export function renderWatchAlreadyActive(opts) {
     return [

package/dist/receive.d.ts

@@ -0,0 +1,66 @@
+/** Synchronous capabilities borrowed from one caller-owned transaction. */
+export interface Item<K extends string | number, D> {
+    readonly key: K;
+    readonly data: D;
+}
+export interface Address<V> {
+    readonly recipient: string;
+    readonly via: V;
+}
+export interface ReceivedHead<K extends string | number, V> {
+    readonly key: K;
+    readonly via: V;
+}
+export interface ReceiptRef<K extends string | number> {
+    readonly recipient: string;
+    readonly item: K;
+}
+export type Selection<K extends string | number, Q> = {
+    readonly kind: 'page';
+    readonly query: Q;
+    readonly limit: number;
+} | {
+    readonly kind: 'exact';
+    readonly key: K;
+    readonly remainingQuery: Q;
+};
+export interface ReceiveRead<K extends string | number, D, V, Q> {
+    heads(recipient: string, query: Q, options: {
+        readonly unconsumed: boolean;
+        readonly limit: number;
+    }): readonly ReceivedHead<K, V>[];
+    addressed(recipient: string, item: K): ReceivedHead<K, V> | undefined;
+    load(keys: readonly K[]): ReadonlyMap<K, D>;
+    count(recipient: string, query: Q, unconsumed: boolean): number;
+    receipt(ref: ReceiptRef<K>): {
+        readonly at: number;
+    } | undefined;
+}
+export interface ReceiveWrite<K extends string | number, D, V, Q> extends ReceiveRead<K, D, V, Q> {
+    insertItem(item: Item<K, D>): void;
+    insertAddress(item: K, address: Address<V>, order: number): void;
+    /** True only for a new coordinate; an existing receipt retains its first timestamp. */
+    insertReceipt(ref: ReceiptRef<K>, at: number): boolean;
+}
+export declare class ReceiveError<K extends string | number = string | number> extends Error {
+    readonly code: 'not_addressed' | 'missing_item';
+    readonly key: K;
+    constructor(code: 'not_addressed' | 'missing_item', key: K);
+}
+/** Storage rejects duplicate items/addresses; the caller rolls back the whole admission. */
+export declare function receive<K extends string | number, D, V>(tx: Pick<ReceiveWrite<K, D, V, unknown>, 'insertItem' | 'insertAddress'>, input: {
+    readonly item: Item<K, D>;
+    readonly audience: readonly Address<V>[];
+}): void;
+/** Queries filter before limiting. Exact selection ignores consumption, not addressing. */
+export declare function selectReceivedHeads<K extends string | number, V, Q>(tx: Pick<ReceiveRead<K, unknown, V, Q>, 'heads' | 'addressed'>, recipient: string, selection: Selection<K, Q>): readonly ReceivedHead<K, V>[];
+/** Record captured coordinates without reselecting or checking their current eligibility. */
+export declare function recordConsumed<K extends string | number>(tx: Pick<ReceiveWrite<K, unknown, unknown, unknown>, 'insertReceipt'>, refs: readonly ReceiptRef<K>[], at: number): number;
+/** Selection, hydration, receipts and remaining count must share the caller's transaction. */
+export declare function consumeReceived<K extends string | number, D, V, Q>(tx: Pick<ReceiveWrite<K, D, V, Q>, 'heads' | 'addressed' | 'load' | 'insertReceipt' | 'count'>, recipient: string, selection: Selection<K, Q>, at: number): {
+    readonly items: readonly (Item<K, D> & {
+        readonly via: V;
+    })[];
+    readonly newlyConsumed: number;
+    readonly remaining: number;
+};

package/dist/receive.js

@@ -0,0 +1,54 @@
+export class ReceiveError extends Error {
+    code;
+    key;
+    constructor(code, key) {
+        super(`${code}: ${String(key)}`);
+        this.code = code;
+        this.key = key;
+        this.name = 'ReceiveError';
+    }
+}
+/** Storage rejects duplicate items/addresses; the caller rolls back the whole admission. */
+export function receive(tx, input) {
+    tx.insertItem(input.item);
+    input.audience.forEach((address, order) => tx.insertAddress(input.item.key, address, order));
+}
+/** Queries filter before limiting. Exact selection ignores consumption, not addressing. */
+export function selectReceivedHeads(tx, recipient, selection) {
+    if (selection.kind === 'page') {
+        if (typeof selection.limit !== 'number')
+            throw new TypeError('Receive limit must be a number.');
+        if (!Number.isSafeInteger(selection.limit) || selection.limit < 1)
+            throw new RangeError('Receive limit must be a positive safe integer.');
+        return tx.heads(recipient, selection.query, { unconsumed: true, limit: selection.limit });
+    }
+    const head = tx.addressed(recipient, selection.key);
+    if (head === undefined)
+        throw new ReceiveError('not_addressed', selection.key);
+    return [head];
+}
+/** Record captured coordinates without reselecting or checking their current eligibility. */
+export function recordConsumed(tx, refs, at) {
+    if (typeof at !== 'number')
+        throw new TypeError('Receipt time must be a number.');
+    if (!Number.isFinite(at))
+        throw new RangeError('Receipt time must be finite.');
+    let count = 0;
+    for (const ref of refs)
+        if (tx.insertReceipt(ref, at))
+            count++;
+    return count;
+}
+/** Selection, hydration, receipts and remaining count must share the caller's transaction. */
+export function consumeReceived(tx, recipient, selection, at) {
+    const heads = selectReceivedHeads(tx, recipient, selection);
+    const data = tx.load(heads.map(head => head.key));
+    const items = heads.map(head => {
+        if (!data.has(head.key))
+            throw new ReceiveError('missing_item', head.key);
+        return { key: head.key, data: data.get(head.key), via: head.via };
+    });
+    const newlyConsumed = recordConsumed(tx, heads.map(head => ({ recipient, item: head.key })), at);
+    const remaining = tx.count(recipient, selection.kind === 'page' ? selection.query : selection.remainingQuery, true);
+    return { items, newlyConsumed, remaining };
+}

package/dist/runtime.d.ts

@@ -4,7 +4,6 @@ export declare const WATCH_HEARTBEAT_MS: number;
 export declare const WATCH_STALE_MS: number;
 export declare const THROTTLE_WINDOW_MS: number;
 export declare const UNREAD_BLOCK_GRACE_MS: number;
-export declare const HELD_WAIT_BUDGET_MS: number;
 export declare const FACT_PAGE_SIZE = 100;
 export declare function inSquareCount(facts: SquareRead): number;
 export declare function terminalStatusFor(current: ParticipantFact | undefined, hardCap: number | null, counts: ParticipantCounts): 'capped' | 'quorum' | undefined;

package/dist/runtime.js

@@ -12,7 +12,6 @@ export const WATCH_HEARTBEAT_MS = parseIntegerEnv('SQUARE_WATCH_HEARTBEAT_MS', 6
 export const WATCH_STALE_MS = parseIntegerEnv('SQUARE_WATCH_STALE_MS', 180000);
 export const THROTTLE_WINDOW_MS = parseIntegerEnv('SQUARE_THROTTLE_WINDOW_MS', 60000);
 export const UNREAD_BLOCK_GRACE_MS = parseIntegerEnv('SQUARE_UNREAD_BLOCK_GRACE_MS', 90000);
-export const HELD_WAIT_BUDGET_MS = parseIntegerEnv('SQUARE_HELD_WAIT_BUDGET_MS', 10 * 60 * 1000);
 export const FACT_PAGE_SIZE = 100;
 export function inSquareCount(facts) { return facts.participantCounts().joined; }
 export function terminalStatusFor(current, hardCap, counts) {
@@ -33,8 +32,8 @@ export function readCursor(facts, name) {
     const boundary = facts.participant(name)?.lastJoinIndex ?? -1;
     const block = facts.directed(name, { afterIndex: boundary, unseenOnly: true }, { edge: 'oldest', limit: 1 }).items[0]?.index;
     const last = facts.activityHeads({
-        afterIndex: boundary, ...(block === undefined ? {} : { beforeIndex: block }), actorRequired: true,
-        kinds: ['join', 'done', 'say', 'hold', 'resume', 'listen', 'ignore', 'unlisten'],
+        afterIndex: boundary, ...(block === undefined ? {} : { beforeIndex: block }),
+        kinds: ['join', 'done', 'say', 'listen', 'ignore', 'unlisten'],
     }, { edge: 'newest', limit: 1 }).items[0]?.index;
     return Math.max(boundary, last ?? boundary);
 }

package/dist/sqlite-square.d.ts

@@ -4,7 +4,6 @@ export type * from './square-facade.js';
 export { createSquareResourceOwner } from './artifact.js';
 export { formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE } from './square-core.js';
 export { CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT } from './catch-decisions.js';
-export { HELD_WAIT_BUDGET_MS } from './runtime.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';
 export declare function squareClock(env: NodeJS.ProcessEnv, clock?: () => number): () => number;

package/dist/sqlite-square.js

@@ -6,8 +6,8 @@ import { squareLocation } from './square-location.js';
 import crypto from 'node:crypto';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { InternalSquareError, SquareError, isSquareError, nameKey, validateName } from './model.js';
-import { coreDone, coreHold, coreIgnore, coreListen, coreListening, coreResume, coreUnlisten, decideAct, decideJoin, resolveKnownName, validateDoneBody } from './decisions.js';
-import { HELD_WAIT_BUDGET_MS, WATCH_HEARTBEAT_MS, inSquareCount, presenceAnchor } from './runtime.js';
+import { coreDone, coreIgnore, coreListen, coreListening, coreUnlisten, 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 { expressionContext } from './activity-feed.js';
 import { expressHint } from './hints.js';
@@ -26,7 +26,6 @@ import { streamSquare } from './stream.js';
 export { createSquareResourceOwner } from './artifact.js';
 export { formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE } from './square-core.js';
 export { CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT } from './catch-decisions.js';
-export { HELD_WAIT_BUDGET_MS } from './runtime.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 checkControl(control) {
@@ -115,12 +114,12 @@ export class SqliteSquare {
         if (this.indexPath !== undefined)
             await rememberSquarePath(this.location, owner, this.indexPath).catch(() => undefined);
     }
-    observation(standingCount, held, participant, now = this.clock()) {
-        return { location: this.location, standingCount, held, now,
+    observation(standingCount, participant, now = this.clock()) {
+        return { location: this.location, standingCount, now,
             ...(participant === undefined ? {} : { participant }) };
     }
     async contextObservation(participant, control) {
-        return (await this.artifact.read(facts => this.observation(inSquareCount(facts), facts.hold().active, participant), control?.signal)).value;
+        return (await this.artifact.read(facts => this.observation(inSquareCount(facts), participant), control?.signal)).value;
     }
     handle(seat) { return new SqliteSquare.ParticipantHandle(seat.participant, this, seat); }
     // The nested handle uses its resource's private dependencies without copying
@@ -142,7 +141,6 @@ export class SqliteSquare {
             const control = input === undefined ? operationControl : optionsOrControl;
             let name = this.name, effect = 'unsent';
             let landedId;
-            let heldWaitedMs = 0;
             try {
                 checkControl(control);
                 name = (await square.artifact.read(facts => resolveKnownName(facts, this.name), control?.signal)).value;
@@ -167,12 +165,9 @@ export class SqliteSquare {
                             // Decoding selected rows is storage work, not proof of safe admission refusal.
                             const proposed = decideAct(facts, { name, body, force: options.force ?? false, metadata: options.metadata, now, mentions: options.mentions,
                                 ...(options.reach === undefined ? {} : { reach: options.reach }), ...(options.noMention === undefined ? {} : { noMention: options.noMention }), ...(reply === undefined ? {} : { reply }) });
-                            const holder = proposed.type === 'held' ? facts.hold().actor : undefined;
                             const decision = rejectUnsentActivity(() => {
                                 if (proposed.type === 'blocked')
                                     throw new SquareError('behind', `${participantIdentity(name)} has pending activity`, { pending: proposed.activitySummaries.reduce((count, summary) => count + summary.count, 0) });
-                                if (proposed.type === 'held')
-                                    throw new SquareError('held', 'The square is held', { ...(holder === undefined ? {} : { holder }), ...(proposed.reason === undefined ? {} : { holdReason: proposed.reason }) });
                                 if (proposed.type === 'capped')
                                     throw new SquareError('capped', `${participantIdentity(name)} reached the activity cap`);
                                 if (proposed.type === 'throttled')
@@ -181,7 +176,7 @@ export class SqliteSquare {
                                     throw new SquareError('bell_quota', `${participantIdentity(name)} cannot ring the bell yet`, { retryAfterMs: Math.max(1, proposed.nextAt - now) });
                                 return proposed;
                             });
-                            return { stored: facts.land(decision.act), standingCount: inSquareCount(facts), held: facts.hold().active,
+                            return { stored: facts.land(decision.act), standingCount: inSquareCount(facts),
                                 ownActivityCount: facts.participant(name).sayCount, hardCap: facts.header().hardCap,
                                 ...(decision.unmatchedMentions === undefined ? {} : { unmatchedMentions: decision.unmatchedMentions }),
                                 ...(decision.replyAuthorNotHere === undefined ? {} : { replyAuthorNotHere: decision.replyAuthorNotHere }) };
@@ -190,33 +185,20 @@ export class SqliteSquare {
                         effect = 'landed';
                         if (square.wakeTransport !== undefined)
                             await deliverPending({ artifact: square.artifact, transport: square.wakeTransport, location: square.deliveryLocation, activity: committed.stored.index, now }).catch(() => undefined);
-                        const { stored, standingCount, held, ownActivityCount, hardCap, ...metadata } = committed;
+                        const { stored, standingCount, ownActivityCount, hardCap, ...metadata } = committed;
                         const hint = expressHint(ownActivityCount);
                         return { activity: toPublicActivity(stored), ...metadata,
                             ...(hint === undefined ? {} : { hint }), ...(context === undefined ? {} : { observation: {
-                                    ...square.observation(standingCount, held, name, now), ownActivityCount, hardCap, context, participant: name,
+                                    ...square.observation(standingCount, name, now), ownActivityCount, hardCap, context, participant: name,
                                 } }) };
                     }
                     catch (error) {
                         if (effect !== 'landed' && isSquareError(error) && error.facts?.activityUnsent === true)
                             effect = 'unsent';
-                        if (effect === 'landed' || !isSquareError(error) || options.noWait || (error.code !== 'held' && error.code !== 'throttled'))
+                        if (effect === 'landed' || !isSquareError(error) || options.noWait || error.code !== 'throttled')
                             throw error;
-                        if (error.code === 'held' && heldWaitedMs >= HELD_WAIT_BUDGET_MS)
-                            throw error;
-                        control?.onProgress?.({ kind: 'waiting', reason: error.code,
-                            ...(error.code === 'throttled' ? { delayMs: error.facts?.retryAfterMs ?? 1 } : {}),
-                            ...(error.facts?.holder === undefined ? {} : { holder: error.facts.holder }),
-                            ...(error.facts?.holdReason === undefined ? {} : { holdReason: error.facts.holdReason }) });
-                        if (error.code === 'throttled')
-                            await sleep(error.facts?.retryAfterMs ?? 1, undefined, { signal: control?.signal });
-                        else {
-                            const started = Date.now();
-                            const observation = await square.artifact.read(facts => facts.hold().active, control?.signal);
-                            if (observation.value)
-                                await square.artifact.changed(observation.version, Math.max(1, HELD_WAIT_BUDGET_MS - heldWaitedMs), control?.signal);
-                            heldWaitedMs += Date.now() - started;
-                        }
+                        control?.onProgress?.({ kind: 'waiting', reason: 'throttled', delayMs: error.facts?.retryAfterMs ?? 1 });
+                        await sleep(error.facts?.retryAfterMs ?? 1, undefined, { signal: control?.signal });
                     }
                 }
             }
@@ -235,7 +217,7 @@ export class SqliteSquare {
                 const act = verb === 'listen' ? coreListen(facts, name, target, now) : verb === 'ignore' ? coreIgnore(facts, name, target, now) : coreUnlisten(facts, name, target, now);
                 const activity = act === undefined ? null : toPublicActivity(facts.land(act));
                 return { activity, ...(!options.observe ? {} : { observation: {
-                            ...square.observation(inSquareCount(facts), facts.hold().active, name, now), participant: name,
+                            ...square.observation(inSquareCount(facts), name, now), participant: name,
                             target: activity?.target ?? target,
                         } }) };
             }, control?.signal)).value;
@@ -247,7 +229,7 @@ export class SqliteSquare {
             const square = this.owner;
             return (await square.artifact.read(facts => {
                 const name = resolveKnownName(facts, this.name);
-                return { listening: coreListening(facts, name), ...(!options.observe ? {} : { observation: square.observation(inSquareCount(facts), facts.hold().active, name) }) };
+                return { listening: coreListening(facts, name), ...(!options.observe ? {} : { observation: square.observation(inSquareCount(facts), name) }) };
             }, control?.signal)).value;
         }
         /** Receipt selection rechecks the lease inside the writer, not at its last heartbeat. */
@@ -283,7 +265,7 @@ export class SqliteSquare {
                 }
                 return { activities: view.activities, remaining: view.remaining, reason,
                     ...(view.hint === undefined ? {} : { hint: view.hint }), ...(!options.observe ? {} : { observation: {
-                            ...square.observation(view.standingCount, view.held, view.participant, view.now), participant: view.participant,
+                            ...square.observation(view.standingCount, view.participant, view.now), participant: view.participant,
                             deliveryAvailable: view.deliveryAvailable,
                             ownActivityCount: view.ownActivityCount, hardCap: view.hardCap,
                             ...(presence === undefined ? { enrichmentUnavailable: true } : { presence }),
@@ -325,7 +307,8 @@ export class SqliteSquare {
                     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 });
-                let quietSince = square.clock(), wasHeld = false, nextHeartbeat = start.heartbeatAt + WATCH_HEARTBEAT_MS;
+                const quietSince = square.clock();
+                let nextHeartbeat = start.heartbeatAt + WATCH_HEARTBEAT_MS;
                 while (true) {
                     checkControl(control);
                     // Arm before selecting: a commit during selection must not be missed.
@@ -337,21 +320,16 @@ export class SqliteSquare {
                         return await complete(undefined, pulse.status);
                     if (pulse.heartbeatAt !== undefined)
                         nextHeartbeat = pulse.heartbeatAt + WATCH_HEARTBEAT_MS;
-                    if (pulse.type === 'sleep') {
-                        const caught = await this.catchPage(name, seat, selection, control, leaseId);
-                        if (caught === null)
-                            return await complete(undefined, 'replaced');
-                        if (caught.activities.length > 0)
-                            return await complete(caught);
-                    }
-                    if (pulse.type === 'held' || wasHeld)
-                        quietSince = square.clock();
-                    wasHeld = pulse.type === 'held';
-                    if (!wasHeld && square.clock() - quietSince >= idle) {
+                    const caught = await this.catchPage(name, seat, selection, control, leaseId);
+                    if (caught === null)
+                        return await complete(undefined, 'replaced');
+                    if (caught.activities.length > 0)
+                        return await complete(caught);
+                    if (square.clock() - quietSince >= idle) {
                         const owns = await ownsWatchLease(square.artifact, seat, square.clock(), leaseId, control?.signal);
                         return await complete(undefined, owns ? 'idle' : 'replaced');
                     }
-                    const deadline = Math.min(nextHeartbeat, wasHeld ? Infinity : quietSince + idle);
+                    const deadline = Math.min(nextHeartbeat, quietSince + idle);
                     await square.artifact.changed(baseline, Math.max(0, deadline - square.clock()), control?.signal);
                 }
             }
@@ -392,21 +370,17 @@ export class SqliteSquare {
             const square = this.owner, seat = this.seat;
             return (await square.artifact.transactAs(participantAuthority(seat), facts => facts.releaseDeliveryDeferral(asSeatRef(seat), id, square.clock()), control?.signal)).value;
         }
-        async lifecycle(verb, body, options, control) {
-            if (verb === 'done')
-                validateDoneBody(body);
+        async done(body, options = {}, control) {
+            validateDoneBody(body);
             const square = this.owner;
             const name = (await square.artifact.read(facts => resolveKnownName(facts, this.name), control?.signal)).value;
             const seat = this.seat, now = square.clock();
             return (await square.artifact.transactAs(participantAuthority(seat), facts => {
-                const stored = facts.land(verb === 'done' ? coreDone(facts, name, body ?? '', now) : verb === 'hold' ? coreHold(facts, name, body ?? '', now) : coreResume(facts, name, now));
-                return { activity: toPublicActivity(stored), ...(!options.observe ? {} : { observation: square.observation(inSquareCount(facts), facts.hold().active, name, now),
+                const stored = facts.land(coreDone(facts, name, body ?? '', now));
+                return { activity: toPublicActivity(stored), ...(!options.observe ? {} : { observation: square.observation(inSquareCount(facts), name, now),
                     }) };
             }, control?.signal)).value;
         }
-        hold(reason, options = {}, control) { return this.lifecycle('hold', reason, options, control); }
-        resume(options = {}, control) { return this.lifecycle('resume', undefined, options, control); }
-        done(body, options = {}, control) { return this.lifecycle('done', body, options, control); }
     };
     async participant(name, { owner }) {
         validateName(name);
@@ -467,7 +441,7 @@ export class SqliteSquare {
                 if (seat === undefined)
                     throw new SquareError('invalid_args', 'The join activity did not establish its artifact seat.');
                 return { participant: this.handle(seat), activity, kind,
-                    ...(!options.observe ? {} : { observation: { ...this.observation(inSquareCount(facts), facts.hold().active, seat.participant, now),
+                    ...(!options.observe ? {} : { observation: { ...this.observation(inSquareCount(facts), seat.participant, now),
                             deliveryAvailable: seat.wakeAddress !== undefined } }) };
             }, control?.signal)).value;
             await this.publishSeat(owner);
@@ -535,7 +509,7 @@ export class SqliteSquare {
                 if (indexes.includes(anchor))
                     (presenceAnchors[anchor] ??= []).push(participant.name);
             }
-            return { activities, observation: { ...this.observation(inSquareCount(facts), facts.hold().active), ...selected,
+            return { activities, observation: { ...this.observation(inSquareCount(facts)), ...selected,
                     sayNumbers: facts.sayOrdinals(indexes), presenceAnchors } };
         }, control?.signal)).value;
     }

package/dist/square-api.d.ts

@@ -16,4 +16,4 @@ export declare function selectOwnSeat(square: Pick<SqliteSquare, 'participant' |
 }): Promise<Participant | undefined>;
 export { ACTIVITY_METADATA_MAX_BYTES } from './model.js';
 export { localUserOwner, harnessOwner, decodeHarnessOwner } from './owner.js';
-export { squareClock, createSquareResourceOwner, formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE, CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT, HELD_WAIT_BUDGET_MS, HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT, DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT, diagnoseSquare, migrateSquare, discover, inbox } from './sqlite-square.js';
+export { squareClock, createSquareResourceOwner, formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE, CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT, HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT, DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT, diagnoseSquare, migrateSquare, discover, inbox } from './sqlite-square.js';

package/dist/square-api.js

@@ -27,4 +27,4 @@ export async function selectOwnSeat(square, owner, name, options) {
 }
 export { ACTIVITY_METADATA_MAX_BYTES } from './model.js';
 export { localUserOwner, harnessOwner, decodeHarnessOwner } from './owner.js';
-export { squareClock, createSquareResourceOwner, formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE, CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT, HELD_WAIT_BUDGET_MS, HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT, DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT, diagnoseSquare, migrateSquare, discover, inbox } from './sqlite-square.js';
+export { squareClock, createSquareResourceOwner, formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE, CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT, HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT, DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT, diagnoseSquare, migrateSquare, discover, inbox } from './sqlite-square.js';

package/dist/square-core.d.ts

@@ -29,15 +29,6 @@ export type Act = {
     mentions?: readonly Participant[];
     reach?: Reach;
     reply?: number;
-} | {
-    kind: 'hold';
-    actor?: Participant;
-    at?: number;
-    body?: string;
-} | {
-    kind: 'resume';
-    actor?: Participant;
-    at?: number;
 } | {
     kind: 'read';
     actor: Participant;

package/dist/square-domain.js

@@ -1,35 +1,13 @@
 import { SquareError, formatActivityId, parseActivityId, sameName, validateOwner, validateName } from './model.js';
+import { resolveAudience } from './attention.js';
 /** The single landing transition, shared by both adapters and explicit rebuild. */
 export function deriveLanding(activity, facts) {
-    const audience = [];
-    if (activity.kind === 'say') {
-        const add = (requested, route) => {
-            const recipient = facts.standing.find((item) => sameName(item.name, requested))?.name;
-            if (recipient === undefined || sameName(recipient, activity.actor)
-                || audience.some((item) => sameName(item.recipient, recipient)))
-                return;
-            if (activity.reach !== 'bell' && facts.incoming.some((item) => item.kind === 'ignore' && sameName(item.listener, recipient)))
-                return;
-            audience.push({ recipient, route });
-        };
-        if (activity.reach === 'bell') {
-            for (const peer of facts.standing)
-                add(peer.name, 'bell');
-        }
-        else {
-            for (const mention of activity.mentions ?? [])
-                add(mention, 'mention');
-            if (facts.replyAuthor !== undefined)
-                add(facts.replyAuthor, 'reply');
-            for (const peer of facts.standing) {
-                if (facts.incoming.some((item) => item.kind === 'listen' && sameName(item.listener, peer.name)))
-                    add(peer.name, 'attention');
-            }
-        }
-    }
+    const audience = activity.kind === 'say' ? resolveAudience({
+        actor: activity.actor, recipients: facts.standing.map((item) => item.name),
+        mentions: activity.mentions, replyAuthor: facts.replyAuthor, reach: activity.reach,
+        incoming: facts.incoming, sameIdentity: sameName,
+    }) : [];
     const actor = activity.actor;
-    if (actor === undefined)
-        return { activity, audience };
     const previous = facts.actor ?? { name: actor, firstIndex: activity.index, joined: false, done: false, sayCount: 0 };
     const participant = {
         ...previous,
@@ -57,7 +35,7 @@ export function deriveLanding(activity, facts) {
 }
 export function landingFacts(read, activity) {
     return {
-        actor: activity.actor === undefined ? undefined : read.participant(activity.actor),
+        actor: read.participant(activity.actor),
         standing: activity.kind === 'say' ? read.roster().filter((item) => item.joined) : [],
         incoming: activity.kind === 'say' ? read.incomingAttention(activity.actor) : [],
         outgoing: activity.kind === 'listen' || activity.kind === 'ignore' || activity.kind === 'unlisten' ? read.attention(activity.actor) : [],
@@ -225,8 +203,8 @@ export function wrapSquareWrite(read, writes, authority) {
         },
         cancelThrough(seat, through) {
             assertSeat(seat);
-            if (!Number.isSafeInteger(through) || through < 0 || through > read.header().lastActIndex || read.activity(through) === undefined)
-                throw new SquareError('invalid_args', 'Cancellation boundary must name an existing activity at or below the current head.');
+            if (!Number.isSafeInteger(through) || through < 0 || through >= read.header().nextActIndex)
+                throw new SquareError('invalid_args', 'Cancellation boundary must be an assigned activity index below the allocator.');
             return mutations.cancelThrough(seat, through);
         },
         markSeen(name, indexes, at) {