@hominis/fireforge 0.50.0 → 0.51.0

package/dist/src/core/furnace-config-validate-exceptions.js

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
- * Validators for the two `furnace validate` policy fields of furnace.json:
- * `validationExceptions[]` and `optInChecks[]`.
+ * Validators for the `furnace validate` and `token lint` policy fields of
+ * furnace.json: `validationExceptions[]`, `optInChecks[]`, `minComponents`
+ * and `tokenSiblingSheets`.
  *
  * Strict on purpose, like `buildAudit.unpackaged`: every exception is a
  * standing suppression of a finding, so a malformed one must fail at load
@@ -10,7 +11,7 @@
 import { FurnaceError } from '../errors/furnace.js';
 import { FURNACE_OPT_IN_CHECKS, } from '../types/furnace.js';
 import { isArray, isObject, isString } from '../utils/validation.js';
-const EXCEPTION_KEYS = new Set(['component', 'check', 'reason']);
+const EXCEPTION_KEYS = new Set(['component', 'check', 'tag', 'reason']);
 function requireNonEmptyString(entry, key, field) {
     const value = entry[key];
     if (!isString(value) || value.trim().length === 0) {
@@ -19,9 +20,9 @@ function requireNonEmptyString(entry, key, field) {
     return value;
 }
 /**
- * Parses `validationExceptions[]`: `{ component, check, reason }` objects,
- * no other keys, every field a non-empty string, and no two entries for the
- * same component and check.
+ * Parses `validationExceptions[]`: `{ component, check, tag?, reason }`
+ * objects, no other keys, every field a non-empty string, and no two
+ * entries for the same component, check and tag.
  */
 export function parseValidationExceptions(raw) {
     if (!isArray(raw)) {
@@ -43,9 +44,12 @@ export function parseValidationExceptions(raw) {
             check: requireNonEmptyString(entry, 'check', field),
             reason: requireNonEmptyString(entry, 'reason', field),
         };
-        const identity = `${exception.component}\u0000${exception.check}`;
+        if (entry['tag'] !== undefined)
+            exception.tag = requireNonEmptyString(entry, 'tag', field);
+        const identity = `${exception.component}\u0000${exception.check}\u0000${exception.tag ?? ''}`;
         if (seen.has(identity)) {
-            throw new FurnaceError(`Furnace config: "${field}" repeats the exception for ${exception.component} [${exception.check}]`);
+            const on = exception.tag !== undefined ? ` on <${exception.tag}>` : '';
+            throw new FurnaceError(`Furnace config: "${field}" repeats the exception for ${exception.component} [${exception.check}]${on}`);
         }
         seen.add(identity);
         return exception;
@@ -54,6 +58,33 @@ export function parseValidationExceptions(raw) {
 function isOptInCheck(value) {
     return FURNACE_OPT_IN_CHECKS.includes(value);
 }
+/**
+ * Parses `tokenSiblingSheets`: an object from a sheet glob to a non-empty
+ * list of partner paths or globs.
+ */
+export function parseTokenSiblingSheets(raw) {
+    if (!isObject(raw)) {
+        throw new FurnaceError('Furnace config: "tokenSiblingSheets" must be an object');
+    }
+    const out = {};
+    for (const [pattern, partners] of Object.entries(raw)) {
+        const valid = isArray(partners) &&
+            partners.length > 0 &&
+            partners.every((partner) => isString(partner) && partner.trim() !== '');
+        if (pattern.includes('..') || !valid || partners.some((p) => String(p).includes('..'))) {
+            throw new FurnaceError(`Furnace config: "tokenSiblingSheets.${pattern}" must be a non-empty list of engine-relative paths or globs (no "..")`);
+        }
+        out[pattern] = partners;
+    }
+    return out;
+}
+/** Parses `minComponents`: a positive integer. */
+export function parseMinComponents(raw) {
+    if (typeof raw !== 'number' || !Number.isInteger(raw) || raw < 1) {
+        throw new FurnaceError('Furnace config: "minComponents" must be a positive integer');
+    }
+    return raw;
+}
 /** Parses `optInChecks[]`: names from {@link FURNACE_OPT_IN_CHECKS}. */
 export function parseOptInChecks(raw) {
     if (!isArray(raw)) {

package/dist/src/core/furnace-config-validate.js

@@ -8,7 +8,7 @@
 import { FurnaceError } from '../errors/furnace.js';
 import { isJsonObject, isString } from '../utils/validation.js';
 import { parseStringArray } from './furnace-config-array-utils.js';
-import { parseOptInChecks, parseValidationExceptions, } from './furnace-config-validate-exceptions.js';
+import { parseMinComponents, parseOptInChecks, parseTokenSiblingSheets, parseValidationExceptions, } from './furnace-config-validate-exceptions.js';
 /**
  * Validates an override component config object.
  * @param data - Raw data to validate
@@ -94,6 +94,9 @@ export function applyOptionalFurnaceFields(migrated, config) {
     if (migrated['platformPrefixes'] !== undefined) {
         config.platformPrefixes = parseStringArray(migrated['platformPrefixes'], 'platformPrefixes');
     }
+    if (migrated['tokenSiblingSheets'] !== undefined) {
+        config.tokenSiblingSheets = parseTokenSiblingSheets(migrated['tokenSiblingSheets']);
+    }
     if (migrated['runtimeVariables'] !== undefined) {
         config.runtimeVariables = parseStringArray(migrated['runtimeVariables'], 'runtimeVariables');
     }
@@ -137,4 +140,7 @@ export function applyOptionalFurnaceFields(migrated, config) {
     if (migrated['optInChecks'] !== undefined) {
         config.optInChecks = parseOptInChecks(migrated['optInChecks']);
     }
+    if (migrated['minComponents'] !== undefined) {
+        config.minComponents = parseMinComponents(migrated['minComponents']);
+    }
 }

package/dist/src/core/furnace-registration-jar-inplace.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Removes the lines registering `files` for `tagName`, leaving every other
+ * line of the block where it is. Returns how many lines were removed.
+ */
+export declare function removeJarMnFileEntries(engineDir: string, tagName: string, files: readonly string[]): Promise<number>;
+/**
+ * Rewrites `oldTag`'s lines in place as `newTag`'s. A line whose renamed
+ * file is in `liveFiles` keeps its position and layout; one whose file is
+ * gone is dropped. Returns the renamed files that already had a line; the
+ * caller's `addJarMnEntries` pass then inserts only the rest.
+ */
+export declare function renameJarMnEntriesInPlace(engineDir: string, oldTag: string, newTag: string, liveFiles: readonly string[], renameFile: (file: string) => string): Promise<string[]>;

package/dist/src/core/furnace-registration-jar-inplace.js

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * In-place edits to a widget's `toolkit/content/jar.mn` block.
+ *
+ * Undeploying one file and renaming a component used to drop every line of
+ * the widget and re-add the live ones, which re-sorted the whole block and
+ * left the owning patch carrying reorder hunks. These helpers touch only
+ * the lines that change: a deleted file's line goes, a renamed component's
+ * lines are rewritten where they stand, and anything still missing is left
+ * for `addJarMnEntries` to insert.
+ */
+import { join } from 'node:path';
+import { pathExists, readText, writeText } from '../utils/fs.js';
+import { escapeRegex } from '../utils/regex.js';
+import { JAR_MN } from './furnace-constants.js';
+/**
+ * The file a widget jar.mn line registers: the `(widgets/<tag>/<file>)`
+ * source mapping, or the legacy `content/global/elements/<tag>.<ext>`
+ * target written before the mapping existed. Undefined when the line is
+ * not one of this tag's.
+ */
+function registeredFile(line, tagName) {
+    const tag = escapeRegex(tagName);
+    const source = new RegExp(`\\(widgets/${tag}/([^)]+)\\)`).exec(line);
+    if (source)
+        return source[1];
+    const legacy = new RegExp(`content/global/elements/(${tag}\\.[^\\s]+)`).exec(line);
+    return legacy?.[1];
+}
+/**
+ * Removes the lines registering `files` for `tagName`, leaving every other
+ * line of the block where it is. Returns how many lines were removed.
+ */
+export async function removeJarMnFileEntries(engineDir, tagName, files) {
+    const filePath = join(engineDir, JAR_MN);
+    if (files.length === 0 || !(await pathExists(filePath)))
+        return 0;
+    const doomed = new Set(files);
+    const lines = (await readText(filePath)).split('\n');
+    const kept = lines.filter((line) => {
+        const file = registeredFile(line, tagName);
+        return file === undefined || !doomed.has(file);
+    });
+    const removed = lines.length - kept.length;
+    if (removed > 0)
+        await writeText(filePath, kept.join('\n'));
+    return removed;
+}
+/**
+ * Rewrites `oldTag`'s lines in place as `newTag`'s. A line whose renamed
+ * file is in `liveFiles` keeps its position and layout; one whose file is
+ * gone is dropped. Returns the renamed files that already had a line; the
+ * caller's `addJarMnEntries` pass then inserts only the rest.
+ */
+export async function renameJarMnEntriesInPlace(engineDir, oldTag, newTag, liveFiles, renameFile) {
+    const filePath = join(engineDir, JAR_MN);
+    if (!(await pathExists(filePath)))
+        return [];
+    const live = new Set(liveFiles);
+    const covered = [];
+    const out = [];
+    for (const line of (await readText(filePath)).split('\n')) {
+        const file = registeredFile(line, oldTag);
+        if (file === undefined) {
+            out.push(line);
+            continue;
+        }
+        const renamed = renameFile(file);
+        if (!live.has(renamed) || covered.includes(renamed))
+            continue;
+        // Textual substitution keeps the indent, column spacing and any
+        // trailing comment the line carried.
+        out.push(line
+            .replace(`content/global/elements/${file}`, `content/global/elements/${renamed}`)
+            .replace(`(widgets/${oldTag}/${file})`, `(widgets/${newTag}/${renamed})`));
+        covered.push(renamed);
+    }
+    await writeText(filePath, out.join('\n'));
+    return covered;
+}

package/dist/src/core/furnace-validate-accessibility.d.ts

@@ -1,7 +1,9 @@
 import type { CustomComponentConfig, FurnaceOptInCheck, ValidationIssue } from '../types/furnace.js';
 /**
- * Validates accessibility patterns in a component's .mjs file.
- * Checks for ARIA roles, keyboard handlers, l10n, and focus delegation.
+ * Validates accessibility patterns in a component's composed source: its
+ * host module and every companion module (see
+ * {@link readComposedComponentSource}). Checks for ARIA roles, keyboard
+ * handlers, l10n, and focus delegation.
  *
  * @param componentDir - Directory holding the component's sources
  * @param tagName - Custom element tag name, used to locate `<tagName>.mjs`

package/dist/src/core/furnace-validate-accessibility.js

@@ -1,12 +1,36 @@
 // SPDX-License-Identifier: EUPL-1.2
+import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { pathExists, readText } from '../utils/fs.js';
 import { createIssue } from './furnace-validate-helpers.js';
 import { countUnlabelledIconButtons } from './furnace-validate-icon-button.js';
 import { collectLitTemplateRegions, parseTemplateAttributes } from './lit-template-regions.js';
 /**
- * Validates accessibility patterns in a component's .mjs file.
- * Checks for ARIA roles, keyboard handlers, l10n, and focus delegation.
+ * Reads the composed component: `<tagName>.mjs` followed by its companion
+ * modules (`<tagName>-*.mjs`, tests and stories left out), so a template's
+ * findings do not depend on which of the component's modules it lives in.
+ * Returns undefined when the host module is missing.
+ */
+async function readComposedComponentSource(componentDir, tagName) {
+    const hostPath = join(componentDir, `${tagName}.mjs`);
+    if (!(await pathExists(hostPath)))
+        return undefined;
+    const entries = await readdir(componentDir).catch(() => []);
+    const companions = entries
+        .filter((name) => name.startsWith(`${tagName}-`) &&
+        name.endsWith('.mjs') &&
+        !/\.(test|spec|stories)\./.test(name))
+        .sort();
+    const sources = [await readText(hostPath)];
+    for (const name of companions)
+        sources.push(await readText(join(componentDir, name)));
+    return sources.join('\n');
+}
+/**
+ * Validates accessibility patterns in a component's composed source: its
+ * host module and every companion module (see
+ * {@link readComposedComponentSource}). Checks for ARIA roles, keyboard
+ * handlers, l10n, and focus delegation.
  *
  * @param componentDir - Directory holding the component's sources
  * @param tagName - Custom element tag name, used to locate `<tagName>.mjs`
@@ -20,10 +44,9 @@ import { collectLitTemplateRegions, parseTemplateAttributes } from './lit-templa
  *   adds the icon-only `<moz-button>` naming check.
  */
 export async function validateAccessibility(componentDir, tagName, customConfig, optInChecks = []) {
-    const mjsPath = join(componentDir, `${tagName}.mjs`);
-    if (!(await pathExists(mjsPath)))
+    const content = await readComposedComponentSource(componentDir, tagName);
+    if (content === undefined)
         return [];
-    const content = await readText(mjsPath);
     const issues = [];
     if (!hasAriaRole(content) && hasGenericInteractiveElement(content)) {
         issues.push(createIssue(tagName, 'warning', 'no-aria-role', 'Generic interactive markup has no native semantics. Prefer native elements, or add role= when native markup cannot provide the semantics.'));
@@ -41,10 +64,13 @@ export async function validateAccessibility(componentDir, tagName, customConfig,
     // activation flows through the inner element and a duplicate handler on
     // the wrapper would either no-op or fire twice alongside the child's
     // built-in keyboard path.
-    const hasClickOnSynthetic = hasTemplateClickOnSyntheticInteractive(content);
+    const syntheticTags = syntheticClickTags(content);
     const keyboardCovered = isKeyboardCoveredByComposition(customConfig);
-    if (hasClickOnSynthetic && !hasKeyboardHandler && !keyboardCovered) {
-        issues.push(createIssue(tagName, 'warning', 'no-keyboard-handler', 'Interactive element has @click but no keyboard event handler (@keydown/@keypress/@keyup).'));
+    if (syntheticTags.length > 0 && !hasKeyboardHandler && !keyboardCovered) {
+        issues.push({
+            ...createIssue(tagName, 'warning', 'no-keyboard-handler', `Interactive element has @click but no keyboard event handler (@keydown/@keypress/@keyup), on ${syntheticTags.map((tag) => `<${tag}>`).join(', ')}.`),
+            tags: syntheticTags,
+        });
     }
     if (containsHardcodedTemplateText(content)) {
         issues.push(createIssue(tagName, 'warning', 'hardcoded-text', 'Possible hardcoded string found. Use data-l10n-id for localization.'));
@@ -164,6 +190,9 @@ const NATIVE_CLICK_INTERACTIVE_TAGS = new Set([
     'moz-radio',
     'moz-radio-group',
     'moz-menulist',
+    // Toolkit's panel-list row renders a button that takes Enter and Space
+    // and dispatches click.
+    'panel-item',
 ]);
 /**
  * Returns true when `customConfig` declares that the component's keyboard
@@ -185,28 +214,33 @@ function isKeyboardCoveredByComposition(customConfig) {
     return composes.some((tag) => NATIVE_CLICK_INTERACTIVE_TAGS.has(tag));
 }
 /**
- * Returns true when `content` has at least one `@click=${...}` handler on a
- * *synthetic* interactive element (e.g. `<div @click>`), which lacks native
- * keyboard activation and therefore needs an explicit key handler for
- * Enter/Space. Returns false when every `@click` handler sits on a native
- * interactive element. Those already fire `click` on keyboard activation.
+ * Returns the tags (in first-seen order) of every *synthetic* interactive
+ * element carrying an `@click=${...}` handler (e.g. `<div @click>`), which
+ * lacks native keyboard activation and therefore needs an explicit key
+ * handler for Enter/Space. Empty when every `@click` handler sits on a
+ * native interactive element. Those already fire `click` on keyboard
+ * activation.
  */
-function hasTemplateClickOnSyntheticInteractive(content) {
+function syntheticClickTags(content) {
     const pattern = /@click\s*=\s*\$\{/g;
+    const tags = [];
     let match;
     while ((match = pattern.exec(content)) !== null) {
-        if (isClickOnSyntheticInteractive(content, match.index)) {
-            return true;
-        }
+        const tag = syntheticClickTag(content, match.index);
+        if (tag !== undefined && !tags.includes(tag))
+            tags.push(tag);
     }
-    return false;
+    return tags;
 }
+/** The tag a synthetic-element `@click` sits on, `?` when it cannot be told. */
+const UNKNOWN_TAG = '?';
 /**
  * Given the offset of an `@click=${...}` occurrence, walks backwards to find
- * the opening `<tag` that owns it and decides whether that tag is a native
- * interactive element (no warning needed) or a synthetic one (warning needed).
+ * the opening `<tag` that owns it and returns that tag when it is a
+ * synthetic interactive element (warning needed), or undefined when it is a
+ * native one (no warning needed).
  */
-function isClickOnSyntheticInteractive(content, clickIndex) {
+function syntheticClickTag(content, clickIndex) {
     // Find the nearest preceding `<` that starts a tag (skip `</` closers).
     let i = clickIndex - 1;
     let tagOpenIndex = -1;
@@ -219,15 +253,15 @@ function isClickOnSyntheticInteractive(content, clickIndex) {
         // which shouldn't happen for a well-formed template but we defensively
         // treat it as synthetic to preserve the prior-behaviour warning.
         if (content[i] === '>') {
-            return true;
+            return UNKNOWN_TAG;
         }
         i--;
     }
     if (tagOpenIndex < 0)
-        return true;
+        return UNKNOWN_TAG;
     const tagMatch = /^<([a-zA-Z][a-zA-Z0-9-]*)/.exec(content.slice(tagOpenIndex));
     if (!tagMatch?.[1])
-        return true;
+        return UNKNOWN_TAG;
     const tagName = tagMatch[1].toLowerCase();
     if (tagName === 'a') {
         // Bare <a> (no href) is non-interactive, so require a keyboard handler.
@@ -235,11 +269,11 @@ function isClickOnSyntheticInteractive(content, clickIndex) {
         // attribute text in between for an href attribute.
         const tagEnd = content.indexOf('>', tagOpenIndex);
         if (tagEnd < 0)
-            return true;
+            return 'a';
         const attrs = content.slice(tagOpenIndex, tagEnd);
-        return !/\shref\s*=/.test(attrs);
+        return /\shref\s*=/.test(attrs) ? undefined : 'a';
     }
-    return !NATIVE_CLICK_INTERACTIVE_TAGS.has(tagName);
+    return NATIVE_CLICK_INTERACTIVE_TAGS.has(tagName) ? undefined : tagName;
 }
 /** ASCII punctuation that reads as decoration rather than localizable text. */
 const SYMBOL_ONLY_ASCII = '+-*=<>|/\\^~@#&!?%';

package/dist/src/core/furnace-validate-exceptions.d.ts

@@ -1,14 +1,22 @@
 /**
  * Applies `furnace.json#validationExceptions[]` to a `furnace validate`
  * result. An exception suppresses every finding of its check on its
- * component. One that suppresses nothing is stale: the finding was fixed
- * (or renamed) and the review record outlived it, so it is reported as a
- * warning naming the entry to delete, which keeps the list honest under
- * `--max-warnings 0`.
+ * component, or with `tag`, a finding whose element tags it (and its
+ * sibling tag entries) cover. One that suppresses nothing is stale: the
+ * finding was fixed (or renamed) and the review record outlived it, so it
+ * is reported as a warning naming the entry to delete, which keeps the
+ * list honest under `--max-warnings 0`.
+ *
+ * An exception never suppresses an error: an error blocks apply, and a
+ * review record cannot make a broken component deployable. The error stays
+ * counted and the matching entry is reported as
+ * `validation-exception-on-error`.
  */
 import type { FurnaceValidationException, ValidationIssue } from '../types/furnace.js';
 /** The check name of the warning a stale exception produces. */
 export declare const STALE_VALIDATION_EXCEPTION_CHECK = "stale-validation-exception";
+/** The check name of the error an exception matching an error produces. */
+export declare const EXCEPTION_ON_ERROR_CHECK = "validation-exception-on-error";
 /** A finding an exception suppressed, with the exception's reason. */
 export interface ExceptedValidationIssue extends ValidationIssue {
     reason: string;

package/dist/src/core/furnace-validate-exceptions.js

@@ -1,9 +1,25 @@
 import { createIssue } from './furnace-validate-helpers.js';
 /** The check name of the warning a stale exception produces. */
 export const STALE_VALIDATION_EXCEPTION_CHECK = 'stale-validation-exception';
+/** The check name of the error an exception matching an error produces. */
+export const EXCEPTION_ON_ERROR_CHECK = 'validation-exception-on-error';
 function matches(exception, issue) {
     return exception.component === issue.component && exception.check === issue.check;
 }
+/**
+ * The exceptions that suppress a warning: an untagged one alone, or tagged
+ * ones that together cover every tag the finding names.
+ */
+function coveringExceptions(issue, candidates) {
+    const untagged = candidates.find((entry) => entry.tag === undefined);
+    if (untagged !== undefined)
+        return [untagged];
+    const tags = issue.tags ?? [];
+    if (tags.length === 0)
+        return [];
+    const covering = tags.map((tag) => candidates.find((entry) => entry.tag === tag));
+    return covering.every((entry) => entry !== undefined) ? [...new Set(covering)] : [];
+}
 /**
  * Splits findings into counted and excepted, and reports stale exceptions.
  *
@@ -18,14 +34,35 @@ export function applyValidationExceptions(issues, exceptions, judged) {
     const outcome = { issues: [], excepted: [], stale: [] };
     const list = exceptions ?? [];
     const used = new Set();
+    const onError = new Set();
     for (const issue of issues) {
-        const exception = list.find((entry) => matches(entry, issue));
-        if (exception === undefined) {
+        const candidates = list.filter((entry) => matches(entry, issue));
+        if (issue.severity === 'error') {
+            for (const entry of candidates) {
+                used.add(entry);
+                onError.add(entry);
+            }
             outcome.issues.push(issue);
             continue;
         }
-        used.add(exception);
-        outcome.excepted.push({ ...issue, reason: exception.reason });
+        const covering = coveringExceptions(issue, candidates);
+        if (covering.length === 0) {
+            // A tagged exception that covers some of the tags is not stale: its
+            // element still carries the finding, beside one it does not cover.
+            for (const entry of candidates) {
+                if (entry.tag !== undefined && issue.tags?.includes(entry.tag) === true)
+                    used.add(entry);
+            }
+            outcome.issues.push(issue);
+            continue;
+        }
+        for (const entry of covering)
+            used.add(entry);
+        outcome.excepted.push({ ...issue, reason: covering.map((entry) => entry.reason).join('; ') });
+    }
+    for (const exception of onError) {
+        outcome.issues.push(createIssue(exception.component, 'error', EXCEPTION_ON_ERROR_CHECK, `furnace.json validationExceptions entry for [${exception.check}] matches an error, ` +
+            'which an exception cannot suppress. Fix the error, then delete the entry.'));
     }
     for (const exception of list) {
         if (used.has(exception) || !judged(exception.component))

package/dist/src/core/furnace-validate-icon-button.js

@@ -18,10 +18,39 @@ import { collectLitTemplateRegions, parseTemplateAttributes } from './lit-templa
 const NAMING_ATTRIBUTES = ['data-l10n-id', 'aria-label', '.arialabel'];
 /** Attributes that give the button a visible label, so it is not icon-only. */
 const LABEL_ATTRIBUTES = ['label', '.label'];
+/**
+ * Whether the button's content has a non-blank character outside tags.
+ * Scans instead of stripping tags, so nested or unbalanced markup cannot
+ * leave a fragment behind that reads as text, and a `>` inside a quoted
+ * attribute value does not end its tag.
+ */
+function hasVisibleText(markup) {
+    let inTag = false;
+    let quote;
+    for (const char of markup) {
+        if (quote !== undefined) {
+            if (char === quote)
+                quote = undefined;
+        }
+        else if (inTag) {
+            if (char === '"' || char === "'")
+                quote = char;
+            else if (char === '>')
+                inTag = false;
+        }
+        else if (char === '<') {
+            inTag = true;
+        }
+        else if (char.trim() !== '') {
+            return true;
+        }
+    }
+    return false;
+}
 function isIconOnly(attrs, innerText) {
     if (LABEL_ATTRIBUTES.some((name) => attrs.has(name)))
         return false;
-    if (innerText.replace(/<[^>]*>/g, '').trim().length > 0)
+    if (hasVisibleText(innerText))
         return false;
     const type = attrs.get('type') ?? '';
     return attrs.has('iconsrc') || attrs.has('.iconsrc') || /(^|\s)icon(\s|$)/.test(type);

package/dist/src/core/history-log-file.js

@@ -17,7 +17,7 @@ import { randomUUID } from 'node:crypto';
 import { appendFile, link, readFile, rename, rm, stat } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 import { getNodeErrorCode, toError } from '../utils/errors.js';
-import { ensureDir } from '../utils/fs.js';
+import { ensureDir, pathExists } from '../utils/fs.js';
 import { info, verbose } from '../utils/logger.js';
 import { FIREFORGE_DIR } from './config-paths.js';
 import { isValidHistoryPath } from './config-validate-history.js';
@@ -131,6 +131,13 @@ export async function migrateLegacyHistoryLog(patchesDir, target) {
         await link(claimed, target);
     }
     catch (error) {
+        // Windows can report two racing renames of one file as both
+        // succeeding, the file ending under the other claimant's name. That
+        // claimant holds the records and moves them, so this one stands down.
+        if (getNodeErrorCode(error) === 'ENOENT' && !(await pathExists(claimed))) {
+            verbose('History log migration lost the claim to a concurrent command');
+            return;
+        }
         // EEXIST: both logs exist. Anything else (a filesystem without hard
         // links, a target on another device): the append below creates the
         // target when it is missing, so it covers that case too.

package/dist/src/core/line-prefixer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Prefixes every line of a chunked stream, for output from several
+ * concurrent harness instances (`fireforge test --jobs`) that share one
+ * terminal and one run log. Without a prefix, interleaved lines from two
+ * browsers cannot be attributed after the fact.
+ */
+/** A stateful line prefixer for one stream. */
+export interface LinePrefixer {
+    /** Returns `chunk` with the prefix inserted at the start of each line. */
+    transform(chunk: string): string;
+}
+/**
+ * Creates a prefixer. Line state carries across chunks, so a line split
+ * between two chunks gets the prefix exactly once.
+ *
+ * @param prefix - Text to insert, e.g. `[job 2] `
+ */
+export declare function createLinePrefixer(prefix: string): LinePrefixer;

package/dist/src/core/line-prefixer.js

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Prefixes every line of a chunked stream, for output from several
+ * concurrent harness instances (`fireforge test --jobs`) that share one
+ * terminal and one run log. Without a prefix, interleaved lines from two
+ * browsers cannot be attributed after the fact.
+ */
+/**
+ * Creates a prefixer. Line state carries across chunks, so a line split
+ * between two chunks gets the prefix exactly once.
+ *
+ * @param prefix - Text to insert, e.g. `[job 2] `
+ */
+export function createLinePrefixer(prefix) {
+    let atLineStart = true;
+    return {
+        transform(chunk) {
+            if (chunk.length === 0)
+                return chunk;
+            let out = '';
+            let start = 0;
+            for (let index = chunk.indexOf('\n'); index !== -1; index = chunk.indexOf('\n', start)) {
+                out += `${atLineStart ? prefix : ''}${chunk.slice(start, index + 1)}`;
+                atLineStart = true;
+                start = index + 1;
+            }
+            if (start < chunk.length) {
+                out += `${atLineStart ? prefix : ''}${chunk.slice(start)}`;
+                atLineStart = false;
+            }
+            return out;
+        },
+    };
+}

package/dist/src/core/mach.d.ts

@@ -47,6 +47,11 @@ export interface MachOptions {
     onProcessGroup?: (pgid: number) => void;
     /** Exec-layer hook, see {@link ProcessGroupOptions.postCloseSweep}. Capture-only. */
     postCloseSweep?: () => Promise<void>;
+    /**
+     * Prefix for every echoed and logged line (concurrent `test --jobs`
+     * instances). The capture and `onOutputChunk` stay raw. Capture-only.
+     */
+    outputPrefix?: string | undefined;
 }
 /**
  * Result of running a mach command while capturing streamed output.
@@ -263,6 +268,8 @@ export interface MachTestSuiteOptions {
      * the harness launched. See {@link MachOptions}.
      */
     teardown?: Pick<MachOptions, 'onOutputChunk' | 'onProcessGroup' | 'postCloseSweep'> | undefined;
+    /** Line prefix for echo and run log, see {@link MachOptions.outputPrefix}. */
+    outputPrefix?: string | undefined;
 }
 /**
  * Runs one mach test command (`mach test` / `mach xpcshell-test` / `mach