@hominis/fireforge 0.45.0 → 0.46.1

package/dist/src/core/engine-session-lock.js

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { InconclusiveVerdictError } from '../errors/base.js';
 import { toError } from '../utils/errors.js';
 import { info, warn } from '../utils/logger.js';
+import { sleep } from '../utils/sleep.js';
 import { readLockStatus, withFileLock } from './file-lock.js';
 import { git } from './git-base.js';
 const ENGINE_SESSION_LOCK_PATH = join('.fireforge', 'engine-session.lock');
@@ -17,38 +18,38 @@ const MAX_WAIT_LOCK_MS = 3600 * 1000;
 /**
  * Formats the periodic operator-facing waiting line printed while `--wait-lock`
  * polls a contended engine session lock. The holder identification comes from
- * the lock's owner-metadata lines (`command=…`, `started=…`); an unreadable
+ * the lock's owner-metadata lines (`command=…`, `started=…`). An unreadable
  * owner file degrades to the anonymous form.
  */
 function formatWaitProgressLine(waitedMs, timeoutMs, holder, queue) {
-    const progress = `${String(Math.round(waitedMs / 1000))}s of up to ${String(Math.round(timeoutMs / 1000))}s`;
+    const progress = `${Math.round(waitedMs / 1000)}s of up to ${Math.round(timeoutMs / 1000)}s`;
     // Queue position: under several concurrent sessions the wait
     // line alone left operators inferring their place from `ps`.
     const position = queue === undefined || queue.depth === 0
         ? ''
         : queue.ahead === 0
-            ? ` You are next in a queue of ${String(queue.depth)}.`
-            : ` ${String(queue.ahead)} ahead of you (queue of ${String(queue.depth)}).`;
+            ? ` You are next in a queue of ${queue.depth}.`
+            : ` ${queue.ahead} ahead of you (queue of ${queue.depth}).`;
     if (holder === undefined) {
         return `Waiting for the FireForge engine lock — ${progress}.${position}`;
     }
     const details = holder.metadata.length > 0 ? ` (${holder.metadata.join(', ')})` : '';
-    return `Waiting for the FireForge engine lock held by PID ${String(holder.pid)}${details} — ${progress}.${position}`;
+    return `Waiting for the FireForge engine lock held by PID ${holder.pid}${details} — ${progress}.${position}`;
 }
 /**
- * Formats the notice printed when the wait budget is EXTENDED because the
+ * Formats the notice printed when the wait budget is extended because the
  * queue advanced.
  *
- * Exported for direct unit testing. It names both figures — the requested
- * budget and the one now in force — because the whole point is that the two
- * have diverged, and an operator comparing the elapsed time against the
- * number they typed would otherwise conclude the timeout is broken.
+ * Exported for direct unit testing. It names both figures, the requested
+ * budget and the one now in force, because they have diverged and an
+ * operator comparing the elapsed time against the number they typed would
+ * otherwise conclude the timeout is broken.
  */
 export function formatWaitExtendedLine(ahead, budgetMs, requestedMs) {
-    const position = ahead === 0 ? 'you are now next' : `${String(ahead)} still ahead of you`;
+    const position = ahead === 0 ? 'you are now next' : `${ahead} still ahead of you`;
     return (`The queue advanced (${position}), so the engine-lock wait was extended to ` +
-        `${String(Math.round(budgetMs / 1000))}s total (you asked for ` +
-        `${String(Math.round(requestedMs / 1000))}s). A queue that stops moving still ` +
+        `${Math.round(budgetMs / 1000)}s total (you asked for ` +
+        `${Math.round(requestedMs / 1000)}s). A queue that stops moving still ` +
         `gives up on the budget you asked for.`);
 }
 /**
@@ -56,11 +57,11 @@ export function formatWaitExtendedLine(ahead, budgetMs, requestedMs) {
  * one engine-mutating FireForge command touches `engine/` at a time.
  */
 export async function withEngineSessionLock(projectRoot, command, operation, options = {}) {
-    // The lock is bypassed under test by default, and that is deliberate: the
+    // The lock is bypassed under test by default, on purpose: the
     // suite runs many engine-mutating commands in-process, which would either
     // serialise on this lock or deadlock outright.
     // `FIREFORGE_ENABLE_ENGINE_SESSION_LOCK_IN_TEST=1` lets the lock's own
-    // tests opt back in. Do not delete this branch — it is the reason the
+    // tests opt back in. Do not delete this branch. It is the reason the
     // suite completes.
     if (process.env['FIREFORGE_ENABLE_ENGINE_SESSION_LOCK_IN_TEST'] !== '1' &&
         (process.env['NODE_ENV'] === 'test' || process.env['VITEST'] !== undefined)) {
@@ -77,30 +78,30 @@ export async function withEngineSessionLock(projectRoot, command, operation, opt
                 onWaitProgress: ({ waitedMs, timeoutMs, holder, queue }) => {
                     info(formatWaitProgressLine(waitedMs, timeoutMs, holder, queue));
                 },
-                // Say it out loud. An extension is the moment the budget the
+                // Announce it. An extension is the moment the budget the
                 // operator asked for stops being the budget in force, and a wait
                 // that silently outlives its own stated timeout is
-                // indistinguishable from a broken one — which is how a downstream
+                // indistinguishable from a broken one, which is how a downstream
                 // fork read it.
                 onWaitExtended: ({ ahead, budgetMs }) => {
                     info(formatWaitExtendedLine(ahead, budgetMs, waitLockSeconds * 1000));
                 },
                 // A budget that expires one position from the head pays the whole
-                // wait for nothing. While the queue is still MOVING the wait is
-                // working, so each advance renews the budget — up to a hard
-                // ceiling, so a pathological queue cannot wait forever. The
-                // no-flag fail-fast path deliberately gets none of this.
+                // wait for nothing. While the queue is still moving the wait is
+                // working, so each advance renews the budget, up to a hard
+                // ceiling so a pathological queue cannot wait forever. The
+                // no-flag fail-fast path gets none of this.
                 extendWhileAdvancing: {
                     maxWaitMs: Math.min(waitLockSeconds * 1000 * WAIT_EXTENSION_FACTOR, MAX_WAIT_LOCK_MS),
                 },
             }
             : {}),
         ownerMetadata: [`command=${command}`, `started=${new Date().toISOString()}`],
-        // Reason first, remedy second — the no-flag default waits
+        // Reason first, remedy second: the no-flag default waits
         // only ~1 s, so contention is the common case and `--wait-lock` is the
         // genuine remedy. withFileLock appends the holder identification from
         // the lock's owner metadata. The leading sentence is a message contract
-        // (pinned by engine-session-lock tests); extend, don't reword.
+        // (pinned by engine-session-lock tests). Extend, don't reword.
         onTimeoutMessage: `Another FireForge engine-mutating command is already running. ` +
             `Wait for it to finish, then retry \`${command}\` — or pass --wait-lock [seconds] ` +
             `to wait for the lock (bare --wait-lock waits up to 60 seconds). ` +
@@ -109,8 +110,8 @@ export async function withEngineSessionLock(projectRoot, command, operation, opt
     });
 }
 /**
- * Inspects the project's engine-session lock without acquiring it —
- * backing `fireforge status --lock`.
+ * Inspects the project's engine-session lock without acquiring it, backing
+ * `fireforge status --lock`.
  *
  * @param projectRoot - Project root containing `.fireforge/`
  * @returns Holder identity, hold duration, and queue depth
@@ -128,21 +129,21 @@ export function formatEngineSessionLockStatus(snapshot, holderCpuSeconds) {
     }
     const elapsed = snapshot.heldForMs === undefined
         ? 'unknown duration'
-        : `${String(Math.round(snapshot.heldForMs / 1000))}s`;
+        : `${Math.round(snapshot.heldForMs / 1000)}s`;
     const holder = snapshot.holder;
     const identity = holder === undefined
         ? 'held by an unidentified process (no readable owner record)'
-        : `held by PID ${String(holder.pid)}${holder.alive ? '' : ' (NOT RUNNING — stale lock)'}` +
+        : `held by PID ${holder.pid}${holder.alive ? '' : ' (NOT RUNNING — stale lock)'}` +
             (holder.metadata.length > 0 ? ` (${holder.metadata.join(', ')})` : '');
     const lines = [
         `Engine session lock: ${identity}, for ${elapsed}.`,
-        `Queue depth: ${String(snapshot.queueDepth)} waiter(s).`,
+        `Queue depth: ${snapshot.queueDepth} waiter(s).`,
     ];
-    // Liveness answers "does the process exist"; it does not answer "is it
+    // Liveness answers "does the process exist". It does not answer "is it
     // getting anywhere". A holder alive for minutes having used a fraction of
     // a second of CPU is the shape of a wedged command, and every waiter
     // behind it inherits the stall. Stated as an observation with its own
-    // caveat — a holder blocked on I/O is also idle, and this must not be read
+    // caveat: a holder blocked on I/O is also idle, and this must not be read
     // as licence to kill anything.
     if (holder?.alive === true && holderCpuSeconds !== undefined) {
         const cpu = `${holderCpuSeconds.toFixed(1)}s`;
@@ -174,15 +175,15 @@ export async function snapshotEngineGeneration(engineDir) {
         }
         catch (error) {
             lastError = error;
-            // A contended `.git/index.lock` is TRANSIENT, not a state: some other
+            // A contended `.git/index.lock` is transient, not a state: some other
             // writer held the index for the instant we looked. Treating it as
             // "unmeasurable" turns a perfectly good suite into
             // `FAIL reason=inconclusive` on a one-sided probe failure. Anything
-            // else — an unreadable `.git`, a non-git `engine/` — is a real state
+            // else (an unreadable `.git`, a non-git `engine/`) is a real state
             // and is reported immediately.
             if (!isIndexLockError(error) || attempt === GENERATION_PROBE_ATTEMPTS - 1)
                 break;
-            await delay(GENERATION_PROBE_RETRY_MS);
+            await sleep(GENERATION_PROBE_RETRY_MS);
         }
     }
     return `${UNAVAILABLE_PREFIX}${toError(lastError).message}`;
@@ -191,11 +192,6 @@ export async function snapshotEngineGeneration(engineDir) {
 const GENERATION_PROBE_ATTEMPTS = 3;
 /** Pause between generation-probe attempts. */
 const GENERATION_PROBE_RETRY_MS = 250;
-function delay(ms) {
-    return new Promise((resolveDelay) => {
-        setTimeout(resolveDelay, ms);
-    });
-}
 /**
  * True when a git failure is the transient index-lock contention shape
  * (`Unable to create '…/.git/index.lock': File exists`) rather than a
@@ -206,7 +202,7 @@ export function isIndexLockError(error) {
     return /index\.lock/i.test(message);
 }
 /**
- * True when a generation token records a failed probe — i.e. nothing was
+ * True when a generation token records a failed probe, i.e. nothing was
  * measured, so the token must never be compared (or hashed) as if it
  * described the engine's state.
  */
@@ -232,9 +228,9 @@ function splitGenerationToken(token) {
 /**
  * Parses `git status --porcelain=v1 -z` into `XY path` records.
  *
- * The rename/copy shape is the trap: `R`/`C` entries are followed by a
- * SECOND NUL-separated field carrying the original path, and consuming only
- * one desynchronises every record after it — turning a one-file rename into
+ * The rename/copy shape needs care: `R`/`C` entries are followed by a
+ * second NUL-separated field carrying the original path, and consuming only
+ * one desynchronises every record after it, turning a one-file rename into
  * a report that the whole tree moved. Both fields are consumed and the
  * record renders as `orig -> new`.
  */
@@ -243,7 +239,7 @@ function parsePorcelainRecords(body) {
     const records = [];
     for (let i = 0; i < fields.length; i++) {
         const field = fields[i] ?? '';
-        // `XY ` — two status characters and a space — then the path.
+        // `XY `, two status characters and a space, then the path.
         if (field.length < 4)
             continue;
         const status = field.slice(0, 2);
@@ -261,8 +257,8 @@ function parsePorcelainRecords(body) {
 /**
  * Describes what moved between two generation tokens, in operator terms.
  *
- * The refusal used to say only THAT the engine changed, which left the
- * operator to reconstruct the writer by hand — `find -newermt` against the
+ * The refusal used to say only that the engine changed, which left the
+ * operator to reconstruct the writer by hand: `find -newermt` against the
  * run window, minus the objdir, minus git's own bookkeeping. Everything
  * needed to answer it is already in the two tokens, so the refusal answers
  * it. Pure and total: an unparseable token yields an empty list rather than
@@ -271,7 +267,7 @@ function parsePorcelainRecords(body) {
  *
  * @param before - Token captured before the run
  * @param after - Token captured after the run
- * @returns Human-readable lines describing the delta; empty when nothing
+ * @returns Human-readable lines describing the delta. Empty when nothing
  *   could be attributed
  */
 export function describeEngineGenerationDelta(before, after) {
@@ -290,7 +286,7 @@ export function describeEngineGenerationDelta(before, after) {
             return;
         const head = records.slice(0, DELTA_ENTRY_LIMIT);
         const truncated = records.length - head.length;
-        lines.push(`${label}: ${head.join(', ')}${truncated > 0 ? `, … (+${String(truncated)} more)` : ''}`);
+        lines.push(`${label}: ${head.join(', ')}${truncated > 0 ? `, … (+${truncated} more)` : ''}`);
     };
     render('Working-tree entries that appeared', appeared);
     render('Working-tree entries that went away', disappeared);
@@ -300,25 +296,25 @@ export function describeEngineGenerationDelta(before, after) {
  * Throws when the engine's generation token differs from `before`, i.e. the
  * engine was mutated by another writer while a test run was in flight.
  *
- * **An unmeasurable engine warns rather than throws.** `engine/` is not
- * always a git checkout — `fireforge download` extracts a source tarball —
+ * An unmeasurable engine warns rather than throws. `engine/` is not
+ * always a git checkout (`fireforge download` extracts a source tarball),
  * so a failed probe is a legitimate state and must not fail the run.
  *
- * What it must also not do is pass *silently*. A failure token compared for
+ * It must also not pass silently. A failure token compared for
  * equality like any other would let a git failure that reproduces across
  * both probes (unreadable `.git`, a permissions problem, a corrupt index)
  * take the `after === before` early return and bless a verdict the guard
- * never verified. Two *differing* failure messages are worse still: they
+ * never verified. Two differing failure messages are worse still: they
  * fall through to the mutation branch and report a spurious
  * "engine/ changed". Hence the prefix comparison rather than a token
- * comparison — the token embeds the error message, and two genuine failures
+ * comparison: the token embeds the error message, and two genuine failures
  * rarely phrase it identically.
  *
- * The tolerance is deliberately limited to a probe that failed *both* times:
+ * The tolerance is limited to a probe that failed both times:
  * that is the steady state of a non-git `engine/`, and it warns. A one-sided
  * transition is not that state. An `engine/` that was measurable and then
  * was not means the second probe measured nothing about a checkout that
- * demonstrably had something to measure; the reverse means there was never a
+ * demonstrably had something to measure. The reverse means there was never a
  * baseline to compare against. Neither verdict can be trusted, so both throw.
  */
 export async function assertEngineGenerationUnchanged(engineDir, before) {

package/dist/src/core/export-moved-code-shape.d.ts

@@ -2,23 +2,23 @@
  * Detects the new-file-plus-moved-code slice shape and names the working
  * sequence through it.
  *
- * A slice that ADDS new files and MOVES lines into them from an existing
+ * A slice that adds new files and moves lines into them from an existing
  * patch has no path through the two refusal flags:
  *
  *  - `re-export --refuse-adjacent-unmanaged` refuses while the new files are
- *    still unmanaged; and
+ *    still unmanaged, and
  *  - exporting the new files as their own patch fails cross-patch lint,
- *    because at the projected placement the OLD patch still contains the
+ *    because at the projected placement the old patch still contains the
  *    moved code.
  *
  * Each guard is individually correct. Together they dead-end, and the way out
- * is non-obvious: adopt the new files into the OLD patch first
+ * is non-obvious: adopt the new files into the old patch first
  * (`re-export --scan --scan-file`), then split them out into a patch of their
  * own (`patch move-files --create --order N`).
  *
- * This module recognises the shape from evidence FireForge already has — the
+ * This module recognises the shape from evidence FireForge already has (the
  * pending diff's new-file content versus the added lines the existing patches
- * carry — so the refusal can name the sequence instead of leaving the
+ * carry), so the refusal can name the sequence instead of leaving the
  * operator to derive it.
  */
 /** One existing patch that already carries lines the new files would add. */
@@ -37,7 +37,7 @@ export interface MovedCodeQueueEntry {
 }
 /**
  * Finds existing patches that still carry substantive lines the pending
- * diff's NEW files would add — the fingerprint of code moved out of an
+ * diff's new files would add, the fingerprint of code moved out of an
  * existing patch into a new file.
  *
  * Pure. Overlaps are returned strongest-first so the message names the

package/dist/src/core/export-moved-code-shape.js

@@ -3,23 +3,23 @@
  * Detects the new-file-plus-moved-code slice shape and names the working
  * sequence through it.
  *
- * A slice that ADDS new files and MOVES lines into them from an existing
+ * A slice that adds new files and moves lines into them from an existing
  * patch has no path through the two refusal flags:
  *
  *  - `re-export --refuse-adjacent-unmanaged` refuses while the new files are
- *    still unmanaged; and
+ *    still unmanaged, and
  *  - exporting the new files as their own patch fails cross-patch lint,
- *    because at the projected placement the OLD patch still contains the
+ *    because at the projected placement the old patch still contains the
  *    moved code.
  *
  * Each guard is individually correct. Together they dead-end, and the way out
- * is non-obvious: adopt the new files into the OLD patch first
+ * is non-obvious: adopt the new files into the old patch first
  * (`re-export --scan --scan-file`), then split them out into a patch of their
  * own (`patch move-files --create --order N`).
  *
- * This module recognises the shape from evidence FireForge already has — the
+ * This module recognises the shape from evidence FireForge already has (the
  * pending diff's new-file content versus the added lines the existing patches
- * carry — so the refusal can name the sequence instead of leaving the
+ * carry), so the refusal can name the sequence instead of leaving the
  * operator to derive it.
  */
 import { extractAddedLinesPerFile } from './patch-lint-diff.js';
@@ -42,7 +42,7 @@ function isSubstantiveLine(line) {
 const MOVED_CODE_LINE_THRESHOLD = 3;
 /**
  * Finds existing patches that still carry substantive lines the pending
- * diff's NEW files would add — the fingerprint of code moved out of an
+ * diff's new files would add, the fingerprint of code moved out of an
  * existing patch into a new file.
  *
  * Pure. Overlaps are returned strongest-first so the message names the
@@ -108,20 +108,20 @@ export function formatAdoptThenSplitRemedy(overlaps, newPatchName, insertionOrde
         return [];
     const fileArgs = strongest.files.map((file) => `--scan-file ${file}`).join(' ');
     const moveArgs = strongest.files.map((file) => `--file ${file}`).join(' ');
-    // `patch move-files --create` takes the new patch's NAME, not a
+    // `patch move-files --create` takes the new patch's name, not a
     // filename: strip the order prefix and the `.patch` suffix so the
     // suggested command is copy-pasteable.
     const suggestedName = newPatchName.replace(/^\d+-/, '').replace(/\.patch$/, '');
     return [
         '',
-        `This looks like a new-file + moved-code slice: ${String(strongest.sharedLines)} substantive ` +
+        `This looks like a new-file + moved-code slice: ${strongest.sharedLines} substantive ` +
             `line(s) the new file(s) would add are still carried by ${strongest.sourcePatch}. ` +
             'Exporting them as their own patch cannot pass cross-patch lint while the source patch ' +
             'still owns the same code, and re-exporting cannot adopt them while they are unmanaged — ' +
             'each guard is right, and together they dead-end.',
         'Working sequence (adopt, then split):',
         `  1. fireforge re-export ${strongest.sourcePatch} --scan ${fileArgs}`,
-        `  2. fireforge patch move-files ${strongest.sourcePatch} ${suggestedName} --create --order ${String(insertionOrder)} ${moveArgs}`,
+        `  2. fireforge patch move-files ${strongest.sourcePatch} ${suggestedName} --create --order ${insertionOrder} ${moveArgs}`,
         'Step 1 adopts the new files into the patch that already owns the moved lines; step 2 ' +
             'splits them back out as one transaction, so the queue is never in a state where two ' +
             'patches own the same code.',

package/dist/src/core/file-lock-owner.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Filename of a lock directory's owner record, relative to the lock dir.
+ *
+ * Re-exported by `file-lock.ts` so external readers (`tree-store.ts`) share
+ * the constant instead of re-spelling `'pid'`. The file format is
+ * documented on {@link readLockOwner}.
+ */
+export declare const LOCK_PID_FILE = "pid";
+/**
+ * Owner record read back from a lock directory's PID file.
+ *
+ * `token` is the per-acquisition UUID written on line 2 of the PID file,
+ * `acquiredAtMs` the wall-clock time the record was written (diagnostic),
+ * and `startTick` the writer's boot-relative start tick (liveness). Records
+ * from releases before a field was introduced parse with it `undefined`.
+ * Readers must treat that as "unknown", never as a mismatch.
+ */
+export type LockOwner = {
+    present: false;
+} | {
+    present: true;
+    pid: number;
+    token?: string;
+    acquiredAtMs?: number;
+    startTick?: number;
+    metadata: string[];
+};
+/**
+ * Reads the owner PID (line 1), acquisition token (line 2), the mechanical
+ * `acquired-at-ms=` / `start-tick=` lines (when present), and diagnostic
+ * metadata (the remaining lines 3+) from a lock directory's PID file.
+ * Returns `{ present: false }` when the PID file is missing, unreadable, or
+ * the PID does not parse as a finite integer (caller falls back to the
+ * age-only staleness heuristic).
+ *
+ * File format note: external readers do `parseInt(content.trim(), 10)`,
+ * which parses the leading digits of a multi-line file, so the token and
+ * mechanical lines stay compatible.
+ *
+ * @param lockPath - Lock directory whose owner record to read
+ * @returns The parsed owner record, or `{ present: false }`
+ */
+export declare function readLockOwner(lockPath: string): Promise<LockOwner>;
+/**
+ * Stamps this process's ownership (PID, per-acquisition token, acquisition
+ * time, own start tick, diagnostic metadata) into a lock directory it has
+ * just created, and reads the record back to prove it landed.
+ *
+ * The write is fatal. It used to be best-effort, on the theory that stale
+ * recovery would fall back to the age heuristic, but that heuristic reaps
+ * any owner-less lock after five minutes, and the build lock legitimately
+ * holds for hours. A holder whose record failed to write was therefore
+ * reaped mid-build and a second process entered the critical section. On
+ * failure the just-created lock directory is removed (nothing else can own
+ * it yet) and a {@link GeneralError} names the cause.
+ *
+ * @param lockPath - Lock directory this process has just `mkdir`'d
+ * @param token - Per-acquisition UUID, later checked by release
+ * @param ownerMetadata - Extra human-diagnostic lines (see `FileLockOptions.ownerMetadata`)
+ * @throws {GeneralError} When the record cannot be written or does not read back as written
+ */
+export declare function writeLockOwner(lockPath: string, token: string, ownerMetadata: readonly string[] | undefined): Promise<void>;
+/**
+ * Boot-relative start tick of a process, where the platform exposes it
+ * cheaply.
+ *
+ * Linux only: field 22 of `/proc/<pid>/stat`, in USER_HZ since boot.
+ * Elsewhere (macOS, Windows) obtaining a start time means spawning
+ * `ps`/`wmic` per probe, which is not worth paying on every poll of a
+ * contended lock. Those platforms return `undefined` and liveness stays
+ * PID-only.
+ *
+ * Not converted to wall-clock time via `/proc/stat` `btime`, on purpose:
+ * on current kernels `btime` is derived from the realtime clock and moves
+ * with every clock step, so a wall-clock comparison against a recorded
+ * acquisition time misjudges a live holder as a reused PID after NTP steps
+ * the clock forward, and reaps a lock that is in use.
+ *
+ * @param pid - Process to look up
+ * @param procRoot - procfs mount, overridable for tests
+ * @returns Start tick, or `undefined` when unobtainable
+ */
+export declare function readProcessStartTick(pid: number, procRoot?: string): number | undefined;
+/**
+ * Whether the process named by a lock's owner record is the same process
+ * that acquired the lock, not merely a live process wearing its PID.
+ *
+ * `isProcessAlive` answers "does this PID exist". After a holder crashes,
+ * the kernel may hand its PID to a long-lived daemon, and a PID-only check
+ * then honours the dead lock until the waiter's timeout. Where the record
+ * carries the writer's start tick and the candidate's own tick is cheaply
+ * obtainable (see {@link readProcessStartTick}), the two must be equal: a
+ * different tick is a different process. Records without a start tick, and
+ * platforms without one, keep the PID-only answer.
+ *
+ * @param owner - Owner record fields that identify the holder
+ * @param procRoot - procfs mount, overridable for tests
+ * @returns True when the original holder is still running (or cannot be proven gone)
+ */
+export declare function isLockOwnerAlive(owner: {
+    pid: number;
+    startTick?: number | undefined;
+}, procRoot?: string): boolean;