@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/core/register-shared-css.d.ts

@@ -1,36 +0,0 @@
-/**
- * CSS registration in browser/themes/shared/jar.inc.mn.
- */
-import type { RegisterResult } from './register-result.js';
-/**
- * Measures the column at which the `(source)` parenthesis opens in adjacent
- * `skin/classic/browser/<x>.css (...)` entries inside an existing
- * jar.inc.mn body, and returns the maximum so a newly inserted entry can
- * align its source column to match.
- *
- * A fixed four-space gap regardless of the surrounding alignment lands a
- * freshly registered file at the wrong column and produces avoidable
- * formatting churn, since adjacent Firefox entries are typically padded to a
- * wider column. Returns `undefined` when no existing entries provide an
- * alignment signal. Callers fall back to the four-space default.
- */
-export declare function measureSourceColumn(content: string): number | undefined;
-/**
- * Builds a `skin/classic/browser/<name>.css   (../shared/<name>.css)`
- * line padded so the parenthesis lands at {@link sourceColumn} (when
- * supplied) or at the default four-space gap (when {@link sourceColumn}
- * is `undefined` or would force the parenthesis closer to the target
- * than {@link MIN_SOURCE_GAP}).
- */
-export declare function buildEntry(name: string, sourceColumn: number | undefined): string;
-/**
- * Registers a CSS file in browser/themes/shared/jar.inc.mn.
- *
- * Entry format:
- *   skin/classic/browser/{name}.css    (../shared/{name}.css)
- *
- * The gap between target and source is sized to align with adjacent
- * entries when the manifest already uses a wider column. It falls back
- * to a four-space minimum otherwise.
- */
-export declare function registerSharedCSS(engineDir: string, fileName: string, after?: string, dryRun?: boolean): Promise<RegisterResult>;

package/dist/src/core/register-shared-css.js

@@ -1,112 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * CSS registration in browser/themes/shared/jar.inc.mn.
- */
-import { basename, join } from 'node:path';
-import { GeneralError } from '../errors/base.js';
-import { pathExists, readText, writeText } from '../utils/fs.js';
-import { normalizePathSlashes } from '../utils/paths.js';
-import { insertJarMnEntry } from './moz-manifest-helpers.js';
-/**
- * Tokenizer-based implementation for shared CSS registration.
- */
-function registerSharedCSSTokenized(content, name, entry, after) {
-    return insertJarMnEntry(content, entry, {
-        sortPattern: /skin\/classic\/browser\/([^.]+)\.css/,
-        sortKey: name,
-        missingSectionMessage: 'Could not find skin/classic/browser/ section in jar.inc.mn',
-        after,
-    });
-}
-/** Minimum gap between the target path and the source parenthesis. */
-const MIN_SOURCE_GAP = 4;
-/**
- * Measures the column at which the `(source)` parenthesis opens in adjacent
- * `skin/classic/browser/<x>.css (...)` entries inside an existing
- * jar.inc.mn body, and returns the maximum so a newly inserted entry can
- * align its source column to match.
- *
- * A fixed four-space gap regardless of the surrounding alignment lands a
- * freshly registered file at the wrong column and produces avoidable
- * formatting churn, since adjacent Firefox entries are typically padded to a
- * wider column. Returns `undefined` when no existing entries provide an
- * alignment signal. Callers fall back to the four-space default.
- */
-export function measureSourceColumn(content) {
-    const lines = content.split('\n');
-    let maxColumn = 0;
-    let sampled = 0;
-    // The regex guarantees `(` appears in the matched line, so the index
-    // lookup below is always >= 0. The `match` body's leading-whitespace
-    // and target-path captures are likewise guaranteed by the pattern, so
-    // we can take the literal `match[0]` (full match) length minus one to
-    // locate the `(` column without a fragile per-group lookup.
-    const lineRe = /^\s*skin\/classic\/browser\/[^\s()]+\s+\(/;
-    for (const line of lines) {
-        const match = lineRe.exec(line);
-        if (!match)
-            continue;
-        const parenIndex = match[0].length - 1;
-        if (parenIndex > maxColumn)
-            maxColumn = parenIndex;
-        sampled++;
-    }
-    return sampled > 0 ? maxColumn : undefined;
-}
-/**
- * Builds a `skin/classic/browser/<name>.css   (../shared/<name>.css)`
- * line padded so the parenthesis lands at {@link sourceColumn} (when
- * supplied) or at the default four-space gap (when {@link sourceColumn}
- * is `undefined` or would force the parenthesis closer to the target
- * than {@link MIN_SOURCE_GAP}).
- */
-export function buildEntry(name, sourceColumn) {
-    const indent = '  ';
-    const target = `${indent}skin/classic/browser/${name}.css`;
-    const minColumn = target.length + MIN_SOURCE_GAP;
-    const column = sourceColumn !== undefined && sourceColumn >= minColumn ? sourceColumn : minColumn;
-    const padding = ' '.repeat(column - target.length);
-    return normalizePathSlashes(`${target}${padding}(../shared/${name}.css)`);
-}
-/**
- * Registers a CSS file in browser/themes/shared/jar.inc.mn.
- *
- * Entry format:
- *   skin/classic/browser/{name}.css    (../shared/{name}.css)
- *
- * The gap between target and source is sized to align with adjacent
- * entries when the manifest already uses a wider column. It falls back
- * to a four-space minimum otherwise.
- */
-export async function registerSharedCSS(engineDir, fileName, after, dryRun = false) {
-    const manifest = 'browser/themes/shared/jar.inc.mn';
-    const manifestPath = join(engineDir, manifest);
-    if (!(await pathExists(manifestPath))) {
-        throw new GeneralError(`Manifest not found: ${manifest}`);
-    }
-    const name = basename(fileName, '.css');
-    const content = await readText(manifestPath);
-    const sourceColumn = measureSourceColumn(content);
-    const entry = buildEntry(name, sourceColumn);
-    // Idempotency check. `furnace chrome-doc create` writes its CSS as a
-    // `content/browser/<name>.css` entry rather than the canonical
-    // `skin/classic/browser/<name>.css` form `register` produces. Recognise
-    // both shapes so a follow-up `register` invocation against an
-    // already-chrome-doc-registered file reports `skipped` instead of
-    // appending a duplicate `skin/classic/browser/...` row.
-    if (content.includes(`skin/classic/browser/${name}.css`) ||
-        content.includes(`content/browser/${name}.css`)) {
-        return { manifest, entry, skipped: true };
-    }
-    const value = registerSharedCSSTokenized(content, name, entry, after);
-    if (!dryRun) {
-        await writeText(manifestPath, value.result);
-    }
-    return {
-        manifest,
-        entry,
-        previousEntry: value.previousEntry,
-        skipped: false,
-        afterFallback: value.afterFallback,
-    };
-}

package/dist/src/core/register-xpcshell-test.d.ts

@@ -1,50 +0,0 @@
-/**
- * xpcshell test-file registration. Without it, xpcshell test files (e.g.
- * `<module-dir>/test/unit/test_*.js`) are rejected by `fireforge register`
- * as "Unknown file pattern". This writer inserts the `["test_*.js"]` section
- * into the directory's `xpcshell.toml` (alphabetically or after the
- * `--after` entry, idempotently). With
- * `--create-manifest` it also creates the manifest and wires
- * `XPCSHELL_TESTS_MANIFESTS` into the nearest moz.build.
- */
-import type { RegisterResult } from './register-result.js';
-/**
- * Checks whether the test file is listed in its directory's
- * `xpcshell.toml`. Throws a "Manifest not found" error when the manifest
- * does not exist (status catches that prefix and reports the manifest as
- * missing rather than the file as unregistered).
- */
-export declare function isXpcshellTestRegistered(engineDir: string, dirRel: string, fileName: string): Promise<boolean>;
-/** Where a new section goes and what placed it there. */
-export interface XpcshellSectionPlacement {
-    /** The manifest content with the section inserted. */
-    content: string;
-    /** The `["…"]` header of the `--after` entry the section follows. */
-    previousEntry?: string | undefined;
-    /** `--after` named no entry, so the section went in sort order. */
-    afterFallback?: boolean | undefined;
-}
-/**
- * Places the `["<fileName>"]` section in the manifest content.
- *
- * Without `after`, the section goes in mozbuild's case-insensitive sort
- * order relative to the other test sections. With `after`, it goes right
- * after the named entry's whole block (its keys included). Either way it
- * is inserted ahead of the `#` comment lines that introduce the next
- * entry, never between a comment and its entry, keeping one
- * blank line between sections.
- */
-export declare function placeXpcshellManifestSection(content: string, fileName: string, after?: string): XpcshellSectionPlacement;
-/**
- * Inserts the `["<fileName>"]` section into the manifest content; see
- * {@link placeXpcshellManifestSection}. Exported for direct unit testing.
- *
- * @internal
- */
-export declare function insertXpcshellManifestSection(content: string, fileName: string, after?: string): string;
-/**
- * Registers an xpcshell test file in its directory's `xpcshell.toml`.
- * With `createManifest`, a missing manifest is scaffolded and wired into
- * the nearest moz.build via `XPCSHELL_TESTS_MANIFESTS`.
- */
-export declare function registerXpcshellTest(engineDir: string, dirRel: string, fileName: string, dryRun?: boolean, createManifest?: boolean, after?: string): Promise<RegisterResult>;

package/dist/src/core/register-xpcshell-test.js

@@ -1,143 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * xpcshell test-file registration. Without it, xpcshell test files (e.g.
- * `<module-dir>/test/unit/test_*.js`) are rejected by `fireforge register`
- * as "Unknown file pattern". This writer inserts the `["test_*.js"]` section
- * into the directory's `xpcshell.toml` (alphabetically or after the
- * `--after` entry, idempotently). With
- * `--create-manifest` it also creates the manifest and wires
- * `XPCSHELL_TESTS_MANIFESTS` into the nearest moz.build.
- */
-import { join } from 'node:path';
-import { GeneralError } from '../errors/base.js';
-import { pathExists, readText, writeText } from '../utils/fs.js';
-import { mozbuildSortCompare } from './moz-manifest-helpers.js';
-import { ensureXpcshellManifestWiring } from './register-scaffold.js';
-function manifestMissingError(manifestRel) {
-    return new GeneralError(`Manifest not found: ${manifestRel}. ` +
-        'Pass --create-manifest to scaffold the xpcshell.toml and wire XPCSHELL_TESTS_MANIFESTS ' +
-        'into the nearest moz.build.');
-}
-/**
- * Checks whether the test file is listed in its directory's
- * `xpcshell.toml`. Throws a "Manifest not found" error when the manifest
- * does not exist (status catches that prefix and reports the manifest as
- * missing rather than the file as unregistered).
- */
-export async function isXpcshellTestRegistered(engineDir, dirRel, fileName) {
-    const manifestRel = `${dirRel}/xpcshell.toml`;
-    const manifestPath = join(engineDir, manifestRel);
-    if (!(await pathExists(manifestPath))) {
-        throw manifestMissingError(manifestRel);
-    }
-    const content = await readText(manifestPath);
-    return content.includes(`["${fileName}"]`);
-}
-const SECTION_HEADER = /^\["([^"]+)"\]\s*$/;
-/**
- * The line where the block headed at `headerIndex` starts: the header
- * itself, or the first of the `#` comment lines directly above it. A
- * comment describes the entry below it, so nothing is inserted between
- * them.
- */
-function blockStart(lines, headerIndex) {
-    let start = headerIndex;
-    while (start > 0 && (lines[start - 1] ?? '').trimStart().startsWith('#'))
-        start -= 1;
-    return start;
-}
-/** Index of the section header `after` names: exact name first, then a substring. */
-function findAfterHeader(lines, after) {
-    const headers = lines
-        .map((line, index) => ({ index, line, name: SECTION_HEADER.exec(line)?.[1] }))
-        .filter((header) => header.name !== undefined);
-    const exact = headers.find((header) => header.name === after || header.line.trim() === after);
-    return (exact ?? headers.find((header) => header.line.includes(after)))?.index ?? -1;
-}
-function spliceSection(lines, index, fileName) {
-    if (index === -1) {
-        // Append after the last section (or at end of file when there are no
-        // sections yet), keeping exactly one trailing newline.
-        while (lines.length > 0 && (lines.at(-1) ?? '').trim() === '')
-            lines.pop();
-        return [...lines, '', `["${fileName}"]`, ''].join('\n');
-    }
-    lines.splice(index, 0, `["${fileName}"]`, '');
-    return lines.join('\n');
-}
-/**
- * Places the `["<fileName>"]` section in the manifest content.
- *
- * Without `after`, the section goes in mozbuild's case-insensitive sort
- * order relative to the other test sections. With `after`, it goes right
- * after the named entry's whole block (its keys included). Either way it
- * is inserted ahead of the `#` comment lines that introduce the next
- * entry, never between a comment and its entry, keeping one
- * blank line between sections.
- */
-export function placeXpcshellManifestSection(content, fileName, after) {
-    const lines = content.split('\n');
-    const headerIndexes = lines.flatMap((line, index) => (SECTION_HEADER.test(line) ? [index] : []));
-    if (after !== undefined) {
-        const afterIndex = findAfterHeader(lines, after);
-        if (afterIndex !== -1) {
-            const next = headerIndexes.find((index) => index > afterIndex);
-            return {
-                content: spliceSection(lines, next === undefined ? -1 : blockStart(lines, next), fileName),
-                previousEntry: (lines[afterIndex] ?? '').trim(),
-            };
-        }
-    }
-    const before = headerIndexes.find((index) => mozbuildSortCompare(fileName, SECTION_HEADER.exec(lines[index] ?? '')?.[1] ?? '') < 0);
-    return {
-        content: spliceSection(lines, before === undefined ? -1 : blockStart(lines, before), fileName),
-        ...(after !== undefined ? { afterFallback: true } : {}),
-    };
-}
-/**
- * Inserts the `["<fileName>"]` section into the manifest content; see
- * {@link placeXpcshellManifestSection}. Exported for direct unit testing.
- *
- * @internal
- */
-export function insertXpcshellManifestSection(content, fileName, after) {
-    return placeXpcshellManifestSection(content, fileName, after).content;
-}
-/**
- * Registers an xpcshell test file in its directory's `xpcshell.toml`.
- * With `createManifest`, a missing manifest is scaffolded and wired into
- * the nearest moz.build via `XPCSHELL_TESTS_MANIFESTS`.
- */
-export async function registerXpcshellTest(engineDir, dirRel, fileName, dryRun = false, createManifest = false, after) {
-    const manifestRel = `${dirRel}/xpcshell.toml`;
-    const manifestPath = join(engineDir, manifestRel);
-    const entry = `["${fileName}"]`;
-    if (!(await pathExists(manifestPath))) {
-        if (!createManifest) {
-            throw manifestMissingError(manifestRel);
-        }
-        const scaffoldActions = [
-            { manifest: manifestRel, change: `created with ${entry}` },
-        ];
-        if (!dryRun) {
-            await writeText(manifestPath, `[DEFAULT]\n\n${entry}\n`);
-        }
-        scaffoldActions.push(...(await ensureXpcshellManifestWiring(engineDir, manifestRel, dryRun)));
-        return { manifest: manifestRel, entry, skipped: false, scaffoldActions };
-    }
-    const content = await readText(manifestPath);
-    if (content.includes(entry)) {
-        return { manifest: manifestRel, entry, skipped: true };
-    }
-    const placement = placeXpcshellManifestSection(content, fileName, after);
-    if (!dryRun) {
-        await writeText(manifestPath, placement.content);
-    }
-    return {
-        manifest: manifestRel,
-        entry,
-        skipped: false,
-        previousEntry: placement.previousEntry,
-        afterFallback: placement.afterFallback,
-    };
-}

package/dist/src/core/run-log-redact.d.ts

@@ -1,38 +0,0 @@
-/**
- * Conservative secret redaction for the run-log FILE tee.
- *
- * A run log is a complete copy of mach's output, and mach echoes its
- * environment in places (configure summaries, `mach env`, harness
- * diagnostics that print the command line). The terminal already showed
- * every byte to the operator who ran it. The file, by contrast, is retained
- * twenty deep and gets attached to bug reports. So the file gets a narrow
- * masking pass and the terminal does not.
- *
- * Minimal and pattern-based. See {@link redactRunLogText} for the exact
- * contract. It is a seatbelt against the common accidental leak, not a
- * guarantee that a log is free of secrets.
- */
-/**
- * Masks the obvious secret shapes in run-log text, line by line.
- *
- * Redacted:
- * - the value of an env-style assignment `KEY=value` whose KEY matches
- *   `/(TOKEN|SECRET|PASSWORD|PASSWD|API_KEY|AUTH)/i`. The value up to the
- *   next whitespace, or a whole quoted string, becomes `KEY=<redacted>`.
- *   The `--flag=value` and `-DNAME=value` spellings of the same shape are
- *   covered (`--password=x` → `--password=<redacted>`).
- * - the credential of an `Authorization:` header (`Bearer`, `Basic` and
- *   `Token` schemes keep the scheme word, and anything else masks the
- *   whole value).
- *
- * Not redacted: secrets that appear without one of those key names or
- * headers (a bare token in a URL query string, a space-separated
- * `--password foo` CLI argument, JSON `"token": "..."` fields, cookies).
- * Line structure and every other byte pass through unchanged. `\n`, `\r\n`
- * and lone `\r` all delimit lines, so carriage-return-repainted progress
- * output is masked per repaint.
- *
- * @param text - One or more complete lines
- * @returns The same text with masked values
- */
-export declare function redactRunLogText(text: string): string;

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

@@ -1,69 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Conservative secret redaction for the run-log FILE tee.
- *
- * A run log is a complete copy of mach's output, and mach echoes its
- * environment in places (configure summaries, `mach env`, harness
- * diagnostics that print the command line). The terminal already showed
- * every byte to the operator who ran it. The file, by contrast, is retained
- * twenty deep and gets attached to bug reports. So the file gets a narrow
- * masking pass and the terminal does not.
- *
- * Minimal and pattern-based. See {@link redactRunLogText} for the exact
- * contract. It is a seatbelt against the common accidental leak, not a
- * guarantee that a log is free of secrets.
- */
-/** Env-style keys whose assigned value is masked. */
-const SECRET_KEY_PATTERN = /(TOKEN|SECRET|PASSWORD|PASSWD|API_KEY|AUTH)/i;
-/**
- * `KEY=value` where KEY is an identifier and the value runs to the next
- * whitespace, or is a single/double-quoted string. The leading group keeps
- * the assignment anchored at a token boundary so `x.y=z` is not split
- * mid-token. A hyphen IS a boundary: mach and configure echo their argv, so
- * `--token=…`, `--password=…` and `-DAUTH_TOKEN=…` are exactly the forms a
- * retained log would otherwise carry verbatim (the lead keeps the dash, and
- * the key is what follows it). Empty values are left alone (nothing to hide).
- */
-const ENV_ASSIGNMENT_PATTERN = /(^|[\s"'([{,;-])([A-Za-z_][A-Za-z0-9_]*)=("(?:[^"\\]|\\.)*"|'[^']*'|[^\s"',;)\]}]+)/g;
-/** `Authorization: <scheme> <credential>` (scheme optional) in HTTP dumps. */
-const AUTHORIZATION_HEADER_PATTERN = /(authorization\s*:\s*)(?:(bearer|basic|token)\s+)?(\S+)/gi;
-/** Marker written in place of a masked value. */
-const REDACTED = '<redacted>';
-function redactLine(line) {
-    return line
-        .replace(ENV_ASSIGNMENT_PATTERN, (whole, lead, key) => SECRET_KEY_PATTERN.test(key) ? `${lead}${key}=${REDACTED}` : whole)
-        .replace(AUTHORIZATION_HEADER_PATTERN, (_whole, lead, scheme) => scheme === undefined ? `${lead}${REDACTED}` : `${lead}${scheme} ${REDACTED}`);
-}
-/**
- * Masks the obvious secret shapes in run-log text, line by line.
- *
- * Redacted:
- * - the value of an env-style assignment `KEY=value` whose KEY matches
- *   `/(TOKEN|SECRET|PASSWORD|PASSWD|API_KEY|AUTH)/i`. The value up to the
- *   next whitespace, or a whole quoted string, becomes `KEY=<redacted>`.
- *   The `--flag=value` and `-DNAME=value` spellings of the same shape are
- *   covered (`--password=x` → `--password=<redacted>`).
- * - the credential of an `Authorization:` header (`Bearer`, `Basic` and
- *   `Token` schemes keep the scheme word, and anything else masks the
- *   whole value).
- *
- * Not redacted: secrets that appear without one of those key names or
- * headers (a bare token in a URL query string, a space-separated
- * `--password foo` CLI argument, JSON `"token": "..."` fields, cookies).
- * Line structure and every other byte pass through unchanged. `\n`, `\r\n`
- * and lone `\r` all delimit lines, so carriage-return-repainted progress
- * output is masked per repaint.
- *
- * @param text - One or more complete lines
- * @returns The same text with masked values
- */
-export function redactRunLogText(text) {
-    if (text.length === 0)
-        return text;
-    // Split with a capturing group so the terminators survive the round trip.
-    // Odd indices are the terminators themselves.
-    return text
-        .split(/(\r\n|\n|\r)/)
-        .map((part, index) => (index % 2 === 0 ? redactLine(part) : part))
-        .join('');
-}

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

@@ -1,97 +0,0 @@
-/**
- * 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.
- */
-/** A run log sink. `write` never throws. */
-export interface RunLog {
-    /** Absolute path to the log file. */
-    path: string;
-    /**
-     * Appends output. Complete lines pass through {@link redactRunLogText}
-     * before hitting disk. A trailing partial line is held until its newline
-     * arrives (or until `close`). Silently drops on any stream error.
-     */
-    write: (chunk: string) => void;
-    /** Flushes and closes. Resolves even when the stream already failed. */
-    close: () => Promise<void>;
-}
-/** `.fireforge/logs` under `projectRoot`. */
-export declare function getRunLogDir(projectRoot: string): string;
-/**
- * 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 declare function openRunLog(projectRoot: string, command: string, now?: Date): Promise<RunLog | undefined>;
-/**
- * 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 declare function keepRunLogCopy(log: RunLog | undefined, flag: string | undefined, command: string): Promise<RunLog | undefined>;
-/** Installs (or clears, with `undefined`) the run log for this process. */
-export declare function setActiveRunLog(log: RunLog | undefined): void;
-/**
- * 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 declare function activeRunLogLine(): number;
-/** Absolute path of the active run log, or undefined when none is open. */
-export declare function getActiveRunLogPath(): string | undefined;
-/** Appends to the active run log. A no-op when none is open. */
-export declare function writeToActiveRunLog(chunk: string): void;
-/**
- * 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 declare function closeActiveRunLog(): Promise<void>;
-/**
- * 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 declare function teeToRunLog(base: NodeJS.WritableStream): NodeJS.WritableStream;