@hominis/fireforge 0.49.2 → 0.51.0

package/dist/src/utils/options.js

@@ -68,9 +68,14 @@ export function stringListOption() {
 const DEFAULT_WAIT_LOCK_SECONDS = 60;
 /** Environment variable naming a standing wait budget for the whole session. */
 export const WAIT_LOCK_ENV_VAR = 'FIREFORGE_WAIT_LOCK';
-/** Bounds shared by the flag and the environment variable. */
+/**
+ * Bounds shared by the flag and the environment variable. The ceiling is a
+ * day: on a shared engine a re-export or `test --build` queued behind a
+ * peer's long series can need more than the hour the cap used to be, and a
+ * longer wait then had to be a requeue after exit 15.
+ */
 const MIN_WAIT_LOCK_SECONDS = 1;
-const MAX_WAIT_LOCK_SECONDS = 3600;
+export const MAX_WAIT_LOCK_SECONDS = 86_400;
 /**
  * Parses a wait budget from text, or undefined when it is not an integer in
  * range. Shared by the flag and {@link WAIT_LOCK_ENV_VAR} so the two cannot
@@ -115,7 +120,7 @@ function waitLockSecondsFromEnv() {
  * - absent (`undefined`) → {@link WAIT_LOCK_ENV_VAR} if set, else `undefined`
  *   (the ~1 s fail-fast),
  * - bare flag (`true`) → {@link DEFAULT_WAIT_LOCK_SECONDS},
- * - explicit value → integer validated into 1..3600.
+ * - explicit value → integer validated into 1..86400.
  *
  * The flag always wins over the environment: the environment expresses a
  * default for a session, and an invocation that names a budget has said
@@ -151,11 +156,11 @@ export function resolveWaitLockSeconds(value) {
  * `--wait-lock` flag was threaded to. A furnace mutation takes the engine
  * session lock and then `.fireforge/furnace.lock`. Only the first had a
  * budget, so a contended deploy died on the file lock's fixed 30 s while
- * its operator believed a much larger budget was in force. Threading the
- * flag reaches the three furnace commands that declare it. This reaches
- * the twelve that do not (`create`, `remove`, `rename`, `refresh`, `scan`,
- * `override`, `chrome-doc`, …), which have no flag to thread but are just
- * as contended.
+ * its operator believed a much larger budget was in force. Every furnace
+ * leaf that takes the furnace lock threads its own `--wait-lock` into it;
+ * this is the fallback when the flag is absent, and the only budget for
+ * callers that do not thread one (doctor's furnace repair, the
+ * pre-build apply).
  *
  * Env-only: a flag belongs to one invocation and is passed
  * explicitly where it applies, while the environment is exactly the place a
@@ -204,9 +209,90 @@ export function ensureWaitLockOptionEverywhere(command) {
         // action can see it. Register the uniform flag only on actionable leaves.
         if (sub.commands.length === 0 && !hasWaitLockOption(sub))
             addAcceptedWaitLockOption(sub);
+        releasePathShapedOptionalValues(sub);
         ensureWaitLockOptionEverywhere(sub);
     }
 }
+/**
+ * Optional-value flags whose value is a number and therefore never a path.
+ * `--canary [path]` is the counter-example that must stay out: its value IS
+ * a path.
+ */
+const NUMERIC_OPTIONAL_VALUE_FLAGS = new Set([
+    '--wait-lock',
+    '--wait-browser',
+    '--wait-port',
+    '--shuffle',
+]);
+/**
+ * True for a token that reads as a path rather than a number: it has a
+ * path separator or a file extension, or is `.`/`..`. A bare word such as
+ * `nonsense` is not path-shaped, so `--wait-lock nonsense` stays the usage
+ * error it always was.
+ */
+export function isPathShapedArgument(token) {
+    if (/^\d+(?:\.\d+)?$/.test(token))
+        return false;
+    return token === '.' || token === '..' || /[\\/]/.test(token) || /\.[A-Za-z][\w-]*$/.test(token);
+}
+/**
+ * Rewrites a command's option tokens so a path-shaped argument after a
+ * numeric optional-value flag is an operand, and the flag takes its
+ * default.
+ *
+ * Commander binds the next non-dash token to an optional value, so
+ * `fireforge test --build --wait-lock browser_x.js` failed with
+ * "--wait-lock must be an integer in 1..86400 (got "browser_x.js")": the
+ * help says the value is optional, and the obvious spelling refused. The
+ * released flag moves to the end of the option section (before any `--`),
+ * where nothing follows it, so commander reads it bare. Operands keep their
+ * relative order. The value of a required-value option (`--mach-arg
+ * --wait-lock`) is never mistaken for a flag.
+ *
+ * @param argv - The tokens commander passes to `parseOptions`
+ * @param requiredValueFlags - This command's flags that always take a value
+ * @returns The rewritten tokens
+ */
+export function releasePathShapedValues(argv, requiredValueFlags) {
+    const kept = [];
+    const released = [];
+    let index = 0;
+    for (; index < argv.length; index += 1) {
+        const token = argv[index] ?? '';
+        if (token === '--')
+            break;
+        const next = argv[index + 1];
+        if (requiredValueFlags.has(token) && next !== undefined) {
+            kept.push(token, next);
+            index += 1;
+            continue;
+        }
+        if (NUMERIC_OPTIONAL_VALUE_FLAGS.has(token) &&
+            next !== undefined &&
+            !next.startsWith('-') &&
+            isPathShapedArgument(next)) {
+            released.push(token);
+            continue;
+        }
+        kept.push(token);
+    }
+    return [...kept, ...released, ...argv.slice(index)];
+}
+/**
+ * Installs {@link releasePathShapedValues} on `command` when it registers
+ * any numeric optional-value flag.
+ */
+function releasePathShapedOptionalValues(command) {
+    const flags = command.options.filter((option) => option.long !== undefined && NUMERIC_OPTIONAL_VALUE_FLAGS.has(option.long));
+    if (flags.length === 0)
+        return;
+    const requiredValueFlags = new Set(command.options
+        .filter((option) => option.required)
+        .flatMap((option) => [option.long, option.short])
+        .filter((flag) => flag !== undefined));
+    const parseOptions = command.parseOptions.bind(command);
+    command.parseOptions = (argv) => parseOptions(releasePathShapedValues(argv, requiredValueFlags));
+}
 /**
  * Registers the shared `--wait-lock [seconds]` flag on a lock-taking
  * command (the engine session lock for engine-mutating commands, the patch

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

@@ -0,0 +1,15 @@
+/**
+ * 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

@@ -0,0 +1,47 @@
+// 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/regex.d.ts

@@ -16,11 +16,23 @@ export declare function hasRawCssColors(content: string): boolean;
  * implementation does not model them, so two adjacent slashes inside a regex
  * (the tail of `/https?:\/\//`) read as a `//` line comment and the rest of
  * the line is blanked, corrupting whatever lint pass consumes the stripped
- * text. Firefox chrome sources contain preprocessor directives (`#ifdef`)
- * and other constructs acorn cannot tokenize. Those fall back to the legacy
- * regex strip, which handles strings but not regex literals.
+ * text. The source is tokenized as a module, then as a script. Firefox
+ * chrome sources can contain constructs acorn tokenizes under neither goal.
+ * Those fall back to the legacy regex strip, which handles strings but not
+ * regex literals.
  */
 export declare function stripJsComments(source: string): string;
+/**
+ * The tokenizer half of {@link stripJsComments}: the stripped source, or
+ * `null` when acorn can tokenize it neither as a module nor as a script.
+ *
+ * Module first, then script, because chrome subscripts are scripts: a
+ * legacy octal escape is a tokenizer error only under the module goal.
+ * Callers that must not under-count when tokenizing fails (the code-line
+ * size metric) read the `null` and pick their own fallback rather than the
+ * legacy regex strip, which can blank code.
+ */
+export declare function stripJsCommentsParsed(source: string): string | null;
 /**
  * Counts the total number of raw CSS color values (hex, rgb, hsl) in content.
  */

package/dist/src/utils/regex.js

@@ -32,16 +32,47 @@ export function hasRawCssColors(content) {
  * implementation does not model them, so two adjacent slashes inside a regex
  * (the tail of `/https?:\/\//`) read as a `//` line comment and the rest of
  * the line is blanked, corrupting whatever lint pass consumes the stripped
- * text. Firefox chrome sources contain preprocessor directives (`#ifdef`)
- * and other constructs acorn cannot tokenize. Those fall back to the legacy
- * regex strip, which handles strings but not regex literals.
+ * text. The source is tokenized as a module, then as a script. Firefox
+ * chrome sources can contain constructs acorn tokenizes under neither goal.
+ * Those fall back to the legacy regex strip, which handles strings but not
+ * regex literals.
  */
 export function stripJsComments(source) {
+    return stripJsCommentsParsed(source) ?? stripJsCommentsLegacy(source);
+}
+/**
+ * The tokenizer half of {@link stripJsComments}: the stripped source, or
+ * `null` when acorn can tokenize it neither as a module nor as a script.
+ *
+ * Module first, then script, because chrome subscripts are scripts: a
+ * legacy octal escape is a tokenizer error only under the module goal.
+ * Callers that must not under-count when tokenizing fails (the code-line
+ * size metric) read the `null` and pick their own fallback rather than the
+ * legacy regex strip, which can blank code.
+ */
+export function stripJsCommentsParsed(source) {
+    const comments = collectJsComments(source, 'module') ?? collectJsComments(source, 'script');
+    if (comments === null)
+        return null;
+    if (comments.length === 0)
+        return source;
+    const chars = source.split('');
+    for (const { start, end } of comments) {
+        for (let i = start; i < end; i++) {
+            if (chars[i] !== '\n' && chars[i] !== '\r') {
+                chars[i] = ' ';
+            }
+        }
+    }
+    return chars.join('');
+}
+/** Comment ranges of `source` under one parse goal, or `null` on a tokenizer error. */
+function collectJsComments(source, sourceType) {
     const comments = [];
     try {
         const t = acornTokenizer(source, {
             ecmaVersion: 'latest',
-            sourceType: 'module',
+            sourceType,
             allowHashBang: true,
             onComment: (_isBlock, _text, start, end) => {
                 comments.push({ start, end });
@@ -55,19 +86,9 @@ export function stripJsComments(source) {
         }
     }
     catch {
-        return stripJsCommentsLegacy(source);
+        return null;
     }
-    if (comments.length === 0)
-        return source;
-    const chars = source.split('');
-    for (const { start, end } of comments) {
-        for (let i = start; i < end; i++) {
-            if (chars[i] !== '\n' && chars[i] !== '\r') {
-                chars[i] = ' ';
-            }
-        }
-    }
-    return chars.join('');
+    return comments;
 }
 /**
  * Legacy pure-regex comment strip, used only when acorn cannot tokenize