@hominis/fireforge 0.40.0 → 0.41.0

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

@@ -10,6 +10,8 @@ export declare function setVerbose(enabled: boolean): void;
 export declare function setMachineOutputMode(enabled: boolean): void;
 /** True when machine-output mode is active. */
 export declare function isMachineOutputMode(): boolean;
+/** Seals (or unseals) stdout after a machine-readable final line. */
+export declare function setStdoutSealed(sealed: boolean): void;
 /**
  * Displays a verbose/debug message (only shown if verbose mode is enabled).
  * @param message - Message to display
@@ -54,7 +56,17 @@ export declare function formatErrorText(message: string): string;
 export declare function spinner(initialMessage: string): SpinnerHandle;
 /** Emits a cancellation message. */
 export declare function cancel(message: string): void;
-/** Checks whether a prompt result represents a user cancellation. */
-export declare function isCancel(value: unknown): boolean;
+/**
+ * Checks whether a prompt result represents a user cancellation.
+ *
+ * Narrows to `symbol` — clack returns its cancel sentinel as a symbol and
+ * `p.isCancel` is itself a type predicate. This wrapper erased that narrowing
+ * by returning plain `boolean` until 0.41.0, which forced eleven `as string`
+ * / `as PatchCategory` / `as OverrideType` casts across six command modules
+ * on the *non*-cancelled branch, where the value is already known not to be
+ * the sentinel. Keep the predicate form: it is the single highest-leverage
+ * signature in the codebase for escape-hatch count.
+ */
+export declare function isCancel(value: unknown): value is symbol;
 /** Displays a titled note block for follow-up details. */
 export declare function note(message: string, title?: string): void;

package/dist/src/utils/logger.js

@@ -34,6 +34,26 @@ export function setMachineOutputMode(enabled) {
 export function isMachineOutputMode() {
     return machineOutputMode;
 }
+/**
+ * Whether stdout is sealed behind a machine-readable final line.
+ *
+ * The `FIREFORGE-VERDICT:` contract promises that line as the run's LAST
+ * stdout write — but emit-then-throw failure paths rethrow into
+ * `withErrorHandling`, whose clack error/cancel rendering lands on stdout
+ * in non-machine mode, displacing the verdict from the final line. The
+ * verdict sink seals stdout the moment it writes; every later logger call
+ * routes to stderr through the same diagnostic channel machine mode uses.
+ * `withErrorHandling`'s finally clears the seal (alongside machine mode).
+ */
+let stdoutSealed = false;
+/** Seals (or unseals) stdout after a machine-readable final line. */
+export function setStdoutSealed(sealed) {
+    stdoutSealed = sealed;
+}
+/** True when human output must avoid stdout. */
+function routeToStderr() {
+    return machineOutputMode || stdoutSealed;
+}
 /** Writes a plain diagnostic line to stderr (machine-mode side channel). */
 function writeDiagnostic(prefix, message) {
     process.stderr.write(`${prefix}${message}\n`);
@@ -52,7 +72,7 @@ function isVerbose() {
 export function verbose(message) {
     if (!isVerbose())
         return;
-    if (machineOutputMode) {
+    if (routeToStderr()) {
         writeDiagnostic('[debug] ', message);
         return;
     }
@@ -63,19 +83,19 @@ function supportsInteractiveSpinner() {
 }
 /** Displays the top-level intro banner for a command. */
 export function intro(message) {
-    if (machineOutputMode)
+    if (routeToStderr())
         return;
     p.intro(message);
 }
 /** Displays the closing outro banner for a command. */
 export function outro(message) {
-    if (machineOutputMode)
+    if (routeToStderr())
         return;
     p.outro(message);
 }
 /** Logs an informational message. */
 export function info(message) {
-    if (machineOutputMode) {
+    if (routeToStderr()) {
         writeDiagnostic('', message);
         return;
     }
@@ -83,7 +103,7 @@ export function info(message) {
 }
 /** Logs a success message. */
 export function success(message) {
-    if (machineOutputMode) {
+    if (routeToStderr()) {
         writeDiagnostic('', message);
         return;
     }
@@ -91,7 +111,7 @@ export function success(message) {
 }
 /** Logs a warning message. */
 export function warn(message) {
-    if (machineOutputMode) {
+    if (routeToStderr()) {
         writeDiagnostic('warning: ', message);
         return;
     }
@@ -99,7 +119,7 @@ export function warn(message) {
 }
 /** Logs an error message. */
 export function error(message) {
-    if (machineOutputMode) {
+    if (routeToStderr()) {
         writeDiagnostic('error: ', message);
         return;
     }
@@ -107,7 +127,7 @@ export function error(message) {
 }
 /** Logs an in-progress step message. */
 export function step(message) {
-    if (machineOutputMode) {
+    if (routeToStderr()) {
         writeDiagnostic('', message);
         return;
     }
@@ -115,7 +135,7 @@ export function step(message) {
 }
 /** Logs a plain message without a status prefix. */
 export function message(message) {
-    if (machineOutputMode) {
+    if (routeToStderr()) {
         writeDiagnostic('', message);
         return;
     }
@@ -135,7 +155,7 @@ export function formatErrorText(message) {
  * @returns Spinner handle with message(), stop(), and error() methods
  */
 export function spinner(initialMessage) {
-    if (machineOutputMode) {
+    if (routeToStderr()) {
         // Spinner progress is diagnostics; keep stdout clean for the payload.
         return {
             message: (msg) => {
@@ -182,19 +202,29 @@ export function spinner(initialMessage) {
 }
 /** Emits a cancellation message. */
 export function cancel(message) {
-    if (machineOutputMode) {
+    if (routeToStderr()) {
         writeDiagnostic('cancelled: ', message);
         return;
     }
     p.cancel(message);
 }
-/** Checks whether a prompt result represents a user cancellation. */
+/**
+ * Checks whether a prompt result represents a user cancellation.
+ *
+ * Narrows to `symbol` — clack returns its cancel sentinel as a symbol and
+ * `p.isCancel` is itself a type predicate. This wrapper erased that narrowing
+ * by returning plain `boolean` until 0.41.0, which forced eleven `as string`
+ * / `as PatchCategory` / `as OverrideType` casts across six command modules
+ * on the *non*-cancelled branch, where the value is already known not to be
+ * the sentinel. Keep the predicate form: it is the single highest-leverage
+ * signature in the codebase for escape-hatch count.
+ */
 export function isCancel(value) {
     return p.isCancel(value);
 }
 /** Displays a titled note block for follow-up details. */
 export function note(message, title) {
-    if (machineOutputMode) {
+    if (routeToStderr()) {
         writeDiagnostic('', title ? `${title}: ${message}` : message);
         return;
     }

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

@@ -22,6 +22,21 @@ import type { Command } from 'commander';
  * helper (or throw commander's InvalidArgumentError directly).
  */
 export declare function commanderArgParser<T>(parse: (raw: string) => T): (raw: string) => T;
+/**
+ * Commander plumbing for a repeatable string option, as a spreadable
+ * `[accumulator, default]` pair:
+ *
+ * ```ts
+ * .option('--mach-arg <arg>', 'Repeatable.', ...stringListOption())
+ * ```
+ *
+ * Seven call sites open-coded this, each with its own `[] as string[]`
+ * default — commander types that slot as `unknown`, so every one carried the
+ * cast. Two of the seven also mutated the accumulator in place rather than
+ * returning a new array. Returning a fresh array per call additionally means
+ * the default cannot be shared between two `.option()` registrations.
+ */
+export declare function stringListOption(): [(value: string, previous: string[]) => string[], string[]];
 /**
  * Resolves the parsed `--wait-lock [seconds]` option value into a wait budget
  * in seconds for `withEngineSessionLock`:
@@ -35,9 +50,11 @@ export declare function commanderArgParser<T>(parse: (raw: string) => T): (raw:
  */
 export declare function resolveWaitLockSeconds(value: string | number | boolean | undefined): number | undefined;
 /**
- * Registers the shared `--wait-lock [seconds]` flag on an engine-mutating
- * command. The parsed option value is `true` for the bare flag or a validated
- * integer; feed it through {@link resolveWaitLockSeconds} at the call site to
- * obtain the `waitLockSeconds` for `withEngineSessionLock`.
+ * Registers the shared `--wait-lock [seconds]` flag on a lock-taking
+ * command (the engine session lock for engine-mutating commands, the patch
+ * directory lock for queue-mutating ones). The parsed option value is `true`
+ * for the bare flag or a validated integer; feed it through
+ * {@link resolveWaitLockSeconds} at the call site to obtain the
+ * `waitLockSeconds` for `withEngineSessionLock`/`withPatchDirectoryLock`.
  */
 export declare function addWaitLockOption(command: Command): Command;

package/dist/src/utils/options.js

@@ -15,6 +15,7 @@ export function pickDefined(obj) {
 }
 import { InvalidArgumentError as CommanderInvalidArgumentError } from 'commander';
 import { GeneralError } from '../errors/base.js';
+import { toError } from './errors.js';
 /**
  * Wraps an option-argument parser so its failures surface through
  * commander's own invalid-argument channel.
@@ -35,10 +36,27 @@ export function commanderArgParser(parse) {
             return parse(raw);
         }
         catch (error) {
-            throw new CommanderInvalidArgumentError(error instanceof Error ? error.message : String(error));
+            throw new CommanderInvalidArgumentError(toError(error).message);
         }
     };
 }
+/**
+ * Commander plumbing for a repeatable string option, as a spreadable
+ * `[accumulator, default]` pair:
+ *
+ * ```ts
+ * .option('--mach-arg <arg>', 'Repeatable.', ...stringListOption())
+ * ```
+ *
+ * Seven call sites open-coded this, each with its own `[] as string[]`
+ * default — commander types that slot as `unknown`, so every one carried the
+ * cast. Two of the seven also mutated the accumulator in place rather than
+ * returning a new array. Returning a fresh array per call additionally means
+ * the default cannot be shared between two `.option()` registrations.
+ */
+export function stringListOption() {
+    return [(value, previous) => [...previous, value], []];
+}
 /** Wait budget applied when `--wait-lock` is passed without a value. */
 const DEFAULT_WAIT_LOCK_SECONDS = 60;
 /**
@@ -69,11 +87,13 @@ export function resolveWaitLockSeconds(value) {
     return n;
 }
 /**
- * Registers the shared `--wait-lock [seconds]` flag on an engine-mutating
- * command. The parsed option value is `true` for the bare flag or a validated
- * integer; feed it through {@link resolveWaitLockSeconds} at the call site to
- * obtain the `waitLockSeconds` for `withEngineSessionLock`.
+ * Registers the shared `--wait-lock [seconds]` flag on a lock-taking
+ * command (the engine session lock for engine-mutating commands, the patch
+ * directory lock for queue-mutating ones). The parsed option value is `true`
+ * for the bare flag or a validated integer; feed it through
+ * {@link resolveWaitLockSeconds} at the call site to obtain the
+ * `waitLockSeconds` for `withEngineSessionLock`/`withPatchDirectoryLock`.
  */
 export function addWaitLockOption(command) {
-    return command.option('--wait-lock [seconds]', 'Wait up to this many seconds (default 60) for another FireForge engine-mutating command to release the engine lock, instead of failing immediately', commanderArgParser((raw) => resolveWaitLockSeconds(raw)));
+    return command.option('--wait-lock [seconds]', 'Wait up to this many seconds (default 60) for another FireForge command to release the contended lock, instead of failing on the default budget', commanderArgParser((raw) => resolveWaitLockSeconds(raw)));
 }

package/dist/src/utils/package-root.js

@@ -2,6 +2,8 @@
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { getNodeErrorCode, toError } from './errors.js';
+import { isObject } from './validation.js';
 function validatePackageMetadata(data, filePath) {
     if (typeof data !== 'object' || data === null) {
         throw new Error(`Invalid package metadata in ${filePath}: expected an object`);
@@ -48,10 +50,11 @@ export function getPackageRoot() {
             // to a wrong ancestor package (any parent exposing bin.fireforge) or
             // end in the unhelpful generic "could not locate" error, hiding the
             // actual syntax problem.
-            const code = error.code;
+            const code = getNodeErrorCode(error);
             if (code !== 'ENOENT' && code !== 'ENOTDIR') {
-                throw new Error(`Found ${packagePath} but could not parse it: ` +
-                    (error instanceof Error ? error.message : String(error)), { cause: error });
+                throw new Error(`Found ${packagePath} but could not parse it: ` + toError(error).message, {
+                    cause: error,
+                });
             }
         }
         const parent = dirname(current);
@@ -63,7 +66,7 @@ export function getPackageRoot() {
 }
 /** @internal */
 export function isFireForgePackageMetadata(pkg) {
-    if (typeof pkg.bin !== 'object' || pkg.bin === null || Array.isArray(pkg.bin)) {
+    if (!isObject(pkg.bin)) {
         return false;
     }
     const bin = pkg.bin;

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

@@ -6,6 +6,7 @@
  * 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';
 /**
  * Sends `signal` to the child's whole tree: the process GROUP on POSIX
@@ -99,8 +100,14 @@ async function listGroupSurvivors(pgid) {
         process.kill(-pgid, 0);
         return [{ pid: -1, command: 'unknown (pgrep unavailable; group still has live members)' }];
     }
-    catch {
-        return [];
+    catch (error) {
+        // Same errno semantics as `isProcessAlive` (which cannot be called here —
+        // 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 — report survivors in both cases.
+        if (getNodeErrorCode(error) === 'ESRCH')
+            return [];
+        return [{ pid: -1, command: 'unknown (pgrep unavailable; group liveness probe denied)' }];
     }
 }
 function describeSurvivors(list) {
@@ -133,6 +140,8 @@ export async function sweepProcessGroup(pgid, graceMs = SWEEP_GRACE_MS) {
         process.kill(-pgid, 'SIGTERM');
     }
     catch {
+        // The group vanished between the listing and the signal — nothing left to
+        // escalate against, so report the survivors collected so far.
         return { survivors };
     }
     await sweepDelay(graceMs);
@@ -142,6 +151,8 @@ export async function sweepProcessGroup(pgid, graceMs = SWEEP_GRACE_MS) {
             process.kill(-pgid, 'SIGKILL');
         }
         catch {
+            // The group died during the grace period, so the SIGKILL escalation has
+            // nothing to signal.
             return { survivors };
         }
         await sweepDelay(Math.min(200, graceMs));

package/dist/src/utils/stdio-drain.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Bounded stdio drain for delayed process exits (FORGE I1).
+ *
+ * `process.exit()` discards whatever is still queued in an async writable —
+ * and stdout IS async when it is a pipe, with a 64 KiB kernel buffer on
+ * macOS/Linux. The observed failure: `status --json --fail-on` writes a
+ * 176 KB payload, the refusal makes `bin/fireforge.ts` exit non-zero, and a
+ * piped consumer receives exactly 65 536 bytes. The bin entry point awaits
+ * this helper before every delayed exit; the helper itself never calls
+ * `process.exit` (the process-boundary test keeps that a bin-only right).
+ */
+/**
+ * The structural slice of `Writable` the drain wait needs — accepted instead
+ * of `NodeJS.WriteStream` so unit tests can drive synthetic streams.
+ */
+export interface DrainableStream {
+    readonly destroyed: boolean;
+    readonly writableFinished: boolean;
+    readonly writableLength: number;
+    on(event: 'drain' | 'error' | 'close', listener: () => void): unknown;
+    off(event: 'drain' | 'error' | 'close', listener: () => void): unknown;
+}
+/**
+ * Waits (bounded by `timeoutMs`) for every given stream — stdout and stderr
+ * by default — to drain. Resolution is unconditional; the caller exits
+ * either way, the bound only decides how much queued output survives.
+ */
+export declare function waitForStdioDrain(timeoutMs: number, streams?: readonly DrainableStream[]): Promise<void>;

package/dist/src/utils/stdio-drain.js

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Bounded stdio drain for delayed process exits (FORGE I1).
+ *
+ * `process.exit()` discards whatever is still queued in an async writable —
+ * and stdout IS async when it is a pipe, with a 64 KiB kernel buffer on
+ * macOS/Linux. The observed failure: `status --json --fail-on` writes a
+ * 176 KB payload, the refusal makes `bin/fireforge.ts` exit non-zero, and a
+ * piped consumer receives exactly 65 536 bytes. The bin entry point awaits
+ * this helper before every delayed exit; the helper itself never calls
+ * `process.exit` (the process-boundary test keeps that a bin-only right).
+ */
+/** True when nothing the process is about to lose remains queued. */
+function isFlushed(stream) {
+    return stream.destroyed || stream.writableFinished || stream.writableLength === 0;
+}
+/**
+ * Resolves once `stream` has drained its queued writes, and always within
+ * `timeoutMs`. Never rejects: `'error'` and `'close'` (an EPIPE'd pipe —
+ * `installBrokenPipeHandler` already swallows the error itself) resolve
+ * immediately, because a destroyed pipe can never drain and must not stall
+ * the exit behind it.
+ */
+function waitForStreamDrain(stream, timeoutMs) {
+    if (isFlushed(stream)) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        const settle = () => {
+            clearTimeout(timer);
+            stream.off('drain', onDrain);
+            stream.off('error', settle);
+            stream.off('close', settle);
+            resolve();
+        };
+        const onDrain = () => {
+            if (isFlushed(stream)) {
+                settle();
+            }
+        };
+        const timer = setTimeout(settle, timeoutMs);
+        stream.on('drain', onDrain);
+        stream.on('error', settle);
+        stream.on('close', settle);
+    });
+}
+/**
+ * Waits (bounded by `timeoutMs`) for every given stream — stdout and stderr
+ * by default — to drain. Resolution is unconditional; the caller exits
+ * either way, the bound only decides how much queued output survives.
+ */
+export async function waitForStdioDrain(timeoutMs, streams = [process.stdout, process.stderr]) {
+    await Promise.all(streams.map((stream) => waitForStreamDrain(stream, timeoutMs)));
+}

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

@@ -1,3 +1,4 @@
+import type { FirefoxProduct } from '../types/config.js';
 /**
  * Checks whether a value is a string.
  * @param value - Value to check
@@ -62,11 +63,31 @@ export declare function isValidFirefoxVersion(version: string): boolean;
  * Accepts formats like "build1", "build2", "build12" (no leading zero).
  */
 export declare function isValidFirefoxCandidate(candidate: string): boolean;
+/**
+ * Valid Firefox product identifiers.
+ *
+ * `satisfies readonly FirefoxProduct[]` links the runtime list to the union at
+ * `types/config.ts:5` in ONE direction: it rejects an entry here that the union
+ * does not declare. It cannot see a union member missing from this list —
+ * widening a `readonly T[]` check never fails for being short. The reverse
+ * direction is covered by the exhaustive switch in
+ * `utils/__tests__/validation.test.ts`, which fails to compile when the union
+ * grows.
+ *
+ * Two further copies of this list existed before 0.41.0 — an inline literal
+ * inside the validator below and `SOURCE_PRODUCTS` in `commands/source.ts` —
+ * neither linked to the union.
+ */
+export declare const FIREFOX_PRODUCTS: readonly ["firefox", "firefox-esr", "firefox-beta", "firefox-devedition"];
 /**
  * Validates a Firefox product string.
- * Accepts: firefox, firefox-esr, firefox-beta, firefox-devedition
+ *
+ * A type predicate, matching its siblings {@link isValidPatchCategory} and
+ * {@link isValidProjectLicense}. It returned plain `boolean` until 0.41.0,
+ * which forced `as FirefoxProduct` casts at both call sites even though the
+ * `.includes` check IS the runtime proof.
  */
-export declare function isValidFirefoxProduct(product: string): boolean;
+export declare function isValidFirefoxProduct(product: string): product is FirefoxProduct;
 /**
  * Valid project license SPDX identifiers.
  */

package/dist/src/utils/validation.js

@@ -4,6 +4,7 @@
  * Used to safely narrow types from unknown values.
  */
 import { InvalidArgumentError } from '../errors/base.js';
+import { escapeRegex } from './regex.js';
 /**
  * Checks whether a value is a string.
  * @param value - Value to check
@@ -94,12 +95,37 @@ export function isValidFirefoxVersion(version) {
 export function isValidFirefoxCandidate(candidate) {
     return /^build[1-9]\d{0,3}$/.test(candidate);
 }
+/**
+ * Valid Firefox product identifiers.
+ *
+ * `satisfies readonly FirefoxProduct[]` links the runtime list to the union at
+ * `types/config.ts:5` in ONE direction: it rejects an entry here that the union
+ * does not declare. It cannot see a union member missing from this list —
+ * widening a `readonly T[]` check never fails for being short. The reverse
+ * direction is covered by the exhaustive switch in
+ * `utils/__tests__/validation.test.ts`, which fails to compile when the union
+ * grows.
+ *
+ * Two further copies of this list existed before 0.41.0 — an inline literal
+ * inside the validator below and `SOURCE_PRODUCTS` in `commands/source.ts` —
+ * neither linked to the union.
+ */
+export const FIREFOX_PRODUCTS = [
+    'firefox',
+    'firefox-esr',
+    'firefox-beta',
+    'firefox-devedition',
+];
 /**
  * Validates a Firefox product string.
- * Accepts: firefox, firefox-esr, firefox-beta, firefox-devedition
+ *
+ * A type predicate, matching its siblings {@link isValidPatchCategory} and
+ * {@link isValidProjectLicense}. It returned plain `boolean` until 0.41.0,
+ * which forced `as FirefoxProduct` casts at both call sites even though the
+ * `.includes` check IS the runtime proof.
  */
 export function isValidFirefoxProduct(product) {
-    return ['firefox', 'firefox-esr', 'firefox-beta', 'firefox-devedition'].includes(product);
+    return FIREFOX_PRODUCTS.includes(product);
 }
 /**
  * Valid project license SPDX identifiers.
@@ -262,7 +288,7 @@ export function normalizeTokenName(name) {
  */
 export function normalizePatchDisplayName(name, category) {
     const stem = name.trim().replace(/\.patch$/i, '');
-    const escaped = category.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const escaped = escapeRegex(category);
     const prefixes = [
         new RegExp(`^\\d+[-_ ]+${escaped}[-_ ]+`, 'i'),
         new RegExp(`^${escaped}[-_ ]+`, 'i'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hominis/fireforge",
-  "version": "0.40.0",
+  "version": "0.41.0",
   "description": "FireForge — a build tool for customizing Firefox",
   "type": "module",
   "main": "./dist/src/index.js",
@@ -18,11 +18,11 @@
   },
   "scripts": {
     "fireforge": "tsx bin/fireforge.ts",
-    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "build": "npm run clean && tsc -p tsconfig.build.json && node ./scripts/generate-build-info.mjs",
     "clean": "node ./scripts/clean.mjs",
-    "lint": "eslint src/ bin/ scripts/ eslint.config.js vitest.config.ts vitest.pack.config.ts",
-    "lint:ci": "eslint src/ bin/ scripts/ eslint.config.js vitest.config.ts vitest.pack.config.ts --max-warnings 0",
-    "lint:fix": "eslint src/ bin/ scripts/ eslint.config.js vitest.config.ts vitest.pack.config.ts --fix",
+    "lint": "eslint src/ bin/ scripts/ eslint-rules/ eslint.config.js vitest.config.ts vitest.pack.config.ts",
+    "lint:ci": "eslint src/ bin/ scripts/ eslint-rules/ eslint.config.js vitest.config.ts vitest.pack.config.ts --max-warnings 0",
+    "lint:fix": "eslint src/ bin/ scripts/ eslint-rules/ eslint.config.js vitest.config.ts vitest.pack.config.ts --fix",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "deadcode:check": "knip",
     "cycles:check": "dpdm --no-output --no-tree --no-warning --exit-code circular:1 src/index.ts bin/fireforge.ts",
@@ -34,10 +34,10 @@
     "whitespace:check": "node ./scripts/check-worktree-whitespace.mjs",
     "pack:verify": "vitest run --config vitest.pack.config.ts",
     "pack:dry-run": "npm pack --dry-run --json --silent",
-    "format": "prettier --write --ignore-unknown \"src/**/*.ts\" \"bin/**/*.ts\" \"scripts/**/*.mjs\" \"package.json\" \"eslint.config.js\" \"vitest.config.ts\" \"vitest.pack.config.ts\" \"tsconfig.json\" \"tsconfig.build.json\" \".lintstagedrc.json\" \".prettierignore\" \".prettierrc\" \".gitignore\" \"README.md\" \"CHANGELOG.md\" \"docs/**/*.md\" \"knip.json\" \"docs/**/*.md\" \"knip.json\"",
-    "format:check": "prettier --check --ignore-unknown \"src/**/*.ts\" \"bin/**/*.ts\" \"scripts/**/*.mjs\" \"package.json\" \"eslint.config.js\" \"vitest.config.ts\" \"vitest.pack.config.ts\" \"tsconfig.json\" \"tsconfig.build.json\" \".lintstagedrc.json\" \".prettierignore\" \".prettierrc\" \".gitignore\" \"README.md\" \"CHANGELOG.md\" \"docs/**/*.md\" \"knip.json\" \"docs/**/*.md\" \"knip.json\"",
+    "format": "prettier --write --ignore-unknown \"src/**/*.ts\" \"bin/**/*.ts\" \"scripts/**/*.mjs\" \"eslint-rules/**/*.js\" \"package.json\" \"eslint.config.js\" \"vitest.config.ts\" \"vitest.pack.config.ts\" \"tsconfig.json\" \"tsconfig.build.json\" \".lintstagedrc.json\" \".prettierignore\" \".prettierrc\" \".gitignore\" \"README.md\" \"CHANGELOG.md\" \"docs/**/*.md\" \"knip.json\"",
+    "format:check": "prettier --check --ignore-unknown \"src/**/*.ts\" \"bin/**/*.ts\" \"scripts/**/*.mjs\" \"eslint-rules/**/*.js\" \"package.json\" \"eslint.config.js\" \"vitest.config.ts\" \"vitest.pack.config.ts\" \"tsconfig.json\" \"tsconfig.build.json\" \".lintstagedrc.json\" \".prettierignore\" \".prettierrc\" \".gitignore\" \"README.md\" \"CHANGELOG.md\" \"docs/**/*.md\" \"knip.json\"",
     "prepare": "node -e \"import('./scripts/prepare.mjs').catch((error) => { if (error && typeof error === 'object' && 'code' in error && error.code === 'ERR_MODULE_NOT_FOUND') process.exit(0); throw error; })\"",
-    "prepack": "npm run build",
+    "prepack": "npm run build && node ./scripts/generate-build-info.mjs --loud",
     "release:check": "npm run format:check && npm run whitespace:check && npm run lint:ci && npm run typecheck && npm run deadcode:check && npm run cycles:check && npm run test:coverage && npm run pack:verify && npm run pack:dry-run",
     "prepublishOnly": "npm run release:check"
   },
@@ -73,7 +73,7 @@
     "eslint-plugin-simple-import-sort": "^14.0.0",
     "fast-check": "^4.6.0",
     "husky": "^9.1.7",
-    "knip": "6.29.0",
+    "knip": "6.32.0",
     "lint-staged": "^17.0.4",
     "prettier": "3.9.6",
     "tsx": "^4.7.0",