@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/utils/parse.js

@@ -1,214 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Lightweight runtime object parsing and field extraction helpers.
- *
- * Reduces repetitive "validate unknown → cast" boilerplate across
- * config validation, manifest parsing, and metadata validation.
- */
-import { isArray, isNumber, isObject, isString } from './validation.js';
-/**
- * A parsed record wrapper that provides typed field extraction
- * with clear error messages. Construct via {@link parseObject}.
- */
-export class ParsedRecord {
-    #data;
-    #label;
-    constructor(data, label) {
-        this.#data = data;
-        this.#label = label;
-    }
-    /**
-     * Extracts a required string field.
-     * @param key - Field name
-     * @returns The string value
-     * @throws Error if the field is missing or not a string
-     */
-    string(key) {
-        const value = this.#data[key];
-        if (!isString(value)) {
-            throw new Error(`${this.#label}.${key} must be a string`);
-        }
-        return value;
-    }
-    /**
-     * Extracts an optional string field.
-     * @param key - Field name
-     * @returns The string value or undefined
-     * @throws Error if the field is present but not a string
-     */
-    optionalString(key) {
-        const value = this.#data[key];
-        if (value === undefined)
-            return undefined;
-        if (!isString(value)) {
-            throw new Error(`${this.#label}.${key} must be a string`);
-        }
-        return value;
-    }
-    /**
-     * Extracts a required number field.
-     * @param key - Field name
-     * @returns The number value
-     * @throws Error if the field is missing or not a number
-     */
-    number(key) {
-        const value = this.#data[key];
-        if (!isNumber(value)) {
-            throw new Error(`${this.#label}.${key} must be a number`);
-        }
-        return value;
-    }
-    /**
-     * Extracts an optional number field.
-     * @param key - Field name
-     * @returns The number value or undefined
-     * @throws Error if the field is present but not a number
-     */
-    optionalNumber(key) {
-        const value = this.#data[key];
-        if (value === undefined)
-            return undefined;
-        if (!isNumber(value)) {
-            throw new Error(`${this.#label}.${key} must be a number`);
-        }
-        return value;
-    }
-    /**
-     * Extracts a required non-negative integer field.
-     * @param key - Field name
-     * @returns The integer value
-     * @throws Error if the field is missing, not a number, or negative
-     */
-    nonNegativeInteger(key) {
-        const value = this.#data[key];
-        if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {
-            throw new Error(`${this.#label}.${key} must be a non-negative integer`);
-        }
-        return value;
-    }
-    /**
-     * Extracts an optional non-negative integer field.
-     * @param key - Field name
-     * @returns The integer value or undefined
-     * @throws Error if the field is present but not a non-negative integer
-     */
-    optionalNonNegativeInteger(key) {
-        const value = this.#data[key];
-        if (value === undefined)
-            return undefined;
-        if (!isNumber(value) || !Number.isInteger(value) || value < 0) {
-            throw new Error(`${this.#label}.${key} must be a non-negative integer`);
-        }
-        return value;
-    }
-    /**
-     * Extracts a required string field and validates it against a predicate.
-     * @param key - Field name
-     * @param predicate - Validation function
-     * @param allowed - Description of allowed values for the error message
-     * @returns The validated string value
-     */
-    stringEnum(key, predicate, allowed) {
-        const value = this.string(key);
-        if (!predicate(value)) {
-            throw new Error(`${this.#label}.${key} must be ${allowed}`);
-        }
-        return value;
-    }
-    /**
-     * Extracts a required string field and validates it with a custom check.
-     * @param key - Field name
-     * @param check - Validation function returning true if valid
-     * @param constraint - Description of the constraint for the error message
-     * @returns The validated string value
-     */
-    validatedString(key, check, constraint) {
-        const value = this.string(key);
-        if (!check(value)) {
-            throw new Error(`${this.#label}.${key} must be ${constraint}`);
-        }
-        return value;
-    }
-    /**
-     * Extracts a required array-of-strings field.
-     * @param key - Field name
-     * @returns The string array
-     * @throws Error if the field is missing or not an array of strings
-     */
-    stringArray(key) {
-        const value = this.#data[key];
-        if (!isArray(value) || !value.every(isString)) {
-            throw new Error(`${this.#label}.${key} must be an array of strings`);
-        }
-        return [...value];
-    }
-    /**
-     * Extracts an optional array-of-strings field.
-     * @param key - Field name
-     * @returns The string array (fresh copy) or undefined when absent
-     * @throws Error if the field is present but not an array of strings
-     */
-    optionalStringArray(key) {
-        const value = this.#data[key];
-        if (value === undefined)
-            return undefined;
-        if (!isArray(value) || !value.every(isString)) {
-            throw new Error(`${this.#label}.${key} must be an array of strings`);
-        }
-        return [...value];
-    }
-    /**
-     * Extracts a required nested object field.
-     * @param key - Field name
-     * @returns A new ParsedRecord wrapping the nested object
-     * @throws Error if the field is missing or not an object
-     */
-    object(key) {
-        const value = this.#data[key];
-        if (!isObject(value)) {
-            throw new Error(`${this.#label}.${key} must be an object`);
-        }
-        return new ParsedRecord(value, `${this.#label}.${key}`);
-    }
-    /**
-     * Extracts an optional nested object field.
-     * @param key - Field name
-     * @returns A new ParsedRecord wrapping the nested object, or undefined
-     * @throws Error if the field is present but not an object
-     */
-    optionalObject(key) {
-        const value = this.#data[key];
-        if (value === undefined)
-            return undefined;
-        if (!isObject(value)) {
-            throw new Error(`${this.#label}.${key} must be an object`);
-        }
-        return new ParsedRecord(value, `${this.#label}.${key}`);
-    }
-    /**
-     * Returns the raw value of a field without validation.
-     * @param key - Field name
-     */
-    raw(key) {
-        return this.#data[key];
-    }
-    /**
-     * Returns all keys in the underlying record.
-     */
-    keys() {
-        return Object.keys(this.#data);
-    }
-}
-/**
- * Wraps an unknown value as a ParsedRecord after verifying it is an object.
- * @param data - The unknown value to parse
- * @param label - Label for error messages (e.g. "Config", "patches[0]")
- * @returns A ParsedRecord for typed field extraction
- * @throws Error if data is not a plain object
- */
-export function parseObject(data, label) {
-    if (!isObject(data)) {
-        throw new Error(`${label} must be an object`);
-    }
-    return new ParsedRecord(data, label);
-}

package/dist/src/utils/path-glob.d.ts

@@ -1,15 +0,0 @@
-/**
- * Minimal path globs for policy config: `*` matches within one path segment,
- * `?` one character of a segment, and `**` any number of whole segments
- * (`a/**` is everything under `a/`, `**\/x` is `x` in any directory). A
- * pattern is anchored at both ends against an engine-relative POSIX path;
- * there is no basename-anywhere matching, so `*.toml` matches only top-level
- * files and `**\/*.toml` matches them everywhere.
- *
- * Hand-rolled because the policy surface needs exactly this much and the
- * package keeps its dependency list short.
- */
-/** Compiles one glob to an anchored regular expression. */
-export declare function globToRegExp(glob: string): RegExp;
-/** True when `path` matches at least one of `globs`. */
-export declare function matchesAnyGlob(path: string, globs: readonly string[]): boolean;

package/dist/src/utils/path-glob.js

@@ -1,47 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Minimal path globs for policy config: `*` matches within one path segment,
- * `?` one character of a segment, and `**` any number of whole segments
- * (`a/**` is everything under `a/`, `**\/x` is `x` in any directory). A
- * pattern is anchored at both ends against an engine-relative POSIX path;
- * there is no basename-anywhere matching, so `*.toml` matches only top-level
- * files and `**\/*.toml` matches them everywhere.
- *
- * Hand-rolled because the policy surface needs exactly this much and the
- * package keeps its dependency list short.
- */
-import { escapeRegex } from './regex.js';
-/** Compiles one glob to an anchored regular expression. */
-export function globToRegExp(glob) {
-    let source = '';
-    for (let i = 0; i < glob.length; i++) {
-        const char = glob[i] ?? '';
-        if (char === '*' && glob[i + 1] === '*') {
-            const atSegmentStart = i === 0 || glob[i - 1] === '/';
-            const followedBySlash = glob[i + 2] === '/';
-            if (atSegmentStart && followedBySlash) {
-                // `**/` : zero or more leading directories.
-                source += '(?:[^/]+/)*';
-                i += 2;
-            }
-            else {
-                source += '.*';
-                i += 1;
-            }
-        }
-        else if (char === '*') {
-            source += '[^/]*';
-        }
-        else if (char === '?') {
-            source += '[^/]';
-        }
-        else {
-            source += escapeRegex(char);
-        }
-    }
-    return new RegExp(`^${source}$`);
-}
-/** True when `path` matches at least one of `globs`. */
-export function matchesAnyGlob(path, globs) {
-    return globs.some((glob) => globToRegExp(glob).test(path));
-}

package/dist/src/utils/paths.d.ts

@@ -1,31 +0,0 @@
-/** Converts Windows path separators to forward slashes for stable comparisons. */
-export declare function normalizePathSlashes(path: string): string;
-/**
- * Strips a leading `engine/` (or `engine\\`) segment from a user-supplied
- * path so the same command invocation accepts both repo-root-relative paths
- * (`engine/browser/base/content/foo.js`) and engine-relative paths
- * (`browser/base/content/foo.js`).
- *
- * The match is case-insensitive because default macOS and Windows
- * filesystems treat `Engine/` and `engine/` as the same directory. A
- * literal lowercase-only check leaves `mach` and the manifest writers
- * resolving against a wrongly-cased prefix. Leading whitespace is ignored so
- * tab-completed inputs do not slip past the strip.
- *
- * The return value is trimmed of that leading whitespace when the prefix
- * matched, and otherwise passed through verbatim. Callers that care about
- * internal whitespace can trim on their side.
- *
- * @param filePath Path as provided by the user
- * @returns Path relative to the engine directory (or the original when the
- *          prefix was absent)
- */
-export declare function stripEnginePrefix(filePath: string): string;
-/** Checks whether a path is explicitly absolute on either POSIX or Windows. */
-export declare function isExplicitAbsolutePath(path: string): boolean;
-/** Resolves a candidate path and returns whether it stays within the given root. */
-export declare function isPathInsideRoot(root: string, candidate: string): boolean;
-/** Checks whether a relative path stays contained within an arbitrary root. */
-export declare function isContainedRelativePath(path: string): boolean;
-/** Converts a candidate path to a normalized root-relative path, rejecting escapes. */
-export declare function toRootRelativePath(root: string, candidate: string): string;

package/dist/src/utils/paths.js

@@ -1,80 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { isAbsolute, relative, resolve, sep } from 'node:path';
-const WINDOWS_ABSOLUTE_PATH = /^[a-zA-Z]:[\\/]/;
-const RELATIVE_PATH_ROOT = resolve('/__fireforge_path_root__');
-/**
- * Matches a leading `engine/` or `engine\\` segment (case-insensitive,
- * tolerates leading whitespace). Shared between `register`, `test`, `lint`,
- * and `export` so every command that takes an engine-relative path accepts
- * both the repo-root form (`engine/browser/...`) and the engine-relative
- * form (`browser/...`) without diverging.
- */
-const ENGINE_PREFIX_PATTERN = /^\s*engine[/\\]/i;
-/** Converts Windows path separators to forward slashes for stable comparisons. */
-export function normalizePathSlashes(path) {
-    return path.replace(/\\/g, '/');
-}
-/**
- * Strips a leading `engine/` (or `engine\\`) segment from a user-supplied
- * path so the same command invocation accepts both repo-root-relative paths
- * (`engine/browser/base/content/foo.js`) and engine-relative paths
- * (`browser/base/content/foo.js`).
- *
- * The match is case-insensitive because default macOS and Windows
- * filesystems treat `Engine/` and `engine/` as the same directory. A
- * literal lowercase-only check leaves `mach` and the manifest writers
- * resolving against a wrongly-cased prefix. Leading whitespace is ignored so
- * tab-completed inputs do not slip past the strip.
- *
- * The return value is trimmed of that leading whitespace when the prefix
- * matched, and otherwise passed through verbatim. Callers that care about
- * internal whitespace can trim on their side.
- *
- * @param filePath Path as provided by the user
- * @returns Path relative to the engine directory (or the original when the
- *          prefix was absent)
- */
-export function stripEnginePrefix(filePath) {
-    const match = ENGINE_PREFIX_PATTERN.exec(filePath);
-    if (match) {
-        return filePath.slice(match[0].length);
-    }
-    return filePath;
-}
-/** Checks whether a path is explicitly absolute on either POSIX or Windows. */
-export function isExplicitAbsolutePath(path) {
-    return isAbsolute(path) || WINDOWS_ABSOLUTE_PATH.test(path);
-}
-/** Resolves a candidate path and returns whether it stays within the given root. */
-export function isPathInsideRoot(root, candidate) {
-    if (candidate.includes('\0'))
-        return false;
-    const resolvedRoot = resolve(root);
-    const resolvedCandidate = isExplicitAbsolutePath(candidate)
-        ? resolve(candidate)
-        : resolve(resolvedRoot, candidate);
-    const relativePath = relative(resolvedRoot, resolvedCandidate);
-    return (relativePath === '' ||
-        (relativePath !== '..' &&
-            !relativePath.startsWith(`..${sep}`) &&
-            !isAbsolute(relativePath) &&
-            !WINDOWS_ABSOLUTE_PATH.test(relativePath)));
-}
-/** Checks whether a relative path stays contained within an arbitrary root. */
-export function isContainedRelativePath(path) {
-    if (isExplicitAbsolutePath(path) || path.includes('\0')) {
-        return false;
-    }
-    return isPathInsideRoot(RELATIVE_PATH_ROOT, path);
-}
-/** Converts a candidate path to a normalized root-relative path, rejecting escapes. */
-export function toRootRelativePath(root, candidate) {
-    const resolvedRoot = resolve(root);
-    const resolvedCandidate = isExplicitAbsolutePath(candidate)
-        ? resolve(candidate)
-        : resolve(resolvedRoot, candidate);
-    if (!isPathInsideRoot(resolvedRoot, resolvedCandidate)) {
-        throw new Error(`Path escapes root: ${candidate}`);
-    }
-    return normalizePathSlashes(relative(resolvedRoot, resolvedCandidate));
-}

package/dist/src/utils/platform.d.ts

@@ -1,9 +0,0 @@
-/**
- * Supported operating system platforms.
- */
-export type Platform = 'darwin' | 'linux' | 'win32';
-/**
- * Gets the current operating system platform.
- * @throws Error if running on an unsupported platform
- */
-export declare function getPlatform(): Platform;

package/dist/src/utils/platform.js

@@ -1,14 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { platform } from 'node:os';
-import { GeneralError } from '../errors/base.js';
-/**
- * Gets the current operating system platform.
- * @throws Error if running on an unsupported platform
- */
-export function getPlatform() {
-    const p = platform();
-    if (p === 'darwin' || p === 'linux' || p === 'win32') {
-        return p;
-    }
-    throw new GeneralError(`Unsupported platform: ${p}. FireForge supports darwin, linux, and win32.`);
-}

package/dist/src/utils/process-group.d.ts

@@ -1,42 +0,0 @@
-/**
- * Process-group kill and post-run sweep helpers for the exec layer.
- * Spawn-based rather than `exec`-based so the two modules do not import
- * each other cyclically.
- */
-import { type ChildProcess } from 'node:child_process';
-/**
- * Sends `signal` to the child's whole tree: the process group on POSIX
- * (negative-PID kill, which reaches mach → python → firefox →
- * content-process chains), or a `taskkill /T /F` tree kill plus a direct
- * `child.kill` fallback on Windows. No-ops once the direct child has exited (group
- * survivors after exit are the post-run sweep's job, not this function's).
- *
- * A failed group kill falls through to a direct `child.kill` on POSIX too:
- * ESRCH/EPERM on the negative PID means the group is gone or was never
- * created, and signalling the direct child is strictly better than
- * returning silently.
- */
-export declare function killProcessTree(child: ChildProcess, signal: NodeJS.Signals, usesProcessGroup: boolean): void;
-/** One process still alive in a swept group. */
-interface ProcessGroupSurvivor {
-    /** PID, or -1 when pgrep was unavailable and only a liveness probe ran. */
-    pid: number;
-    /** Command line (pgrep -lf output), best-effort. */
-    command: string;
-}
-/**
- * Post-run reaper for a process group FireForge itself spawned (`pgid` is
- * the PID of a child started with `detached: true`): lists survivors,
- * SIGTERMs the group, waits a short grace, escalates to SIGKILL, and warns
- * about anything that still refuses to die. POSIX only (no-op on win32).
- * The only kill target is `-pgid`, never anything outside the group.
- * A healthy run costs exactly one `pgrep`.
- *
- * `context` names why the group is being reaped in the warning; the default
- * is the post-close sweep. The parent-exit watchdog passes its own, because
- * there the group is still running when the sweep begins.
- */
-export declare function sweepProcessGroup(pgid: number, graceMs?: number, context?: string): Promise<{
-    survivors: ProcessGroupSurvivor[];
-}>;
-export {};

package/dist/src/utils/process-group.js

@@ -1,190 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Process-group kill and post-run sweep helpers for the exec layer.
- * Spawn-based rather than `exec`-based so the two modules do not import
- * each other cyclically.
- */
-import { spawn } from 'node:child_process';
-import { getNodeErrorCode } from './errors.js';
-import { verbose, warn } from './logger.js';
-import { sleep } from './sleep.js';
-/**
- * Sends `signal` to the child's whole tree: the process group on POSIX
- * (negative-PID kill, which reaches mach → python → firefox →
- * content-process chains), or a `taskkill /T /F` tree kill plus a direct
- * `child.kill` fallback on Windows. No-ops once the direct child has exited (group
- * survivors after exit are the post-run sweep's job, not this function's).
- *
- * A failed group kill falls through to a direct `child.kill` on POSIX too:
- * ESRCH/EPERM on the negative PID means the group is gone or was never
- * created, and signalling the direct child is strictly better than
- * returning silently.
- */
-export function killProcessTree(child, signal, usesProcessGroup) {
-    if (child.exitCode !== null || child.signalCode !== null)
-        return;
-    const targetPid = child.pid;
-    if (targetPid === undefined)
-        return;
-    try {
-        if (usesProcessGroup) {
-            // Negative PID routes to the process group, killing the Python
-            // wrapper, the firefox it forked, and every content process
-            // that inherited the group.
-            try {
-                process.kill(-targetPid, signal);
-            }
-            catch {
-                // ESRCH/EPERM: the group is gone, or was never created because the
-                // platform ignored `detached`. Signal the direct child rather than
-                // doing nothing, since it may well still be alive. Without this
-                // fall-through a failed group kill left the child running.
-                child.kill(signal);
-            }
-        }
-        else {
-            // No process group on Windows, so taskkill /T walks the descendant
-            // tree instead. Always forced (/F): there is no SIGTERM analogue,
-            // so the grace window only exists on POSIX.
-            spawn('taskkill', ['/pid', String(targetPid), '/T', '/F'], {
-                stdio: 'ignore',
-            }).on('error', () => {
-                // taskkill unavailable, so nothing more we can do beyond the
-                // direct-child kill below.
-            });
-            child.kill(signal);
-        }
-    }
-    catch {
-        // Already gone. Nothing to do.
-    }
-}
-const SWEEP_GRACE_MS = 2000;
-const MULTIPROCESSING_WORKER_PATTERN = /multiprocessing\.(?:spawn|forkserver)|resource_tracker/;
-/**
- * Minimal spawn-based pgrep runner. exitCode -1 means pgrep itself was
- * unavailable or errored (distinct from exit 1 = "no matches").
- */
-async function runPgrep(args) {
-    return new Promise((resolve) => {
-        const child = spawn('pgrep', args, { stdio: ['ignore', 'pipe', 'ignore'] });
-        let stdout = '';
-        child.stdout.on('data', (data) => {
-            stdout += data.toString('utf8');
-        });
-        child.on('error', () => {
-            resolve({ exitCode: -1, stdout: '' });
-        });
-        child.on('close', (code) => {
-            resolve({ exitCode: code ?? -1, stdout });
-        });
-    });
-}
-/** Lists processes still in `pgid` via `pgrep -g -lf`, with a kill(0) fallback. */
-async function listGroupSurvivors(pgid) {
-    const result = await runPgrep(['-g', String(pgid), '-lf']);
-    if (result.exitCode === 0) {
-        return result.stdout
-            .split('\n')
-            .map((line) => line.trim())
-            .filter((line) => line.length > 0)
-            .map((line) => {
-            const match = /^(\d+)\s+(.*)$/.exec(line);
-            return match
-                ? { pid: Number(match[1]), command: match[2] ?? '' }
-                : { pid: -1, command: line };
-        });
-    }
-    if (result.exitCode === 1)
-        return []; // no matches
-    // pgrep unavailable/broken: fall back to a group liveness probe.
-    try {
-        process.kill(-pgid, 0);
-        return [{ pid: -1, command: 'unknown (pgrep unavailable; group still has live members)' }];
-    }
-    catch (error) {
-        // Same errno semantics as `isProcessAlive` (which cannot be called here,
-        // since it probes a single positive pid): only ESRCH proves the group is
-        // gone. EPERM means it exists under another uid, and an unrecognized
-        // failure is not evidence of absence, so report survivors in both cases.
-        if (getNodeErrorCode(error) === 'ESRCH')
-            return [];
-        return [{ pid: -1, command: 'unknown (pgrep unavailable; group liveness probe denied)' }];
-    }
-}
-function describeSurvivors(list) {
-    return list
-        .map((s) => {
-        const tag = MULTIPROCESSING_WORKER_PATTERN.test(s.command)
-            ? ' [multiprocessing worker — the known busy-spin orphan shape]'
-            : '';
-        return `PID ${s.pid}: ${s.command}${tag}`;
-    })
-        .join('; ');
-}
-/**
- * Post-run reaper for a process group FireForge itself spawned (`pgid` is
- * the PID of a child started with `detached: true`): lists survivors,
- * SIGTERMs the group, waits a short grace, escalates to SIGKILL, and warns
- * about anything that still refuses to die. POSIX only (no-op on win32).
- * The only kill target is `-pgid`, never anything outside the group.
- * A healthy run costs exactly one `pgrep`.
- *
- * `context` names why the group is being reaped in the warning; the default
- * is the post-close sweep. The parent-exit watchdog passes its own, because
- * there the group is still running when the sweep begins.
- */
-export async function sweepProcessGroup(pgid, graceMs = SWEEP_GRACE_MS, context = 'after exit') {
-    if (process.platform === 'win32')
-        return { survivors: [] };
-    const survivors = await listGroupSurvivors(pgid);
-    if (survivors.length === 0)
-        return { survivors };
-    warn(`Harness process group ${pgid} has ${survivors.length} live ` +
-        `process(es) ${context} — reaping the group. ${describeSurvivors(survivors)}`);
-    try {
-        process.kill(-pgid, 'SIGTERM');
-    }
-    catch {
-        // The group vanished between the listing and the signal, so there is
-        // nothing left to escalate against. Report the survivors collected so far.
-        return { survivors };
-    }
-    // Ref'd (sleep's default): this wait sits between the group
-    // SIGTERM and the post-grace re-list/SIGKILL escalation, awaited from a
-    // child 'close' handler after the signal forwarder is disposed. With an
-    // unref'd timer nothing keeps the event loop alive, so Node could exit
-    // mid-grace and skip the escalation entirely. Healthy runs never reach
-    // here (sweepProcessGroup early-returns on zero survivors).
-    await sleep(graceMs);
-    let remaining = await listGroupSurvivors(pgid);
-    if (remaining.length > 0) {
-        try {
-            process.kill(-pgid, 'SIGKILL');
-        }
-        catch {
-            // The group died during the grace period, so the SIGKILL escalation has
-            // nothing to signal.
-            return { survivors };
-        }
-        // Ref'd (sleep's default): this wait sits between the group
-        // SIGTERM and the post-grace re-list/SIGKILL escalation, awaited from a
-        // child 'close' handler after the signal forwarder is disposed. With an
-        // unref'd timer nothing keeps the event loop alive, so Node could exit
-        // mid-grace and skip the escalation entirely. Healthy runs never reach
-        // here (sweepProcessGroup early-returns on zero survivors).
-        await sleep(Math.min(200, graceMs));
-        remaining = await listGroupSurvivors(pgid);
-        if (remaining.length > 0) {
-            warn(`Process group ${pgid} still has survivors after SIGKILL: ${describeSurvivors(remaining)}. ` +
-                'Inspect manually (ps -axo pid,ppid,time,command) and kill by PID.');
-        }
-        else {
-            verbose(`Process group ${pgid} reaped after SIGKILL escalation.`);
-        }
-    }
-    else {
-        verbose(`Process group ${pgid} reaped cleanly with SIGTERM.`);
-    }
-    return { survivors };
-}

package/dist/src/utils/process-input.d.ts

@@ -1,27 +0,0 @@
-/** Options for {@link execWithInput}. */
-export interface ExecWithInputOptions {
-    /** Working directory for the command */
-    cwd?: string;
-    /** Environment variables merged over `process.env` */
-    env?: Record<string, string>;
-}
-/** Result of {@link execWithInput}: stdout stays raw bytes. */
-export interface ExecBufferResult {
-    /** Standard output, uncapped and undecoded */
-    stdout: Buffer;
-    /** Standard error, decoded as UTF-8 */
-    stderr: string;
-    /** Process exit code */
-    exitCode: number;
-}
-/**
- * Runs a command, writes `input` to its stdin, and returns stdout as raw
- * bytes. For batch protocols (`git cat-file --batch`) whose framing counts
- * bytes: the decoded, 50 MB-capped collector `exec` uses would corrupt
- * both. The caller bounds the input, and so the output.
- * @param command - Command to execute
- * @param args - Command arguments
- * @param input - Bytes written to stdin, which is then closed
- * @param options - Execution options
- */
-export declare function execWithInput(command: string, args: string[], input: string | Buffer, options?: ExecWithInputOptions): Promise<ExecBufferResult>;