@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/patch-retired.js

@@ -1,92 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Retired order slots: the placeholders `patch retire` leaves in
- * `patches.json#retired` so a patch can leave the queue without opening a
- * numeric gap or renumbering its successors.
- *
- * A slot is not a patch. It has no `.patch` file and no row in `patches`,
- * so everything that applies, exports, lints or rebases the queue walks past
- * it without knowing it exists. The one reader is the
- * `patchPolicy.allowGaps: false` gap check, which counts a retired order as
- * occupied. A patch that later takes the same order fills the slot, and
- * {@link carryRetiredSlots} drops it on that write, so the manifest never
- * holds a slot and a patch at one order.
- *
- * Reserved slots (`patch reserve`) follow the same rules: a placeholder for
- * an order a session has claimed but not exported yet, counted as occupied
- * by the gap check and filled (and dropped) by the export that lands on it.
- */
-/**
- * The retired slots of `current` that no patch in `patches` occupies, or
- * undefined when none remain. Every manifest write that rebuilds the
- * `patches` list routes the slots through here, so a slot survives the
- * rewrite and a filled one does not.
- *
- * @param current - Manifest the slots come from (null or slot-free: none)
- * @param patches - The rows the written manifest will hold
- */
-export function carryRetiredSlots(current, patches) {
-    const slots = current?.retired;
-    if (slots === undefined || slots.length === 0)
-        return undefined;
-    const occupied = new Set(patches.map((patch) => patch.order));
-    const kept = slots
-        .filter((slot) => !occupied.has(slot.order))
-        .map((slot) => ({ ...slot }))
-        .sort((a, b) => a.order - b.order);
-    return kept.length > 0 ? kept : undefined;
-}
-/**
- * Reserved twin of {@link carryRetiredSlots}: the reservations of `current`
- * that no patch in `patches` has filled yet.
- *
- * @param current - Manifest the slots come from
- * @param patches - The rows the written manifest will hold
- */
-export function carryReservedSlots(current, patches) {
-    const slots = current?.reserved;
-    if (slots === undefined || slots.length === 0)
-        return undefined;
-    const occupied = new Set(patches.map((patch) => patch.order));
-    const kept = slots
-        .filter((slot) => !occupied.has(slot.order))
-        .map((slot) => ({ ...slot }))
-        .sort((a, b) => a.order - b.order);
-    return kept.length > 0 ? kept : undefined;
-}
-/**
- * Builds a manifest from `patches` that keeps `current`'s unfilled retired
- * and reserved slots. Each key is omitted entirely when no slot remains, so
- * a queue that never retired or reserved anything writes the same JSON as
- * before.
- *
- * @param current - Manifest the slots come from
- * @param patches - The rows the written manifest will hold
- */
-export function manifestWithRetiredSlots(current, patches) {
-    const retired = carryRetiredSlots(current, patches);
-    const reserved = carryReservedSlots(current, patches);
-    return {
-        version: 1,
-        patches,
-        ...(retired !== undefined ? { retired } : {}),
-        ...(reserved !== undefined ? { reserved } : {}),
-    };
-}
-/** The set of order numbers held by retired slots. */
-export function retiredOrderSet(manifest) {
-    return new Set((manifest.retired ?? []).map((slot) => slot.order));
-}
-/** The set of order numbers held by reserved slots. */
-export function reservedOrderSet(manifest) {
-    return new Set((manifest.reserved ?? []).map((slot) => slot.order));
-}
-/**
- * The reservation at `order`, if any.
- *
- * @param manifest - Manifest to search (null: none)
- * @param order - Order number
- */
-export function reservationAt(manifest, order) {
-    return manifest?.reserved?.find((slot) => slot.order === order);
-}

package/dist/src/core/patch-source-metadata.d.ts

@@ -1,6 +0,0 @@
-import type { PatchMetadata } from '../types/commands/index.js';
-import type { FirefoxConfig } from '../types/config.js';
-/** Metadata fields stamped on new or refreshed patch entries. */
-export declare function buildPatchSourceMetadata(firefox: Pick<FirefoxConfig, 'product' | 'version'>): Pick<PatchMetadata, 'sourceEsrVersion' | 'sourceProduct' | 'sourceVersion'>;
-/** Source version reader that also accepts rows carrying only `sourceEsrVersion`. */
-export declare function getPatchSourceVersion(patch: Pick<PatchMetadata, 'sourceEsrVersion' | 'sourceVersion'>): string;

package/dist/src/core/patch-source-metadata.js

@@ -1,12 +0,0 @@
-/** Metadata fields stamped on new or refreshed patch entries. */
-export function buildPatchSourceMetadata(firefox) {
-    return {
-        sourceEsrVersion: firefox.version,
-        sourceProduct: firefox.product,
-        sourceVersion: firefox.version,
-    };
-}
-/** Source version reader that also accepts rows carrying only `sourceEsrVersion`. */
-export function getPatchSourceVersion(patch) {
-    return patch.sourceVersion ?? patch.sourceEsrVersion;
-}

package/dist/src/core/patch-subset.d.ts

@@ -1,18 +0,0 @@
-import type { PatchesManifest, PatchMetadata } from '../types/commands/index.js';
-/**
- * Resolves a `--patches <name…>` subset against the manifest, matching each
- * requested name tolerantly (exact filename, filename ± `.patch`, the bare
- * order number, the manifest `name` field, or the slug). Accepts repeated
- * values and lists separated by commas or whitespace, so a list passed as
- * one shell word (`--patches "$P"` under zsh) still splits. Throws when a
- * requested name matches none, so a typo fails loud rather than silently
- * judging nothing; the refusal names that name and its nearest matches,
- * not the whole queue.
- *
- * @param manifest - The loaded patch manifest
- * @param requested - Raw `--patches` values (each may be a comma or whitespace list)
- * @param refusalHint - Sentence inserted into the no-match refusal, naming
- *   what the caller's flag selects
- * @returns The matching manifest rows, de-duplicated, in request order
- */
-export declare function selectPatchSubset(manifest: PatchesManifest, requested: readonly string[], refusalHint?: string): PatchMetadata[];

package/dist/src/core/patch-subset.js

@@ -1,67 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The `--patches <name…>` subset resolver shared by `lint --per-patch`,
- * `status` and `verify`. One matcher, so a name that selects a patch in
- * one gate selects the same patch in the others.
- */
-import { GeneralError } from '../errors/base.js';
-import { formatPatchSuggestions } from './patch-identifier-suggest.js';
-/** Every spelling an operator may use for one patch. */
-function patchAliases(p) {
-    const aliases = new Set([p.filename, p.filename.replace(/\.patch$/, ''), p.name]);
-    // The bare order number, both as the manifest records it and as the
-    // filename spells it (`2` and `002`). The refusal message offers stems,
-    // and an operator reading `102-ui-canvas-tiles.patch` in a lint finding
-    // reaches for `102` first.
-    aliases.add(String(p.order));
-    const match = /^(\d+)-([a-z]+)-(.+)\.patch$/.exec(p.filename);
-    if (match?.[1])
-        aliases.add(match[1]);
-    if (match?.[2] && match[3]) {
-        aliases.add(`${match[2]}-${match[3]}`);
-        aliases.add(match[3]);
-    }
-    return aliases;
-}
-function matchesPatch(p, name) {
-    const aliases = patchAliases(p);
-    const stem = name.replace(/\.patch$/, '');
-    return aliases.has(name) || aliases.has(stem) || aliases.has(`${stem}.patch`);
-}
-/**
- * Resolves a `--patches <name…>` subset against the manifest, matching each
- * requested name tolerantly (exact filename, filename ± `.patch`, the bare
- * order number, the manifest `name` field, or the slug). Accepts repeated
- * values and lists separated by commas or whitespace, so a list passed as
- * one shell word (`--patches "$P"` under zsh) still splits. Throws when a
- * requested name matches none, so a typo fails loud rather than silently
- * judging nothing; the refusal names that name and its nearest matches,
- * not the whole queue.
- *
- * @param manifest - The loaded patch manifest
- * @param requested - Raw `--patches` values (each may be a comma or whitespace list)
- * @param refusalHint - Sentence inserted into the no-match refusal, naming
- *   what the caller's flag selects
- * @returns The matching manifest rows, de-duplicated, in request order
- */
-export function selectPatchSubset(manifest, requested, refusalHint = '') {
-    const normalizedRequests = requested
-        .flatMap((entry) => entry.split(/[\s,]+/))
-        .filter((entry) => entry.length > 0);
-    const selected = [];
-    const seen = new Set();
-    for (const name of normalizedRequests) {
-        const found = manifest.patches.filter((p) => matchesPatch(p, name));
-        if (found.length === 0) {
-            throw new GeneralError(`No patch in the queue matches "${name}".${refusalHint ? ` ${refusalHint}` : ''} ` +
-                formatPatchSuggestions(name, manifest.patches));
-        }
-        for (const p of found) {
-            if (!seen.has(p.filename)) {
-                seen.add(p.filename);
-                selected.push(p);
-            }
-        }
-    }
-    return selected;
-}

package/dist/src/core/patch-transform.d.ts

@@ -1,61 +0,0 @@
-/**
- * Pure content transformation functions for patch operations.
- * These operate on file content strings without filesystem side effects.
- */
-/**
- * Extracts the complete file content from a "new file" patch given a raw
- * diff string already in memory. A caller with only a patch file path
- * reads it first; every caller holds the diff already.
- *
- * @param diff - Raw unified-diff content
- * @param targetFile - Optional target file to scope extraction to
- * @returns The file content that the patch would create
- * @throws PatchError for binary sections. A `GIT binary patch` payload is
- *   base85 (whose alphabet includes `+`), so "extract the + lines" would
- *   silently write garbage text over a binary target. Callers must treat
- *   binary new-file conflicts as unresolvable rather than auto-resolving.
- */
-export declare function extractNewFileContentFromDiff(diff: string, targetFile?: string): string;
-/**
- * {@link extractNewFileContentFromDiff} for many targets over one parse of
- * the diff. Each target gets exactly what the single-target call returns;
- * a target whose sections include a binary one (which that call refuses)
- * is left out of the map and named in `refused`.
- * @param diff - Raw unified-diff content
- * @param targetFiles - Files whose created content to extract
- */
-export declare function extractNewFileContentsFromDiff(diff: string, targetFiles: Iterable<string>): {
-    contents: Map<string, string>;
-    refused: string[];
-};
-/**
- * Projects every text new file a diff creates into a path → content map, for
- * the cross-patch lint projections that build a synthetic patch-queue entry.
- *
- * Binary new files are skipped rather than refused. The map feeds only the
- * forward-import rule, which scans content for import statements, and a
- * binary blob authors none, so omitting it contributes exactly what
- * including it would. Refusing instead (which is what
- * {@link extractNewFileContentFromDiff} correctly does for a caller that
- * named one file) made vendoring a new binary impossible: every projection
- * site fed it every detected new file, so `export --order`, `re-export
- * --scan --scan-file`, `patch move-files-into` and `patch split` all died on
- * a file the export half had just written a valid `GIT binary patch` for.
- * Nothing is lost by skipping: binary bodies are covered independently by the
- * `binary-body-not-reconstructable` queue lint, and
- * `buildPatchQueueContext` already tolerates them for real queue entries.
- *
- * One parse for the whole diff, rather than one per new file, shared by
- * every call site.
- */
-export declare function buildNewFileTextProjection(diff: string): Map<string, string>;
-/**
- * Applies an already-read patch body to content. Batched callers that hold
- * many (patch, file) pairs use this to read each patch body once instead of
- * once per pair.
- * @param content - Original content (null for new files)
- * @param patchContent - Full text of the patch body
- * @param targetFile - The file path within the patch
- * @returns Modified content
- */
-export declare function applyPatchTextToContent(content: string | null, patchContent: string, targetFile: string): string;

package/dist/src/core/patch-transform.js

@@ -1,198 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Pure content transformation functions for patch operations.
- * These operate on file content strings without filesystem side effects.
- */
-import { PatchError } from '../errors/patch.js';
-import { isNewFileInPatch, parseDiffSections, parseHunksForFile } from './patch-parse.js';
-/**
- * Extracts the complete file content from a "new file" patch given a raw
- * diff string already in memory. A caller with only a patch file path
- * reads it first; every caller holds the diff already.
- *
- * @param diff - Raw unified-diff content
- * @param targetFile - Optional target file to scope extraction to
- * @returns The file content that the patch would create
- * @throws PatchError for binary sections. A `GIT binary patch` payload is
- *   base85 (whose alphabet includes `+`), so "extract the + lines" would
- *   silently write garbage text over a binary target. Callers must treat
- *   binary new-file conflicts as unresolvable rather than auto-resolving.
- */
-export function extractNewFileContentFromDiff(diff, targetFile) {
-    const sections = parseDiffSections(diff).filter((section) => !targetFile || section.targetPath === targetFile);
-    const binary = sections.find((section) => section.isBinary);
-    if (binary) {
-        throw new PatchError(`Cannot extract text content from binary patch section for ${binary.targetPath}`, binary.targetPath);
-    }
-    return contentFromSections(sections);
-}
-/**
- * {@link extractNewFileContentFromDiff} for many targets over one parse of
- * the diff. Each target gets exactly what the single-target call returns;
- * a target whose sections include a binary one (which that call refuses)
- * is left out of the map and named in `refused`.
- * @param diff - Raw unified-diff content
- * @param targetFiles - Files whose created content to extract
- */
-export function extractNewFileContentsFromDiff(diff, targetFiles) {
-    const sectionsByTarget = new Map();
-    for (const section of parseDiffSections(diff)) {
-        const list = sectionsByTarget.get(section.targetPath) ?? [];
-        list.push(section);
-        sectionsByTarget.set(section.targetPath, list);
-    }
-    const contents = new Map();
-    const refused = [];
-    for (const target of targetFiles) {
-        const sections = sectionsByTarget.get(target) ?? [];
-        if (sections.some((section) => section.isBinary)) {
-            refused.push(target);
-            continue;
-        }
-        contents.set(target, contentFromSections(sections));
-    }
-    return { contents, refused };
-}
-/**
- * Walks the added (`+`) lines of already-parsed sections into file content.
- * Shared by {@link extractNewFileContentFromDiff} and
- * {@link buildNewFileTextProjection} so the two cannot drift on the empty-file
- * and no-trailing-newline cases below.
- */
-function contentFromSections(sections) {
-    // An empty new file is a legitimate git diff: `new file mode` with no
-    // hunks at all. It must extract as '': the historical line-walker
-    // returned '\n' for it, creating a one-byte file that failed checksum
-    // and drift comparisons against the truly empty file the patch creates.
-    const hunks = sections.flatMap((section) => section.hunks);
-    if (hunks.length === 0) {
-        return '';
-    }
-    const contentLines = [];
-    for (const hunk of hunks) {
-        for (const line of hunk.lines) {
-            // Lines starting with + are added content (skip the + prefix).
-            // `-`/context lines shouldn't exist in new-file patches.
-            if (line.startsWith('+')) {
-                contentLines.push(line.slice(1));
-            }
-        }
-    }
-    const lastHunk = hunks[hunks.length - 1];
-    const hasNoNewlineMarker = lastHunk?.noNewlineAtEndNew ?? false;
-    // Join lines and handle trailing newline
-    const result = contentLines.join('\n');
-    return hasNoNewlineMarker ? result : result + '\n';
-}
-/**
- * Projects every text new file a diff creates into a path → content map, for
- * the cross-patch lint projections that build a synthetic patch-queue entry.
- *
- * Binary new files are skipped rather than refused. The map feeds only the
- * forward-import rule, which scans content for import statements, and a
- * binary blob authors none, so omitting it contributes exactly what
- * including it would. Refusing instead (which is what
- * {@link extractNewFileContentFromDiff} correctly does for a caller that
- * named one file) made vendoring a new binary impossible: every projection
- * site fed it every detected new file, so `export --order`, `re-export
- * --scan --scan-file`, `patch move-files-into` and `patch split` all died on
- * a file the export half had just written a valid `GIT binary patch` for.
- * Nothing is lost by skipping: binary bodies are covered independently by the
- * `binary-body-not-reconstructable` queue lint, and
- * `buildPatchQueueContext` already tolerates them for real queue entries.
- *
- * One parse for the whole diff, rather than one per new file, shared by
- * every call site.
- */
-export function buildNewFileTextProjection(diff) {
-    const newFiles = new Map();
-    for (const section of parseDiffSections(diff)) {
-        if (!section.isNewFile || section.isBinary)
-            continue;
-        newFiles.set(section.targetPath, contentFromSections([section]));
-    }
-    return newFiles;
-}
-/**
- * Applies an already-read patch body to content. Batched callers that hold
- * many (patch, file) pairs use this to read each patch body once instead of
- * once per pair.
- * @param content - Original content (null for new files)
- * @param patchContent - Full text of the patch body
- * @param targetFile - The file path within the patch
- * @returns Modified content
- */
-export function applyPatchTextToContent(content, patchContent, targetFile) {
-    // Check if this is a new file patch for the target file specifically
-    if (content === null) {
-        if (isNewFileInPatch(patchContent, targetFile)) {
-            return extractNewFileContentFromDiff(patchContent, targetFile);
-        }
-        // If not a new file patch but content is null, return empty
-        return '';
-    }
-    const hunks = parseHunksForFile(patchContent, targetFile);
-    if (hunks.length === 0) {
-        return content;
-    }
-    // Apply hunks
-    const contentLines = content.split('\n');
-    // Remove trailing empty line if content ends with newline (but not for empty files)
-    if (contentLines.length > 1 && contentLines[contentLines.length - 1] === '') {
-        contentLines.pop();
-    }
-    // Process hunks in reverse order to preserve line numbers
-    const sortedHunks = [...hunks].sort((a, b) => b.oldStart - a.oldStart);
-    // The "no newline at end" marker applies to the last hunk in file order
-    // (highest oldStart), which is the *first* hunk in our reverse-sorted array.
-    // We read the new-side flag because the output we produce corresponds to
-    // the new side. Asymmetric diffs (old lacks newline, new has one, or
-    // vice versa) would otherwise disagree with `git apply`.
-    const lastHunkNoNewline = sortedHunks[0]?.noNewlineAtEndNew ?? false;
-    for (const hunk of sortedHunks) {
-        const newLines = [];
-        // Compute actual old-line count from hunk body for cross-check
-        let actualOldCount = 0;
-        for (const line of hunk.lines) {
-            if (line.startsWith('+')) {
-                newLines.push(line.slice(1));
-            }
-            else if (line.startsWith(' ')) {
-                newLines.push(line.slice(1));
-                actualOldCount++;
-            }
-            else if (line.startsWith('-')) {
-                actualOldCount++;
-            }
-            // Lines starting with '-' are removed (not added to newLines)
-        }
-        if (actualOldCount !== hunk.oldCount) {
-            throw new PatchError(`Patch hunk header mismatch for ${targetFile}: header says ${hunk.oldCount} old lines but body has ${actualOldCount}`, targetFile);
-        }
-        // Replace the old lines with new lines. Unified-diff convention: for a
-        // pure-insertion hunk (`@@ -N,0 +M,k @@`), N names the line before the
-        // insertion point, so content is spliced at index N (after line N).
-        // `N - 1` inserted one line too early, and `@@ -0,0` (insert at top of
-        // file) produced splice(-1, …), which inserts before the last element.
-        const startIndex = hunk.oldCount === 0 ? hunk.oldStart : hunk.oldStart - 1;
-        // Verify context lines match before applying
-        let verifyIndex = startIndex;
-        for (const hunkLine of hunk.lines) {
-            if (hunkLine.startsWith(' ') || hunkLine.startsWith('-')) {
-                const expectedContent = hunkLine.slice(1);
-                const actualContent = contentLines[verifyIndex];
-                if (actualContent !== expectedContent) {
-                    throw new PatchError(`Patch context mismatch at line ${verifyIndex + 1} for ${targetFile}: ` +
-                        `expected "${expectedContent}", got "${actualContent}"`, targetFile);
-                }
-                verifyIndex++;
-            }
-        }
-        contentLines.splice(startIndex, hunk.oldCount, ...newLines);
-    }
-    // Respect the no-newline-at-end-of-file marker from the last hunk
-    if (lastHunkNoNewline) {
-        return contentLines.join('\n');
-    }
-    return contentLines.join('\n') + '\n';
-}

package/dist/src/core/preflight-wait.d.ts

@@ -1,22 +0,0 @@
-/** Waits for a busy browser or port without changing or terminating its owner. */
-export declare function waitForPreflight(action: () => Promise<void>, seconds?: number): Promise<void>;
-/**
- * Spends a `--wait-browser`/`--wait-port` budget BEFORE the engine session
- * lock is taken, so a run queued behind a busy browser or port does not
- * hold the lock (and every peer's build, test and re-export behind it)
- * while it does nothing. The caller re-checks once under the lock.
- *
- * Never refuses on its own: when the budget runs out the run still joins
- * the lock queue, and the single check under the lock decides. A peer's
- * test run that holds the lock legitimately keeps its browser alive until
- * it releases, and refusing here would turn that ordinary queue into a
- * refusal the old in-lock wait never produced. Never terminates anything
- * either: nothing is owned before the lock is won. A refusal whose note is
- * in `clearNotes` (a stale browser the run is allowed to reap under the
- * lock) counts as clear.
- *
- * @param action - The preflight probe, which throws `PreflightRefusalError` while busy
- * @param seconds - The wait budget
- * @param clearNotes - Refusal classes that do not need waiting out
- */
-export declare function waitBeforeLock(action: () => Promise<void>, seconds: number | undefined, clearNotes?: readonly string[]): Promise<void>;

package/dist/src/core/preflight-wait.js

@@ -1,62 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { PreflightRefusalError } from '../errors/base.js';
-import { info } from '../utils/logger.js';
-import { sleep } from '../utils/sleep.js';
-/** Waits for a busy browser or port without changing or terminating its owner. */
-export async function waitForPreflight(action, seconds) {
-    const deadline = Date.now() + (seconds ?? 0) * 1000;
-    let announced = false;
-    for (;;) {
-        try {
-            await action();
-            return;
-        }
-        catch (error) {
-            if (!(error instanceof PreflightRefusalError) || Date.now() >= deadline)
-                throw error;
-            if (!announced) {
-                info(`Waiting up to ${seconds} seconds: ${error.message}`);
-                announced = true;
-            }
-            await sleep(Math.min(500, Math.max(1, deadline - Date.now())));
-        }
-    }
-}
-/**
- * Spends a `--wait-browser`/`--wait-port` budget BEFORE the engine session
- * lock is taken, so a run queued behind a busy browser or port does not
- * hold the lock (and every peer's build, test and re-export behind it)
- * while it does nothing. The caller re-checks once under the lock.
- *
- * Never refuses on its own: when the budget runs out the run still joins
- * the lock queue, and the single check under the lock decides. A peer's
- * test run that holds the lock legitimately keeps its browser alive until
- * it releases, and refusing here would turn that ordinary queue into a
- * refusal the old in-lock wait never produced. Never terminates anything
- * either: nothing is owned before the lock is won. A refusal whose note is
- * in `clearNotes` (a stale browser the run is allowed to reap under the
- * lock) counts as clear.
- *
- * @param action - The preflight probe, which throws `PreflightRefusalError` while busy
- * @param seconds - The wait budget
- * @param clearNotes - Refusal classes that do not need waiting out
- */
-export async function waitBeforeLock(action, seconds, clearNotes = []) {
-    try {
-        await waitForPreflight(async () => {
-            try {
-                await action();
-            }
-            catch (error) {
-                if (error instanceof PreflightRefusalError && clearNotes.includes(error.note))
-                    return;
-                throw error;
-            }
-        }, seconds);
-    }
-    catch (error) {
-        if (!(error instanceof PreflightRefusalError))
-            throw error;
-        info(`Still busy after the ${seconds ?? 0}-second wait; joining the lock queue and re-checking once under the lock.`);
-    }
-}

package/dist/src/core/process-cpu-time.d.ts

@@ -1,12 +0,0 @@
-/**
- * Reads a process's accumulated CPU seconds.
- *
- * Best-effort: a missing `ps`, an exited process, or an unparseable field
- * yields `undefined`, which callers must render as "unknown" rather than as
- * zero. Reporting a live build as having used no CPU would invert the very
- * diagnosis this exists for.
- *
- * @param pid - Process to inspect
- * @returns Accumulated CPU seconds, or `undefined` when unmeasurable
- */
-export declare function readProcessCpuSeconds(pid: number): Promise<number | undefined>;

package/dist/src/core/process-cpu-time.js

@@ -1,52 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Accumulated-CPU-time probe for a single PID.
- *
- * Exists to answer the one question `kill(pid, 0)` cannot: a lock holder
- * that exists may still be wedged. A downstream fork running five concurrent
- * sessions on one checkout diagnosed exactly this by hand ("a holder at
- * near-zero CPU is hung, not working") after a queue stalled behind a
- * command that had consumed 0.3 s of CPU in eleven minutes.
- *
- * It is reported as evidence, never as a verdict. A legitimately slow holder
- * can also sit at low CPU while blocked on I/O or on a child process, so
- * nothing keys a refusal, a kill, or a lock steal off this number.
- */
-import { exec } from '../utils/process.js';
-import { parsePsDuration } from '../utils/ps-duration.js';
-/**
- * Reads a process's accumulated CPU seconds.
- *
- * Best-effort: a missing `ps`, an exited process, or an unparseable field
- * yields `undefined`, which callers must render as "unknown" rather than as
- * zero. Reporting a live build as having used no CPU would invert the very
- * diagnosis this exists for.
- *
- * @param pid - Process to inspect
- * @returns Accumulated CPU seconds, or `undefined` when unmeasurable
- */
-export async function readProcessCpuSeconds(pid) {
-    if (!Number.isSafeInteger(pid) || pid <= 0)
-        return undefined;
-    try {
-        if (process.platform === 'win32') {
-            const result = await exec('powershell.exe', [
-                '-NoProfile',
-                '-NonInteractive',
-                '-Command',
-                `(Get-Process -Id ${pid} -ErrorAction SilentlyContinue).CPU`,
-            ]);
-            const seconds = Number.parseFloat(result.stdout.trim());
-            return Number.isFinite(seconds) ? seconds : undefined;
-        }
-        const result = await exec('ps', ['-p', String(pid), '-o', 'time=']);
-        const field = result.stdout.split(/\r?\n/).find((line) => line.trim().length > 0);
-        if (field === undefined)
-            return undefined;
-        const seconds = parsePsDuration(field);
-        return Number.isNaN(seconds) ? undefined : seconds;
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/src/core/process-owner.d.ts

@@ -1,9 +0,0 @@
-/** Parent evidence; an unreadable parent is never proof of an orphan. */
-export declare function readProcessOwner(pid: number): Promise<{
-    parentPid: number;
-    owner: string;
-} | undefined>;
-/** Harness arguments alone never prove abandonment: require a dead parent too. */
-export declare function isOrphanedHarness(commandLine: string, parentPid?: number): boolean;
-/** Refreshes the exact command and orphan evidence immediately before signaling. */
-export declare function isStillOrphanedProcess(pid: number, commandLine: string): Promise<boolean>;

package/dist/src/core/process-owner.js

@@ -1,43 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { exec } from '../utils/process.js';
-/** Parent evidence; an unreadable parent is never proof of an orphan. */
-export async function readProcessOwner(pid) {
-    if (process.platform === 'win32')
-        return undefined;
-    try {
-        const result = await exec('ps', ['-p', String(pid), '-o', 'ppid='], { timeout: 5000 });
-        const parentPid = Number(result.stdout.trim());
-        if (result.exitCode !== 0 || !Number.isSafeInteger(parentPid) || parentPid < 1)
-            return undefined;
-        if (parentPid === 1)
-            return { parentPid, owner: 'init/launchd (parent exited)' };
-        const parent = await exec('ps', ['-p', String(parentPid), '-o', 'args='], { timeout: 5000 });
-        if (parent.exitCode !== 0 || !parent.stdout.trim())
-            return undefined;
-        return { parentPid, owner: parent.stdout.trim() };
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Harness arguments alone never prove abandonment: require a dead parent too. */
-export function isOrphanedHarness(commandLine, parentPid) {
-    return (parentPid === 1 &&
-        (/\s-marionette(?:\s|$)/.test(commandLine) ||
-            /\s-profile(?:\s|=)[^\n]*(?:fireforge-|mochitest|rust_mozprofile)/.test(commandLine)));
-}
-/** Refreshes the exact command and orphan evidence immediately before signaling. */
-export async function isStillOrphanedProcess(pid, commandLine) {
-    // Windows ownership has no verified implementation; never infer it from
-    // command-line appearance or enable a destructive PowerShell fallback.
-    if (process.platform === 'win32')
-        return false;
-    try {
-        const result = await exec('ps', ['-p', String(pid), '-o', 'ppid=,args='], { timeout: 5000 });
-        const match = /^\s*(\d+)\s+(.+?)\s*$/.exec(result.stdout);
-        return result.exitCode === 0 && match?.[1] === '1' && match[2] === commandLine;
-    }
-    catch {
-        return false;
-    }
-}