@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/core/run-log.js

@@ -1,334 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Per-run output logs under `.fireforge/logs/`.
- *
- * Without a log, a run's diagnosis exists in exactly one place: the terminal.
- * Piping through `tail`/`grep`, the ergonomic default when output is long,
- * keeps the summary and discards the `TEST-UNEXPECTED-FAIL` lines that say
- * what broke, and it launders the exit code besides. An operator rule
- * ("never pipe a run") does not hold in practice, so this is not an operator
- * problem: the tool is the only party that can make the log survive the
- * mistake.
- *
- * So `test` and `build` write their own complete copy as they stream, and the
- * `FIREFORGE-VERDICT:` line names the path. A piped, truncated, or
- * backgrounded run then still leaves a re-readable artifact.
- *
- * Everything here is best-effort. A log is a diagnostic aid, and a run must
- * never fail because one could not be opened, written, or pruned.
- * Every entry point swallows its errors and degrades to "no log", which is
- * exactly the behaviour of a run without this module.
- */
-import { createWriteStream } from 'node:fs';
-import { mkdir, readdir, stat, unlink } from 'node:fs/promises';
-import { basename as basenameOf, dirname, join, resolve } from 'node:path';
-import { Writable } from 'node:stream';
-import { toError } from '../utils/errors.js';
-import { verbose } from '../utils/logger.js';
-import { FIREFORGE_DIR } from './config-paths.js';
-import { redactRunLogText } from './run-log-redact.js';
-import { fileSafeTimestamp } from './state-file.js';
-/** Directory under `.fireforge/` holding run logs. */
-const LOGS_DIRNAME = 'logs';
-/**
- * How many logs to keep per command kind. Retention is per-kind so a busy
- * `test` loop cannot evict every `build` log, which is the pair an operator
- * most often needs to read together.
- */
-const RETAINED_LOGS_PER_COMMAND = 20;
-/**
- * Cap on the partial line held back between writes. A child emitting one
- * enormous unterminated line (a minified dump on stderr) would otherwise
- * grow the buffer without bound (and, because each write rebuilds
- * `pending + chunk`, quadratically), with nothing reaching disk until
- * close. Past the cap the tail is redacted and written as-is. A `KEY=value`
- * split exactly at the cap boundary is the accepted cost. Same figure as
- * `line-dispatch.ts` uses for the stream matchers.
- */
-const MAX_PENDING_LINE_SIZE = 1024 * 1024;
-/**
- * Index just past the last line terminator in `text`, or -1 when there is
- * none. `\n` and lone `\r` both terminate: progress-bar output (mach,
- * cargo) repaints a line with carriage returns and may never send a
- * newline, which would otherwise pin the whole run in `pending`. A single
- * trailing `\r` is not a terminator yet: it may be the first half of a
- * `\r\n` split across chunks.
- */
-function lastLineEnd(text) {
-    const lastNewline = text.lastIndexOf('\n');
-    const lastReturn = text.lastIndexOf('\r');
-    const cut = lastReturn > lastNewline && lastReturn < text.length - 1 ? lastReturn : lastNewline;
-    return cut === -1 ? -1 : cut + 1;
-}
-/** `.fireforge/logs` under `projectRoot`. */
-export function getRunLogDir(projectRoot) {
-    return join(projectRoot, FIREFORGE_DIR, LOGS_DIRNAME);
-}
-/**
- * Makes room for one new log by deleting the oldest, so that at most
- * {@link RETAINED_LOGS_PER_COMMAND} logs for `command` exist once the new
- * one is created. Pruning runs before the file is opened, hence the
- * `- 1`, without which the directory settles at N + 1.
- *
- * Best-effort: a failure here must not stop the run that is about to be
- * logged.
- */
-async function pruneRunLogs(dir, command) {
-    const keep = RETAINED_LOGS_PER_COMMAND - 1;
-    try {
-        const entries = await readdir(dir);
-        const mine = entries.filter((name) => name.startsWith(`${command}-`) && name.endsWith('.log'));
-        if (mine.length <= keep)
-            return;
-        // Names embed a lexically-sortable timestamp, so sorting is ordering by
-        // age without stat-ing every file.
-        const stale = mine.sort().slice(0, mine.length - keep);
-        await Promise.all(stale.map(async (name) => {
-            try {
-                await unlink(join(dir, name));
-            }
-            catch {
-                // A concurrent run may have pruned it already.
-            }
-        }));
-    }
-    catch (error) {
-        verbose(`Run-log pruning skipped: ${toError(error).message}`);
-    }
-}
-/**
- * Opens `.fireforge/logs/<command>-<timestamp>.log` for a run, pruning older
- * logs of the same kind first.
- *
- * @param projectRoot - Project root directory
- * @param command - Command kind, e.g. `test` or `build`
- * @param now - Clock injection point for deterministic tests
- * @returns The sink, or undefined when no log could be opened
- */
-export async function openRunLog(projectRoot, command, now = new Date()) {
-    const dir = getRunLogDir(projectRoot);
-    const path = join(dir, `${command}-${fileSafeTimestamp(now)}.log`);
-    try {
-        await mkdir(dir, { recursive: true });
-        await pruneRunLogs(dir, command);
-    }
-    catch (error) {
-        verbose(`Run log unavailable (${path}): ${toError(error).message}`);
-        return undefined;
-    }
-    return openRunLogSink(path);
-}
-/**
- * Opens one redacting log file at `path`, creating its directory.
- *
- * @param path - Absolute file path
- * @returns The sink, or undefined when the file could not be opened
- */
-async function openRunLogSink(path) {
-    let stream;
-    try {
-        await mkdir(dirname(path), { recursive: true });
-        stream = createWriteStream(path, { flags: 'a' });
-    }
-    catch (error) {
-        verbose(`Run log unavailable (${path}): ${toError(error).message}`);
-        return undefined;
-    }
-    // A stream error after open (disk full, a removed directory) must not
-    // become an unhandled 'error' event and kill the run the log exists to
-    // describe. Latch it and drop every later write.
-    let broken = false;
-    stream.on('error', (error) => {
-        broken = true;
-        verbose(`Run log write failed (${path}): ${error.message}`);
-    });
-    // Redaction is per LINE, and chunks arrive at arbitrary byte boundaries,
-    // so a `KEY=value` split across two chunks would slip past a per-chunk
-    // pass. Hold the trailing partial line until its terminator arrives (or
-    // it outgrows MAX_PENDING_LINE_SIZE, or the log is closed).
-    let pending = '';
-    const emit = (text) => {
-        if (broken || text.length === 0)
-            return;
-        try {
-            stream.write(redactRunLogText(text));
-        }
-        catch {
-            broken = true;
-        }
-    };
-    return {
-        path,
-        write: (chunk) => {
-            if (broken)
-                return;
-            const buffered = pending + chunk;
-            const lineEnd = lastLineEnd(buffered);
-            if (lineEnd === -1) {
-                pending = buffered;
-            }
-            else {
-                pending = buffered.slice(lineEnd);
-                emit(buffered.slice(0, lineEnd));
-            }
-            if (pending.length > MAX_PENDING_LINE_SIZE) {
-                emit(pending);
-                pending = '';
-            }
-        },
-        close: async () => {
-            const tail = pending;
-            pending = '';
-            emit(tail);
-            await new Promise((resolve) => {
-                stream.end(() => {
-                    resolve();
-                });
-            });
-        },
-    };
-}
-/** Environment variable naming where every run's log is also kept. */
-const LOG_KEEP_ENV_VAR = 'FIREFORGE_LOG_KEEP';
-/**
- * Where a run's kept copy goes: `--keep-log <path>` when given, else
- * {@link LOG_KEEP_ENV_VAR}, else nowhere. A value that ends in a path
- * separator or names an existing directory receives the log under its own
- * `.fireforge/logs/` basename, so a session-wide directory collects one
- * file per run. Any other value is the file itself. Relative values resolve
- * against the caller's working directory.
- *
- * @param flag - The `--keep-log` value, if any
- * @param basename - The run log's own file name
- * @returns The absolute destination, or undefined when none was asked for
- */
-async function resolveRunLogKeepPath(flag, basename) {
-    const raw = flag ?? process.env[LOG_KEEP_ENV_VAR]?.trim();
-    if (raw === undefined || raw.length === 0)
-        return undefined;
-    const target = resolve(raw);
-    let directory = /[\\/]$/.test(raw);
-    if (!directory) {
-        try {
-            directory = (await stat(target)).isDirectory();
-        }
-        catch {
-            directory = false;
-        }
-    }
-    return directory ? join(target, basename) : target;
-}
-/**
- * Tees a run log into a caller-chosen copy (`--keep-log`,
- * {@link LOG_KEEP_ENV_VAR}) that retention never prunes.
- *
- * `.fireforge/logs/` keeps twenty logs per command kind for EVERY session
- * on the checkout, so on a shared checkout a log named by a verdict line
- * can be gone within the hour, and a failure recorded only by its log path
- * cannot be read later. The copy is written live, line for line with the
- * same redaction, rather than copied at the end: a killed run keeps what it
- * had written, like the primary log does.
- *
- * The primary path stays the one `log=` names. When the primary could not
- * be opened the copy stands in for it.
- *
- * @param log - The primary run log, if one opened
- * @param flag - The `--keep-log` value, if any
- * @param command - Command kind, naming a copy that has no primary
- * @returns A sink writing to both, or whichever one opened
- */
-export async function keepRunLogCopy(log, flag, command) {
-    const basename = log === undefined ? `${command}-${fileSafeTimestamp(new Date())}.log` : basenameOf(log.path);
-    const keepPath = await resolveRunLogKeepPath(flag, basename);
-    if (keepPath === undefined || keepPath === log?.path)
-        return log;
-    const copy = await openRunLogSink(keepPath);
-    if (copy === undefined)
-        return log;
-    if (log === undefined)
-        return copy;
-    return {
-        path: log.path,
-        write: (chunk) => {
-            log.write(chunk);
-            copy.write(chunk);
-        },
-        close: async () => {
-            await Promise.all([log.close(), copy.close()]);
-        },
-    };
-}
-/**
- * The run log for the command currently executing, if any.
- *
- * Module state rather than a threaded parameter, for the same reason
- * `test-verdict.ts` keeps its emitted-once flag here: the sink has to be
- * reachable from `mach.ts`'s stream callbacks, which sit five frames below
- * the command that opened it, behind dispatch signatures that exist to
- * describe TESTS rather than logging. Threading it would have touched every
- * dispatcher, the retry wrapper and the shard loop to deliver one pointer.
- *
- * One command runs per process, so a single slot is the whole lifetime.
- */
-let activeRunLog;
-/** Newlines written to the active log so far, for line references into it. */
-let activeRunLogNewlines = 0;
-/** Installs (or clears, with `undefined`) the run log for this process. */
-export function setActiveRunLog(log) {
-    activeRunLog = log;
-    activeRunLogNewlines = 0;
-}
-/**
- * The 1-based line of the active run log the next write starts on.
- * Redaction rewrites within a line and never adds or drops one, so the
- * number holds for the file on disk.
- */
-export function activeRunLogLine() {
-    return activeRunLogNewlines + 1;
-}
-/** Absolute path of the active run log, or undefined when none is open. */
-export function getActiveRunLogPath() {
-    return activeRunLog?.path;
-}
-/** Appends to the active run log. A no-op when none is open. */
-export function writeToActiveRunLog(chunk) {
-    if (activeRunLog === undefined)
-        return;
-    for (let index = chunk.indexOf('\n'); index !== -1; index = chunk.indexOf('\n', index + 1)) {
-        activeRunLogNewlines += 1;
-    }
-    activeRunLog.write(chunk);
-}
-/**
- * Closes and clears the active run log. Resolves even when none is open.
- *
- * Also called from the entry point's SIGINT/SIGTERM path: the held partial
- * line and anything queued in the stream would otherwise be lost across
- * `process.exit`, and a killed run's last line is usually the one that
- * says what it was doing.
- */
-export async function closeActiveRunLog() {
-    const log = activeRunLog;
-    activeRunLog = undefined;
-    await log?.close();
-}
-/**
- * A writable that forwards to `base` and to the active run log.
- *
- * Used by the stdio-inheriting capture path, whose collectors take a mirror
- * stream rather than per-chunk callbacks, so the tee reuses the mirror the
- * exec layer already supports instead of growing a second hook.
- *
- * @param base - The stream to forward to (normally `process.stdout`)
- * @returns A writable teeing into `base` and the run log
- */
-export function teeToRunLog(base) {
-    return new Writable({
-        write(chunk, _encoding, callback) {
-            const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
-            base.write(text);
-            writeToActiveRunLog(text);
-            callback();
-        },
-    });
-}

package/dist/src/core/run-profile.d.ts

@@ -1,57 +0,0 @@
-/** Directory-name prefix of every FireForge-owned temporary run profile. */
-export declare const RUN_PROFILE_PREFIX = "fireforge-run-profile-";
-/** The profile a run launches with, and how to release it afterwards. */
-export interface RunProfile {
-    /** Program parameters to append to `mach run` (empty for mach's default). */
-    args: string[];
-    /** Absolute profile directory, when one was chosen. */
-    dir?: string;
-    /** Whether FireForge created the directory and will delete it. */
-    temporary: boolean;
-    /** Removes a temporary profile. A no-op otherwise. Never throws. */
-    dispose: () => Promise<void>;
-}
-/** Inputs to {@link resolveRunProfile}. */
-export interface RunProfileRequest {
-    /** `--profile <path>`: launch with this directory, left in place. */
-    profile?: string | undefined;
-    /** `--temp-profile`: launch with a fresh directory removed afterwards. */
-    tempProfile?: boolean | undefined;
-    /**
-     * Whether a named `profile` launches with `-purgecaches` (default `true`).
-     * A UI build does not change the build id the profile's startup cache is
-     * keyed on, so without it a kept profile runs the chrome scripts an
-     * earlier build cached. Temporary profiles start without a cache.
-     */
-    purgeCaches?: boolean | undefined;
-    /**
-     * Whether this is a `--smoke-exit` run. A smoke run with neither flag gets
-     * a temporary profile: the step exists to prove what the build does on a
-     * clean start, and the developer's profile-default carries whatever state
-     * the last session left.
-     */
-    smoke: boolean;
-    /** Base directory for temporary profiles (defaults to the OS tmpdir). */
-    tempRoot?: string | undefined;
-}
-/**
- * Removes every temporary run profile this process still holds. Called by
- * the CLI entry point's signal handler after child shutdown. Never throws.
- */
-export declare function removeActiveRunProfiles(): Promise<void>;
-/**
- * Chooses the profile for a run.
- * @param request - The run's profile flags
- * @returns The profile arguments and their release handle
- */
-export declare function resolveRunProfile(request: RunProfileRequest): Promise<RunProfile>;
-/**
- * Removes temporary run profiles whose owning FireForge process is gone.
- * The `finally` that releases a profile covers a clean exit, a failed run
- * and a forwarded SIGINT/SIGTERM, but not a SIGKILL of FireForge itself;
- * this sweep is the backstop for that case. A directory whose marker is
- * missing or unreadable is left alone: nothing proves it is abandoned.
- * @param tempRoot - Base directory to sweep (defaults to the OS tmpdir)
- * @returns The number of directories removed
- */
-export declare function sweepAbandonedRunProfiles(tempRoot?: string): Promise<number>;

package/dist/src/core/run-profile.js

@@ -1,137 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Profile selection for `fireforge run`.
- *
- * `mach run` on desktop has no `--profile` option of its own: its parser's
- * `--profile/-P` belongs to the Android run parser. On desktop a profile
- * reaches Firefox as a program parameter (`-profile <dir>`), and mach skips
- * creating the objdir's `tmp/profile-default` when it sees one among the
- * params.
- * Mach's `--temp-profile` does mint a fresh directory, but inside the objdir
- * and never removes it, so FireForge owns the temporary profile instead:
- * it creates the directory, seeds the two prefs mach would have written,
- * passes it as `-profile`, and deletes it when the run ends.
- */
-import { mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { InvalidArgumentError } from '../errors/base.js';
-import { isProcessAlive, toError } from '../utils/errors.js';
-import { verbose, warn } from '../utils/logger.js';
-/** Directory-name prefix of every FireForge-owned temporary run profile. */
-export const RUN_PROFILE_PREFIX = 'fireforge-run-profile-';
-/** Marker file naming the pid of the FireForge process that owns the profile. */
-const OWNER_MARKER = '.fireforge-run-owner';
-/**
- * The prefs `mach run` writes into the profiles it creates itself. A profile
- * passed with `-profile` gets none of them, and a first-run default-browser
- * prompt would sit in a headed smoke window.
- */
-const SEEDED_USER_JS = 'user_pref("browser.shell.checkDefaultBrowser", false);\n' +
-    'user_pref("browser.aboutConfig.showWarning", false);\n';
-/**
- * Temporary profiles this process created and has not yet removed. The
- * command's own `finally` loses the race to the entry point's signal
- * handler, whose `process.exit` never lets it run, so the handler removes
- * these itself once the browser tree has shut down.
- */
-const activeTemporaryProfiles = new Set();
-async function removeTemporaryProfile(dir) {
-    try {
-        await rm(dir, { recursive: true, force: true });
-        activeTemporaryProfiles.delete(dir);
-    }
-    catch (error) {
-        warn(`Could not remove temporary run profile ${dir}: ${toError(error).message}`);
-    }
-}
-/**
- * Removes every temporary run profile this process still holds. Called by
- * the CLI entry point's signal handler after child shutdown. Never throws.
- */
-export async function removeActiveRunProfiles() {
-    await Promise.all([...activeTemporaryProfiles].map((dir) => removeTemporaryProfile(dir)));
-}
-const NO_PROFILE = {
-    args: [],
-    temporary: false,
-    dispose: () => Promise.resolve(),
-};
-/**
- * Chooses the profile for a run.
- * @param request - The run's profile flags
- * @returns The profile arguments and their release handle
- */
-export async function resolveRunProfile(request) {
-    if (request.profile !== undefined && request.tempProfile === true) {
-        throw new InvalidArgumentError('--profile and --temp-profile are mutually exclusive: name a profile or ask for a fresh one.', 'profile');
-    }
-    if (request.profile !== undefined) {
-        const dir = resolve(request.profile);
-        const purge = request.purgeCaches === false ? [] : ['-purgecaches'];
-        return {
-            args: ['-profile', dir, ...purge],
-            dir,
-            temporary: false,
-            dispose: NO_PROFILE.dispose,
-        };
-    }
-    if (request.tempProfile !== true && !request.smoke) {
-        return NO_PROFILE;
-    }
-    const dir = await mkdtemp(join(request.tempRoot ?? tmpdir(), RUN_PROFILE_PREFIX));
-    activeTemporaryProfiles.add(dir);
-    // The owner marker goes in first, so a FireForge killed past this point
-    // leaves a directory the next run can prove abandoned.
-    await writeFile(join(dir, OWNER_MARKER), `${process.pid}\n`);
-    await writeFile(join(dir, 'user.js'), SEEDED_USER_JS);
-    verbose(`Temporary run profile: ${dir}`);
-    return {
-        args: ['-profile', dir],
-        dir,
-        temporary: true,
-        dispose: () => removeTemporaryProfile(dir),
-    };
-}
-/**
- * Removes temporary run profiles whose owning FireForge process is gone.
- * The `finally` that releases a profile covers a clean exit, a failed run
- * and a forwarded SIGINT/SIGTERM, but not a SIGKILL of FireForge itself;
- * this sweep is the backstop for that case. A directory whose marker is
- * missing or unreadable is left alone: nothing proves it is abandoned.
- * @param tempRoot - Base directory to sweep (defaults to the OS tmpdir)
- * @returns The number of directories removed
- */
-export async function sweepAbandonedRunProfiles(tempRoot = tmpdir()) {
-    let entries;
-    try {
-        entries = await readdir(tempRoot);
-    }
-    catch {
-        return 0;
-    }
-    let removed = 0;
-    for (const entry of entries) {
-        if (!entry.startsWith(RUN_PROFILE_PREFIX))
-            continue;
-        const dir = join(tempRoot, entry);
-        let pid;
-        try {
-            pid = Number.parseInt((await readFile(join(dir, OWNER_MARKER), 'utf8')).trim(), 10);
-        }
-        catch {
-            continue;
-        }
-        if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid || isProcessAlive(pid)) {
-            continue;
-        }
-        try {
-            await rm(dir, { recursive: true, force: true });
-            removed += 1;
-        }
-        catch (error) {
-            verbose(`Could not remove abandoned run profile ${dir}: ${toError(error).message}`);
-        }
-    }
-    return removed;
-}

package/dist/src/core/shared-ftl.d.ts

@@ -1,28 +0,0 @@
-/**
- * Structural rules for the `sharedFtl` field on a custom component.
- *
- * Both the `--shared-ftl` CLI flag path (`furnace create`) and the
- * furnace.json parser apply the same rules. Extracting them here
- * avoids drift between the two entry points and lets the `.mjs`
- * template generator assume the value is safe to interpolate verbatim.
- */
-/**
- * Outcome of {@link validateSharedFtl}. `ok: true` carries the trimmed
- * (operator-safe) value. `ok: false` carries a human-readable message
- * suitable for throwing as a `FurnaceError` or `InvalidArgumentError`.
- */
-export type SharedFtlValidation = {
-    ok: true;
-    value: string;
-} | {
-    ok: false;
-    reason: string;
-};
-/**
- * Validates a candidate `sharedFtl` value. Returns the trimmed value
- * when well-formed, or a structured reason when not. Callers throw the
- * error type appropriate to their context (CLI vs config parser).
- */
-export declare function validateSharedFtl(raw: unknown, context: {
-    localized: boolean;
-}): SharedFtlValidation;

package/dist/src/core/shared-ftl.js

@@ -1,49 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Structural rules for the `sharedFtl` field on a custom component.
- *
- * Both the `--shared-ftl` CLI flag path (`furnace create`) and the
- * furnace.json parser apply the same rules. Extracting them here
- * avoids drift between the two entry points and lets the `.mjs`
- * template generator assume the value is safe to interpolate verbatim.
- */
-/**
- * Characters that must not appear in `sharedFtl`.
- *
- * This is a policy rule about what a sensible FTL path looks like, not the
- * safety boundary for the generated `.mjs`. The scaffold escapes the value at
- * its sink with `JSON.stringify` (`commands/furnace/create-templates.ts`),
- * which is what actually makes interpolation safe, and what covers the two
- * inputs this rule never catches: a `"` and a raw newline.
- *
- * Kept because each remains a real sign of a malformed path:
- *  - `\` is a path-escape we do not want to interpret.
- *  - Backticks and `${` are inert in the current double-quoted sink, but a
- *    template-literal sink is one refactor away and they are not valid in a
- *    chrome:// FTL path regardless.
- */
-const UNSAFE_CHARS = /[`\\]|\$\{/;
-/**
- * Validates a candidate `sharedFtl` value. Returns the trimmed value
- * when well-formed, or a structured reason when not. Callers throw the
- * error type appropriate to their context (CLI vs config parser).
- */
-export function validateSharedFtl(raw, context) {
-    if (typeof raw !== 'string') {
-        return { ok: false, reason: 'must be a string when set' };
-    }
-    const value = raw.trim();
-    if (value.length === 0) {
-        return { ok: false, reason: 'must not be empty' };
-    }
-    if (UNSAFE_CHARS.test(value)) {
-        return {
-            ok: false,
-            reason: 'must not contain backticks, backslashes, or ${ (would break the generated .mjs)',
-        };
-    }
-    if (!context.localized) {
-        return { ok: false, reason: 'requires localized to be true' };
-    }
-    return { ok: true, value };
-}

package/dist/src/core/signal-critical.d.ts

@@ -1,38 +0,0 @@
-/**
- * Signal-deferred critical sections.
- *
- * Commands that perform a compound mutation (e.g. "apply a patch to the
- * engine, then persist progress to a session file on disk") need to finish
- * the pair atomically with respect to SIGINT / SIGTERM. The furnace rollback
- * mechanism is not the right tool here: rebase-style operations intentionally
- * leave the engine mutated and only need the on-disk bookkeeping write to
- * complete before the process exits.
- *
- * `runInSignalCriticalSection(fn)` wraps a short body in a registry slot.
- * While the body runs, the CLI entry point's SIGINT / SIGTERM handlers wait
- * for the slot to clear before calling `process.exit`, so a signal that
- * lands mid-body is held until the body's state write finishes.
- *
- * This module is a pure runtime registry. It installs no signal handlers
- * itself. The bin entry point is responsible for awaiting
- * `waitForActiveCriticalSections` before terminating.
- */
-/**
- * Runs `fn` inside a signal-deferred critical section. The CLI entry point's
- * signal handlers `await` every active section before exiting, so a SIGINT or
- * SIGTERM that arrives during `fn` will hold exit until `fn` returns (or
- * rejects).
- *
- * `fn` should be short. Anything that takes longer than the bounded wait in
- * the bin handler (`SIGNAL_CRITICAL_SECTION_TIMEOUT_MS`) will time out and
- * the handler will exit anyway. The intent is "guard the apply + state
- * persist pair," not "postpone exit indefinitely."
- */
-export declare function runInSignalCriticalSection<T>(label: string, fn: () => Promise<T>): Promise<T>;
-/**
- * Waits for every active critical section to complete or for `timeoutMs` to
- * elapse, whichever comes first. Never rejects: a section that throws still
- * resolves from the registry's perspective because `runInSignalCriticalSection`
- * cleans up in `finally`.
- */
-export declare function waitForActiveCriticalSections(timeoutMs: number): Promise<void>;