@crouter/api 0.3.386 → 0.3.388

package/dist/core/user-settings.js

@@ -0,0 +1,458 @@
+import { CONDENSED_HISTORY_MODES, MOUSE_MODE_DEFAULTS, WHIP_MESSAGE_MODES } from '../types.js';
+function cycleChoice(choices, current, delta) {
+    const index = choices.indexOf(current);
+    const start = index >= 0 ? index : 0;
+    return choices[(start + delta + choices.length) % choices.length];
+}
+function cycleNumber(choices, current, delta) {
+    const exact = choices.indexOf(current);
+    if (exact >= 0)
+        return choices[(exact + delta + choices.length) % choices.length];
+    if (delta >= 0)
+        return choices.find((choice) => choice > current) ?? choices[0];
+    return [...choices].reverse().find((choice) => choice < current) ?? choices[choices.length - 1];
+}
+function booleanFromString(raw, key) {
+    if (raw === 'true')
+        return true;
+    if (raw === 'false')
+        return false;
+    return `${key} must be true or false`;
+}
+function nonNegativeIntegerFromString(raw, key) {
+    if (!/^\d+$/.test(raw))
+        return `${key} must be an integer >= 0`;
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value))
+        return `${key} must be an integer >= 0`;
+    return value;
+}
+function positiveIntegerFromString(raw, key) {
+    const value = nonNegativeIntegerFromString(raw, key);
+    if (typeof value === 'string' || value < 1)
+        return `${key} must be an integer >= 1`;
+    return value;
+}
+const AUTO_UPDATE_MODES = [false, 'notify', 'apply'];
+const UPDATE_INTERVAL_HOURS = [0, 1, 6, 12, 24, 48, 72, 168];
+const MAX_PANES = [1, 2, 3, 4, 5, 6, 8, 10, 12];
+const OPENAI_CODEX_PROVIDER_KEY = 'openai-codex';
+/** The options block for one provider, created on first write so a row can
+ *  toggle an option the config file has never named. */
+function providerOptionsFor(config, providerId) {
+    const existing = config.providerOptions[providerId];
+    if (existing !== undefined)
+        return existing;
+    const created = {};
+    config.providerOptions[providerId] = created;
+    return created;
+}
+const LIVE_CYCLES = [1, 2, 3, 4, 5, 6];
+/**
+ * Exhaustive settings-surface coverage for ScopeConfig. Primitive preferences
+ * are required by the type to define a Settings row; structured registries must
+ * name the specialized surface that owns them. Adding a config field therefore
+ * fails typecheck until its user-facing settings coverage is decided. The
+ * auto_update nested record is exhaustive for the same reason.
+ */
+export const CONFIG_SETTINGS_COVERAGE = {
+    schema_version: { surface: 'specialized', owner: 'internal schema migration' },
+    marketplaces: { surface: 'specialized', owner: 'Plugins and pkg market commands' },
+    plugins: { surface: 'specialized', owner: 'Plugins tab and pkg plugin commands' },
+    auto_update: {
+        surface: 'settings',
+        settings: {
+            crtr: {
+                key: 'auto_update.crtr',
+                label: 'crouter updates',
+                description: 'Notify about crouter releases, install them automatically, or turn checks off.',
+                valueConstraint: 'true|false|notify|apply; true stores notify',
+                applies: 'Applies on the next crouter command.',
+                group: 'updates',
+                order: 70,
+                format: (config) => config.auto_update.crtr === false ? 'off' : config.auto_update.crtr,
+                cycle: (config, delta) => { config.auto_update.crtr = cycleChoice(AUTO_UPDATE_MODES, config.auto_update.crtr, delta); },
+                setFromString: (config, raw) => {
+                    const value = raw === 'true' ? 'notify' : raw;
+                    if (value !== 'notify' && value !== 'apply' && value !== 'false')
+                        return 'auto_update.crtr must be notify, apply, or false';
+                    config.auto_update.crtr = value === 'false' ? false : value;
+                    return null;
+                },
+            },
+            content: {
+                key: 'auto_update.content',
+                label: 'Content updates',
+                description: 'Notify about plugin and marketplace updates, apply them automatically, or turn checks off.',
+                valueConstraint: 'false|notify|apply',
+                applies: 'Applies on the next crouter command.',
+                group: 'updates',
+                order: 80,
+                format: (config) => config.auto_update.content === false ? 'off' : config.auto_update.content,
+                cycle: (config, delta) => { config.auto_update.content = cycleChoice(AUTO_UPDATE_MODES, config.auto_update.content, delta); },
+                setFromString: (config, raw) => {
+                    if (raw !== 'notify' && raw !== 'apply' && raw !== 'false')
+                        return 'auto_update.content must be notify, apply, or false';
+                    config.auto_update.content = raw === 'false' ? false : raw;
+                    return null;
+                },
+            },
+            interval_hours: {
+                key: 'auto_update.interval_hours',
+                label: 'Update interval',
+                description: 'Minimum hours between automatic update checks. Zero checks on every command.',
+                valueConstraint: 'integer >= 0',
+                applies: 'Applies on the next crouter command.',
+                group: 'updates',
+                order: 90,
+                format: (config) => `${config.auto_update.interval_hours}h`,
+                cycle: (config, delta) => { config.auto_update.interval_hours = cycleNumber(UPDATE_INTERVAL_HOURS, config.auto_update.interval_hours, delta); },
+                setFromString: (config, raw) => {
+                    const value = nonNegativeIntegerFromString(raw, 'auto_update.interval_hours');
+                    if (typeof value === 'string')
+                        return value;
+                    config.auto_update.interval_hours = value;
+                    return null;
+                },
+            },
+        },
+    },
+    max_panes_per_window: {
+        surface: 'settings',
+        setting: {
+            key: 'max_panes_per_window',
+            label: 'Maximum panes',
+            description: 'Maximum human-review panes placed in one tmux window before using another window.',
+            valueConstraint: 'integer >= 1',
+            applies: 'Applies to the next pane placement.',
+            group: 'panes',
+            order: 20,
+            format: (config) => String(config.max_panes_per_window),
+            cycle: (config, delta) => { config.max_panes_per_window = cycleNumber(MAX_PANES, config.max_panes_per_window, delta); },
+            setFromString: (config, raw) => {
+                const value = positiveIntegerFromString(raw, 'max_panes_per_window');
+                if (typeof value === 'string')
+                    return value;
+                config.max_panes_per_window = value;
+                return null;
+            },
+        },
+    },
+    auto_open_child_viewers: {
+        surface: 'settings',
+        setting: {
+            key: 'auto_open_child_viewers',
+            label: 'Open child panes',
+            description: 'Open each managed child beside its watched parent. Off keeps new children running in the background.',
+            valueConstraint: 'true|false',
+            applies: 'Applies to the next managed child created; independent roots still open their attended viewer.',
+            group: 'panes',
+            order: 10,
+            format: (config) => config.auto_open_child_viewers ? 'on' : 'off',
+            cycle: (config) => { config.auto_open_child_viewers = !config.auto_open_child_viewers; },
+            setFromString: (config, raw) => {
+                const value = booleanFromString(raw, 'auto_open_child_viewers');
+                if (typeof value === 'string')
+                    return value;
+                config.auto_open_child_viewers = value;
+                return null;
+            },
+        },
+    },
+    brokerThresholds: { surface: 'specialized', owner: 'Broker limits tab' },
+    lifecycle: { surface: 'specialized', owner: 'sys config set lifecycle.unattendedParkMs' },
+    completion_bell: {
+        surface: 'settings',
+        setting: {
+            key: 'completion_bell',
+            label: 'Completion bell',
+            description: 'Ring a short sound when the node in an attached viewer finishes a turn.',
+            valueConstraint: 'true|false',
+            applies: 'Applies on the next turn end.',
+            group: 'display',
+            order: 41,
+            format: (config) => config.completion_bell ? 'on' : 'off',
+            cycle: (config) => { config.completion_bell = !config.completion_bell; },
+            setFromString: (config, raw) => {
+                const value = booleanFromString(raw, 'completion_bell');
+                if (typeof value === 'string')
+                    return value;
+                config.completion_bell = value;
+                return null;
+            },
+        },
+    },
+    working_gerunds: { surface: 'specialized', owner: 'sys config set working_gerunds' },
+    whip_mode: {
+        surface: 'settings',
+        setting: {
+            key: 'whip_mode',
+            label: 'Whip mode',
+            description: 'Play the whip animation when you send a prompt and when a viewer opens for an agent with an initial prompt.',
+            valueConstraint: 'true|false',
+            applies: 'Applies on the next attach.',
+            group: 'display',
+            order: 39,
+            format: (config) => config.whip_mode ? 'on' : 'off',
+            cycle: (config) => { config.whip_mode = !config.whip_mode; },
+            setFromString: (config, raw) => {
+                const value = booleanFromString(raw, 'whip_mode');
+                if (typeof value === 'string')
+                    return value;
+                config.whip_mode = value;
+                return null;
+            },
+        },
+    },
+    page_surface: {
+        surface: 'settings',
+        setting: {
+            key: 'page_surface',
+            label: 'Page human surface',
+            description: 'This host reads pages in a browser rather than a terminal. Agents are told the page module runs as written, HTML pages are offered, and document review and live display leave the command tree.',
+            valueConstraint: 'true|false',
+            applies: 'Applies when human command help is assembled.',
+            group: 'display',
+            order: 37,
+            format: (config) => config.page_surface ? 'on' : 'off',
+            cycle: (config) => { config.page_surface = !config.page_surface; },
+            setFromString: (config, raw) => {
+                const value = booleanFromString(raw, 'page_surface');
+                if (typeof value === 'string')
+                    return value;
+                config.page_surface = value;
+                return null;
+            },
+        },
+    },
+    whip_messages: { surface: 'specialized', owner: 'sys config set whip_messages' },
+    whip_message_mode: {
+        surface: 'settings',
+        setting: {
+            key: 'whip_message_mode',
+            label: 'Whip message',
+            description: 'What the whip action sends: a random line from whip_messages, or the fixed “Go faster”.',
+            valueConstraint: WHIP_MESSAGE_MODES.join('|'),
+            applies: 'Applies on the next attach.',
+            group: 'display',
+            order: 40,
+            format: (config) => config.whip_message_mode === 'go-faster' ? 'go faster' : 'random',
+            cycle: (config, delta) => { config.whip_message_mode = cycleChoice(WHIP_MESSAGE_MODES, config.whip_message_mode, delta); },
+            setFromString: (config, raw) => {
+                if (!WHIP_MESSAGE_MODES.includes(raw))
+                    return `whip_message_mode must be one of: ${WHIP_MESSAGE_MODES.join('|')}`;
+                config.whip_message_mode = raw;
+                return null;
+            },
+        },
+    },
+    mouse_mode_default: {
+        surface: 'settings',
+        setting: {
+            key: 'mouse_mode_default',
+            label: 'Default mouse mode',
+            description: 'Initial mouse wheel scrolling for each attached viewer.',
+            valueConstraint: MOUSE_MODE_DEFAULTS.join('|'),
+            applies: 'Applies on the next attach.',
+            group: 'display',
+            order: 38,
+            format: (config) => config.mouse_mode_default === 'tmux' ? 'follow tmux' : config.mouse_mode_default,
+            cycle: (config, delta) => { config.mouse_mode_default = cycleChoice(MOUSE_MODE_DEFAULTS, config.mouse_mode_default, delta); },
+            setFromString: (config, raw) => {
+                if (!MOUSE_MODE_DEFAULTS.includes(raw))
+                    return `mouse_mode_default must be one of: ${MOUSE_MODE_DEFAULTS.join('|')}`;
+                config.mouse_mode_default = raw;
+                return null;
+            },
+        },
+    },
+    live_cycles: {
+        surface: 'settings',
+        setting: {
+            key: 'live_cycles',
+            label: 'Live cycles',
+            description: 'Trailing refresh cycles rendered at full fidelity; older cycles condense to text.',
+            valueConstraint: 'integer >= 1',
+            applies: 'Applies on the next attach.',
+            group: 'display',
+            order: 50,
+            format: (config) => String(config.live_cycles),
+            cycle: (config, delta) => { config.live_cycles = cycleNumber(LIVE_CYCLES, config.live_cycles, delta); },
+            setFromString: (config, raw) => {
+                const value = positiveIntegerFromString(raw, 'live_cycles');
+                if (typeof value === 'string')
+                    return value;
+                config.live_cycles = value;
+                return null;
+            },
+        },
+    },
+    condensed_history: {
+        surface: 'settings',
+        setting: {
+            key: 'condensed_history',
+            label: 'Condensed history',
+            description: 'Messages retained from condensed cycles. Tool calls are never kept.',
+            valueConstraint: CONDENSED_HISTORY_MODES.join('|'),
+            applies: 'Applies on the next attach.',
+            group: 'display',
+            order: 60,
+            format: (config) => config.condensed_history,
+            cycle: (config, delta) => { config.condensed_history = cycleChoice(CONDENSED_HISTORY_MODES, config.condensed_history, delta); },
+            setFromString: (config, raw) => {
+                if (!CONDENSED_HISTORY_MODES.includes(raw))
+                    return `condensed_history must be one of: ${CONDENSED_HISTORY_MODES.join('|')}`;
+                config.condensed_history = raw;
+                return null;
+            },
+        },
+    },
+    bash_tool_purpose: {
+        surface: 'settings',
+        setting: {
+            key: 'bash_tool_purpose',
+            label: 'Bash purpose field',
+            description: 'Expose the optional purpose label to agents in the bash tool schema. Off removes the field without disabling the bash valve.',
+            valueConstraint: 'true|false',
+            applies: 'Applies on the next node session.',
+            group: 'display',
+            order: 25,
+            format: (config) => config.bash_tool_purpose ? 'on' : 'off',
+            cycle: (config) => { config.bash_tool_purpose = !config.bash_tool_purpose; },
+            setFromString: (config, raw) => {
+                const value = booleanFromString(raw, 'bash_tool_purpose');
+                if (typeof value === 'string')
+                    return value;
+                config.bash_tool_purpose = value;
+                return null;
+            },
+        },
+    },
+    fold_finished_tools: {
+        surface: 'settings',
+        setting: {
+            key: 'fold_finished_tools',
+            label: 'Fold finished tools',
+            description: 'Fold every settled tool call to its call line. Toggle live with /fold-tools.',
+            valueConstraint: 'true|false',
+            applies: 'Applies on the next attach.',
+            group: 'display',
+            order: 30,
+            format: (config) => config.fold_finished_tools ? 'on' : 'off',
+            cycle: (config) => { config.fold_finished_tools = !config.fold_finished_tools; },
+            setFromString: (config, raw) => {
+                const value = booleanFromString(raw, 'fold_finished_tools');
+                if (typeof value === 'string')
+                    return value;
+                config.fold_finished_tools = value;
+                return null;
+            },
+        },
+    },
+    summarize_tool_calls: {
+        surface: 'settings',
+        setting: {
+            key: 'summarize_tool_calls',
+            label: 'Summarize tool calls',
+            description: 'Replace completed folded tool-call groups with a one-line broker summary when available.',
+            valueConstraint: 'true|false',
+            applies: 'Applies when the next visible message closes a tool-call group.',
+            group: 'display',
+            order: 35,
+            format: (config) => config.summarize_tool_calls ? 'on' : 'off',
+            cycle: (config) => { config.summarize_tool_calls = !config.summarize_tool_calls; },
+            setFromString: (config, raw) => {
+                const value = booleanFromString(raw, 'summarize_tool_calls');
+                if (typeof value === 'string')
+                    return value;
+                config.summarize_tool_calls = value;
+                return null;
+            },
+        },
+    },
+    detailed_tool_recaps: {
+        surface: 'settings',
+        setting: {
+            key: 'detailed_tool_recaps',
+            label: 'Detailed tool recaps',
+            description: 'Show each document read and edited file in folded tool recaps. Off shows a compact count line instead.',
+            valueConstraint: 'true|false',
+            applies: 'Applies on the next attach.',
+            group: 'display',
+            order: 36,
+            format: (config) => config.detailed_tool_recaps ? 'on' : 'off',
+            cycle: (config) => { config.detailed_tool_recaps = !config.detailed_tool_recaps; },
+            setFromString: (config, raw) => {
+                const value = booleanFromString(raw, 'detailed_tool_recaps');
+                if (typeof value === 'string')
+                    return value;
+                config.detailed_tool_recaps = value;
+                return null;
+            },
+        },
+    },
+    keybindings: { surface: 'specialized', owner: 'Keybindings tab' },
+    tmux_passthrough: { surface: 'specialized', owner: 'Keybindings tab' },
+    providerOptions: {
+        surface: 'settings',
+        settings: {
+            'openai-codex.fastMode': {
+                key: `providerOptions.${OPENAI_CODEX_PROVIDER_KEY}.fastMode`,
+                label: 'Codex fast mode',
+                description: 'Serve Codex turns at the ChatGPT priority tier: about 1.5x faster generation for about 2x the credits. Displayed cost does not reflect the premium.',
+                valueConstraint: 'true|false',
+                applies: "Applies on each node's next turn.",
+                group: 'providers',
+                order: 40,
+                format: (config) => config.providerOptions[OPENAI_CODEX_PROVIDER_KEY]?.fastMode ? 'on' : 'off',
+                cycle: (config) => {
+                    const options = providerOptionsFor(config, OPENAI_CODEX_PROVIDER_KEY);
+                    options.fastMode = !options.fastMode;
+                },
+                setFromString: (config, raw) => {
+                    const value = booleanFromString(raw, `providerOptions.${OPENAI_CODEX_PROVIDER_KEY}.fastMode`);
+                    if (typeof value === 'string')
+                        return value;
+                    providerOptionsFor(config, OPENAI_CODEX_PROVIDER_KEY).fastMode = value;
+                    return null;
+                },
+            },
+        },
+    },
+    modelLadders: { surface: 'specialized', owner: 'Models tab' },
+    modelRoutes: { surface: 'specialized', owner: 'Models route declarations' },
+    modelRouting: { surface: 'specialized', owner: 'Models route declarations' },
+    kinds: { surface: 'specialized', owner: 'Models tab and kind registry' },
+    page_components: { surface: 'specialized', owner: 'Page component catalog: product-registered page component kinds' },
+    remoteCanvas: { surface: 'specialized', owner: 'canvas config commands' },
+    api: { surface: 'specialized', owner: 'sys connect' },
+    paths: { surface: 'specialized', owner: 'runtime layout' },
+    store: { surface: 'specialized', owner: 'daemon conversation store' },
+    runtime: { surface: 'specialized', owner: 'app-facing listener' },
+    spawnEnv: { surface: 'specialized', owner: 'spawn environment allow-list' },
+    bin: { surface: 'specialized', owner: 'bare-binary contributions on every node PATH' },
+    humanActions: { surface: 'specialized', owner: 'scope-configured human completion actions' },
+};
+/** The exhaustive top-level key list used by config persistence and help. */
+export const SCOPE_CONFIG_KEYS = Object.keys(CONFIG_SETTINGS_COVERAGE);
+function collectUserSettings() {
+    const out = [];
+    for (const coverage of Object.values(CONFIG_SETTINGS_COVERAGE)) {
+        if (coverage.surface !== 'settings')
+            continue;
+        if ('setting' in coverage)
+            out.push(coverage.setting);
+        else
+            out.push(...Object.values(coverage.settings));
+    }
+    return out.sort((a, b) => a.order - b.order);
+}
+/** The single row registry shared by `sys settings` and `sys config set`. */
+export const USER_SETTINGS = collectUserSettings();
+export function findUserSetting(key) {
+    return USER_SETTINGS.find((setting) => setting.key === key);
+}
+/** The rows one settings destination owns, in registry order. */
+export function userSettingsInGroup(group) {
+    return USER_SETTINGS.filter((setting) => setting.group === group);
+}

package/dist/daemon/broker-signals/bus.d.ts

@@ -0,0 +1,30 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { BrokerExtensionNodeDTO } from '../../api/dto/broker-ops.js';
+/** Node-owned mutable fields in extensionNode's projection. Keep this list and
+ * the typed cache view together; object/worktree-owned fields are never cached. */
+export declare const BROKER_SIGNAL_NODE_COLUMNS: readonly ["description", "title", "icon", "mode", "lifecycle", "status", "cwd", "parent", "fork_from", "profile_id", "review_binding_json", "persona_ack_json", "intent"];
+type ProjectedNodeKey<C extends string> = C extends 'review_binding_json' ? 'review_binding' : C extends 'persona_ack_json' ? 'persona_ack' : C;
+export type BrokerSignalCachedNode = Pick<BrokerExtensionNodeDTO, Extract<ProjectedNodeKey<(typeof BROKER_SIGNAL_NODE_COLUMNS)[number]>, keyof BrokerExtensionNodeDTO>>;
+/** Only node-owned columns are suitable for P4's cache. The source list also
+ * drives the SQLite trigger, so a newly added node field has one edit point. */
+export declare function cachedBrokerNodeFields(node: BrokerExtensionNodeDTO): BrokerSignalCachedNode;
+export type BrokerSignalKind = 'mail' | 'node';
+export type BrokerSignalSubscriber = (nodeId: string, kind: BrokerSignalKind) => void;
+/** Hints, not delivery state: a rolled-back write may mark a node. The consumer
+ * always re-reads durable state. Pending marks are bounded by distinct node ids. */
+export declare class BrokerSignalBus {
+    private readonly dirty;
+    private readonly subscribers;
+    private scheduled;
+    subscribe(listener: BrokerSignalSubscriber): () => void;
+    markMail(nodeId: string): void;
+    markNode(nodeId: string): void;
+    private mark;
+    private flush;
+    /** Reinstalled for every new daemon canvas handle (TEMP triggers vanish on close). */
+    install(db: DatabaseSync): void;
+    close(): void;
+}
+/** One daemon-process bus; the API fixture binds this same instance. */
+export declare const brokerSignalBus: BrokerSignalBus;
+export {};

package/dist/daemon/broker-signals/bus.js

@@ -0,0 +1,87 @@
+/** Node-owned mutable fields in extensionNode's projection. Keep this list and
+ * the typed cache view together; object/worktree-owned fields are never cached. */
+export const BROKER_SIGNAL_NODE_COLUMNS = [
+    'description', 'title', 'icon', 'mode', 'lifecycle', 'status', 'cwd',
+    'parent', 'fork_from', 'profile_id', 'review_binding_json',
+    'persona_ack_json', 'intent',
+];
+const nodeField = (column) => column === 'review_binding_json' ? 'review_binding' : column === 'persona_ack_json' ? 'persona_ack' : column;
+/** Only node-owned columns are suitable for P4's cache. The source list also
+ * drives the SQLite trigger, so a newly added node field has one edit point. */
+export function cachedBrokerNodeFields(node) {
+    const picked = {};
+    for (const column of BROKER_SIGNAL_NODE_COLUMNS) {
+        const field = nodeField(column);
+        picked[field] = node[field];
+    }
+    return picked;
+}
+/** Hints, not delivery state: a rolled-back write may mark a node. The consumer
+ * always re-reads durable state. Pending marks are bounded by distinct node ids. */
+export class BrokerSignalBus {
+    dirty = new Map();
+    subscribers = new Set();
+    scheduled;
+    subscribe(listener) {
+        this.subscribers.add(listener);
+        return () => { this.subscribers.delete(listener); };
+    }
+    markMail(nodeId) { this.mark(nodeId, 1); }
+    markNode(nodeId) { this.mark(nodeId, 2); }
+    mark(nodeId, flag) {
+        this.dirty.set(nodeId, (this.dirty.get(nodeId) ?? 0) | flag);
+        this.scheduled ??= setImmediate(() => this.flush());
+    }
+    flush() {
+        this.scheduled = undefined;
+        const batch = [...this.dirty];
+        this.dirty.clear();
+        for (const [id, flags] of batch) {
+            for (const listener of this.subscribers) {
+                try {
+                    if (flags & 1)
+                        listener(id, 'mail');
+                    if (flags & 2)
+                        listener(id, 'node');
+                }
+                catch { /* a subscriber never interrupts another subscriber */ }
+            }
+        }
+    }
+    /** Reinstalled for every new daemon canvas handle (TEMP triggers vanish on close). */
+    install(db) {
+        db.function('crtr_signal', { deterministic: false }, (kind, id) => {
+            // SQLite invokes this synchronously inside the writer's statement. A hint
+            // must never cause a transaction to fail, even for an unexpected row.
+            try {
+                if (typeof id === 'string') {
+                    if (kind === 'mail')
+                        this.markMail(id);
+                    if (kind === 'node')
+                        this.markNode(id);
+                }
+            }
+            catch { /* best-effort hint only */ }
+            return null;
+        });
+        db.exec(`
+      CREATE TEMP TRIGGER crtr_sig_deliv_ins AFTER INSERT ON main.deliveries
+        WHEN NEW.wake = 1 BEGIN SELECT crtr_signal('mail', NEW.destination_id); END;
+      CREATE TEMP TRIGGER crtr_sig_deliv_upd AFTER UPDATE OF state, canceled_at, claim_owner ON main.deliveries
+        WHEN NEW.wake = 1 BEGIN SELECT crtr_signal('mail', NEW.destination_id); END;
+      CREATE TEMP TRIGGER crtr_sig_deliv_del AFTER DELETE ON main.deliveries
+        WHEN OLD.wake = 1 BEGIN SELECT crtr_signal('mail', OLD.destination_id); END;
+      CREATE TEMP TRIGGER crtr_sig_node_upd AFTER UPDATE OF ${BROKER_SIGNAL_NODE_COLUMNS.join(', ')} ON main.nodes
+        BEGIN SELECT crtr_signal('node', NEW.node_id); END;
+    `);
+    }
+    close() {
+        if (this.scheduled !== undefined)
+            clearImmediate(this.scheduled);
+        this.scheduled = undefined;
+        this.dirty.clear();
+        this.subscribers.clear();
+    }
+}
+/** One daemon-process bus; the API fixture binds this same instance. */
+export const brokerSignalBus = new BrokerSignalBus();