@hominis/fireforge 0.30.0 → 0.31.0

package/dist/src/core/token-manager.js

@@ -69,39 +69,54 @@ function validateDarkValue(options) {
         throw new InvalidArgumentError('Override mode requires --dark-value to be specified.', 'darkValue');
     }
 }
-async function assertTokenCategoryExists(engineDir, tokensCssPath, category) {
-    const filePath = join(engineDir, tokensCssPath);
-    if (!(await pathExists(filePath))) {
-        throw new GeneralError(`Token CSS file not found: ${tokensCssPath}`);
-    }
-    const content = await readText(filePath);
-    const lines = content.split('\n');
+/**
+ * True when `lines` contain a category header (single-line or multi-line
+ * banner shape) naming `category`. Shared by the pre-add assertion and the
+ * in-memory banner creation path so both agree on what "exists" means.
+ */
+function categoryHeaderExists(lines, category) {
     const escapedCategory = escapeRegex(category);
     const singleLinePattern = new RegExp(`\\/\\*\\s*=.*${escapedCategory}.*=\\s*\\*\\/`);
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i] ?? '';
         if (singleLinePattern.test(line)) {
-            return;
+            return true;
         }
         if (/^\s*\/\*\s*=+/.test(line) && !/\*\//.test(line)) {
             for (let j = i + 1; j < Math.min(i + 6, lines.length); j++) {
                 const blockLine = lines[j] ?? '';
                 if (new RegExp(escapedCategory).test(blockLine)) {
-                    return;
+                    return true;
                 }
                 if (/\*\//.test(blockLine))
                     break;
             }
         }
     }
+    return false;
+}
+async function assertTokenCategoryExists(engineDir, tokensCssPath, category, createCategory = false) {
+    const filePath = join(engineDir, tokensCssPath);
+    if (!(await pathExists(filePath))) {
+        throw new GeneralError(`Token CSS file not found: ${tokensCssPath}`);
+    }
+    const content = await readText(filePath);
+    const lines = content.split('\n');
+    if (categoryHeaderExists(lines, category))
+        return;
+    // The write path declares the banner in the same edit as the token
+    // insertion, so a missing category is fine when creation was requested.
+    if (createCategory)
+        return;
     const discoveredCategories = discoverCategoryHeaders(lines);
     const available = discoveredCategories.length > 0
         ? `Available categories in the file: ${discoveredCategories.map((name) => `"${name}"`).join(', ')}.`
-        : 'The file currently has no category headers. Add one by hand near the top of the :root { … } block — the format is "/* = My Category = */" — or run "fireforge furnace init --force" to re-scaffold the default seed set.';
+        : 'The file currently has no category headers.';
     throw new GeneralError(`Category "${category}" not found in ${tokensCssPath}.\n\n` +
         `${available}\n\n` +
         'Categories are declared by comment headers. Single-line shape: /* = My Category = */. ' +
-        'Multi-line shape: /* =============\\n * My Category\\n * ============= */.');
+        'Multi-line shape: /* =============\\n * My Category\\n * ============= */.\n\n' +
+        'Re-run with --create-category to declare the banner and insert the token in one step.');
 }
 /**
  * Scans a tokens CSS file for category header comments and returns the
@@ -156,7 +171,7 @@ export async function validateTokenAdd(root, options) {
     validateTokenNameSyntax(options.tokenName);
     await validateTokenPrefix(root, options);
     validateDarkValue(options);
-    await assertTokenCategoryExists(engineDir, tokensCssPath, options.category);
+    await assertTokenCategoryExists(engineDir, tokensCssPath, options.category, options.createCategory === true);
 }
 /**
  * Adds a design token to the CSS file and documentation.
@@ -185,7 +200,7 @@ export async function addToken(root, options) {
         };
     }
     // --- CSS file ---
-    const cssAdded = await addTokenToCSS(engineDir, options, tokensCssPath);
+    const { added: cssAdded, categoryCreated } = await addTokenToCSS(engineDir, options, tokensCssPath);
     if (!cssAdded) {
         return {
             cssAdded: false,
@@ -203,8 +218,39 @@ export async function addToken(root, options) {
         unmappedAdded: docsResult.unmappedAdded,
         countUpdated: docsResult.countUpdated,
         skipped: false,
+        categoryCreated,
     };
 }
+/**
+ * Splices a new single-line category banner ("= Name =" comment shape, the
+ * same format `discoverCategoryHeaders` recognises) just before the closing
+ * brace of the `:root` block, making the new category the last section.
+ * Mutates `lines` in place.
+ */
+function declareCategoryBanner(lines, category, tokensCssPath) {
+    let rootOpen = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (/:root\s*\{/.test(lines[i] ?? '')) {
+            rootOpen = i;
+            break;
+        }
+    }
+    if (rootOpen === -1) {
+        throw new GeneralError(`Cannot create category "${category}": no :root block found in ${tokensCssPath}. ` +
+            'Run "fireforge furnace init --force" to re-scaffold the tokens CSS file.');
+    }
+    let rootClose = -1;
+    for (let i = rootOpen + 1; i < lines.length; i++) {
+        if (/^\s*\}/.test(lines[i] ?? '')) {
+            rootClose = i;
+            break;
+        }
+    }
+    if (rootClose === -1) {
+        throw new GeneralError(`Cannot create category "${category}": the :root block in ${tokensCssPath} never closes.`);
+    }
+    lines.splice(rootClose, 0, '', `  /* = ${category} = */`);
+}
 function findCategorySection(lines, category, tokensCssPath) {
     const escapedCategory = escapeRegex(category);
     const singleLinePattern = new RegExp(`\\/\\*\\s*=.*${escapedCategory}.*=\\s*\\*\\/`);
@@ -296,15 +342,23 @@ function insertDarkModeOverride(lines, options) {
  */
 async function addTokenToCSS(engineDir, options, tokensCssPath) {
     const filePath = join(engineDir, tokensCssPath);
-    await assertTokenCategoryExists(engineDir, tokensCssPath, options.category);
+    await assertTokenCategoryExists(engineDir, tokensCssPath, options.category, options.createCategory === true);
     let content = await readText(filePath);
     // Idempotency check — strip CSS block comments so we don't match inside them
     const stripped = content.replace(/\/\*[\s\S]*?\*\//g, '');
     if (stripped.includes(options.tokenName + ':')) {
-        return false;
+        return { added: false, categoryCreated: false };
     }
     const lines = content.split('\n');
     const annotation = getModeAnnotation(options.mode, options.value);
+    // Declare a missing category banner in the same in-memory edit as the
+    // token insertion — the file is written exactly once, so a failure
+    // between "banner declared" and "token inserted" cannot occur.
+    let categoryCreated = false;
+    if (options.createCategory === true && !categoryHeaderExists(lines, options.category)) {
+        declareCategoryBanner(lines, options.category, tokensCssPath);
+        categoryCreated = true;
+    }
     const { categoryLine, sectionEnd } = findCategorySection(lines, options.category, tokensCssPath);
     // Build the insertion lines
     const insertLines = [];
@@ -325,7 +379,7 @@ async function addTokenToCSS(engineDir, options, tokensCssPath) {
     insertDarkModeOverride(lines, options);
     content = lines.join('\n');
     await writeText(filePath, content);
-    return true;
+    return { added: true, categoryCreated };
 }
 /**
  * Strips surrounding backticks from a cell, if present. Token cells are

package/dist/src/core/typecheck-shim.d.ts

@@ -11,27 +11,6 @@
  */
 /** Filename used for the synthetic Firefox-globals shim source file. */
 export declare const SHIM_FILENAME = "__fireforge_firefox_globals.d.ts";
-/**
- * Minimal `.d.ts` shim for Firefox privileged-scope globals.
- *
- * Firefox source is plain JS — no TypeScript allowed. The shim lets
- * TS-driven type checking run without reporting "cannot find name"
- * for the most common Mozilla APIs. Types are intentionally loose
- * (`any`) because full Firefox type coverage is out of scope.
- *
- * Notable patterns that require shimming:
- * - `const lazy = {};` + `ChromeUtils.defineESModuleGetters(lazy, { ... })`
- *   populates `lazy` at runtime; we declare it as `Record<string, any>`.
- * - `Services.obs`, `Services.prefs`, etc. are XPCOM service accessors.
- * - `Ci`, `Cc`, `Cr`, `Cu` are XPCOM component shortcuts.
- * - Browser chrome globals like `gBrowser`, `gURLBar` are common in
- *   content scripts wired via `browser.js`.
- * - Dynamic `import("resource:-…")` / `import("chrome:-…")` under patch
- *   checkJs: the compiler sees empty stubs (`noResolve`); without URL
- *   ambient modules namespaces degrade to unusable typings. Wildcards
- *   keep Firefox URL imports pragmatically loose, same posture as globals.
- */
-export declare const FIREFOX_GLOBALS_SHIM = "\ndeclare var Services: any;\ndeclare var ChromeUtils: {\n  defineESModuleGetters(target: any, modules: Record<string, string>): void;\n  importESModule(specifier: string): any;\n  import(specifier: string): any;\n  defineModuleGetter(target: any, name: string, specifier: string): void;\n  generateQI(interfaces: any[]): Function;\n  isClassInfo(obj: any): boolean;\n};\ndeclare var Cu: any;\ndeclare var Ci: any;\ndeclare var Cc: any;\ndeclare var Cr: any;\ndeclare var Components: any;\ndeclare var XPCOMUtils: any;\ndeclare var lazy: Record<string, any>;\ndeclare var PathUtils: any;\ndeclare var IOUtils: any;\ndeclare var FileUtils: any;\ndeclare var gBrowser: any;\ndeclare var gURLBar: any;\ndeclare var gNavigatorBundle: any;\ndeclare var AppConstants: any;\n\n// Shorthand ambient modules \u2014 exports from matching URL imports are loosely typed,\n// avoiding noResolve empty-graph namespaces. (Named member access broke when we tried\n// export= Record under moduleResolution Bundler.)\ndeclare module 'resource:*';\ndeclare module 'chrome:*';\n\n";
 /**
  * TS diagnostic codes suppressed by both the patch-lint checkJs pass
  * and the whole-project typecheck command. Each is a known false

package/dist/src/core/typecheck-shim.js

@@ -30,18 +30,21 @@ export const SHIM_FILENAME = '__fireforge_firefox_globals.d.ts';
  * - Browser chrome globals like `gBrowser`, `gURLBar` are common in
  *   content scripts wired via `browser.js`.
  * - Dynamic `import("resource:-…")` / `import("chrome:-…")` under patch
- *   checkJs: the compiler sees empty stubs (`noResolve`); without URL
- *   ambient modules namespaces degrade to unusable typings. Wildcards
- *   keep Firefox URL imports pragmatically loose, same posture as globals.
+ *   checkJs: imports of *patch-owned* modules resolve to their real
+ *   sources (see `patch-lint-checkjs.ts`); everything else fails host
+ *   resolution and lands on these URL ambient wildcards, keeping
+ *   upstream Firefox imports pragmatically loose, same posture as globals.
  */
-export const FIREFOX_GLOBALS_SHIM = `
+const FIREFOX_GLOBALS_SHIM = `
 declare var Services: any;
 declare var ChromeUtils: {
   defineESModuleGetters(target: any, modules: Record<string, string>): void;
   importESModule(specifier: string): any;
   import(specifier: string): any;
   defineModuleGetter(target: any, name: string, specifier: string): void;
+  defineLazyGetter(target: any, name: string, getter: () => any): void;
   generateQI(interfaces: any[]): Function;
+  getClassName(obj: any, unwrap?: boolean): string;
   isClassInfo(obj: any): boolean;
 };
 declare var Cu: any;
@@ -58,6 +61,25 @@ declare var gBrowser: any;
 declare var gURLBar: any;
 declare var gNavigatorBundle: any;
 declare var AppConstants: any;
+// Fluent localization — a stable chrome global. Members stay loose (any),
+// but the constructor shape is declared so "new Localization([...])" and
+// "new Localization([...], true)" typecheck without a local cast.
+declare var Localization: {
+  new (
+    resourceIds: Array<string | { path: string; optional?: boolean }>,
+    sync?: boolean
+  ): {
+    formatValue(id: string, args?: Record<string, unknown>): any;
+    formatValues(keys: any[]): any;
+    formatMessages(keys: any[]): any;
+    formatValueSync(id: string, args?: Record<string, unknown>): any;
+    formatValuesSync(keys: any[]): any;
+    formatMessagesSync(keys: any[]): any;
+    addResourceIds(ids: Array<string | { path: string; optional?: boolean }>): void;
+    removeResourceIds(ids: string[]): number;
+    setAsync(): void;
+  };
+};
 
 // Shorthand ambient modules — exports from matching URL imports are loosely typed,
 // avoiding noResolve empty-graph namespaces. (Named member access broke when we tried

package/dist/src/core/wire-utils.js

@@ -60,9 +60,7 @@ export function coerceToCall(expression) {
  */
 export function countBraceDepth(line, inBlockComment) {
     let depth = 0;
-    let inSingle = false;
-    let inDouble = false;
-    let inTemplate = false;
+    let quote = null;
     let inLine = false;
     let inBlock = inBlockComment;
     for (let i = 0; i < line.length; i++) {
@@ -77,23 +75,13 @@ export function countBraceDepth(line, inBlockComment) {
             }
             continue;
         }
-        if (ch === '\\' && (inSingle || inDouble || inTemplate)) {
+        if (ch === '\\' && quote !== null) {
             i++;
             continue;
         }
-        if (inSingle) {
-            if (ch === "'")
-                inSingle = false;
-            continue;
-        }
-        if (inDouble) {
-            if (ch === '"')
-                inDouble = false;
-            continue;
-        }
-        if (inTemplate) {
-            if (ch === '`')
-                inTemplate = false;
+        if (quote !== null) {
+            if (ch === quote)
+                quote = null;
             continue;
         }
         if (ch === '/' && next === '/') {
@@ -105,35 +93,12 @@ export function countBraceDepth(line, inBlockComment) {
             i++;
             continue;
         }
-        // Heuristic for regex literals: if / follows an operator or keyword boundary,
-        // treat it as a regex start and skip to the closing /
-        if (ch === '/' && next !== undefined) {
-            const prev = i > 0 ? line[i - 1] : undefined;
-            if (prev === undefined || /[=(:,!|&?;~^{[\n+\-*%<>]/.test(prev)) {
-                // Skip to closing /
-                i++;
-                while (i < line.length) {
-                    if (line[i] === '\\') {
-                        i++; // skip escaped character
-                    }
-                    else if (line[i] === '/') {
-                        break;
-                    }
-                    i++;
-                }
-                continue;
-            }
-        }
-        if (ch === "'") {
-            inSingle = true;
-            continue;
-        }
-        if (ch === '"') {
-            inDouble = true;
+        if (ch === '/' && next !== undefined && isRegexLiteralStart(line, i)) {
+            i = scanToRegexLiteralEnd(line, i);
             continue;
         }
-        if (ch === '`') {
-            inTemplate = true;
+        if (ch === "'" || ch === '"' || ch === '`') {
+            quote = ch;
             continue;
         }
         if (ch === '{')
@@ -143,6 +108,34 @@ export function countBraceDepth(line, inBlockComment) {
     }
     return { depth, inBlockComment: inBlock };
 }
+/**
+ * Regex-literal opener heuristic for the fallback scanner: a `/` is
+ * treated as starting a regex when it follows an operator or
+ * keyword-boundary character (or starts the line). See the misfire notes
+ * on {@link countBraceDepth}.
+ */
+function isRegexLiteralStart(line, i) {
+    const prev = i > 0 ? line[i - 1] : undefined;
+    return prev === undefined || /[=(:,!|&?;~^{[\n+\-*%<>]/.test(prev);
+}
+/**
+ * Scans from the opening `/` of a regex literal to its closing `/`
+ * (honouring escapes), returning the index of the closing slash — or the
+ * end of the line when the literal never closes.
+ */
+function scanToRegexLiteralEnd(line, start) {
+    let i = start + 1;
+    while (i < line.length) {
+        if (line[i] === '\\') {
+            i++; // skip escaped character
+        }
+        else if (line[i] === '/') {
+            break;
+        }
+        i++;
+    }
+    return i;
+}
 /**
  * Extracts the class/object name from an expression like "MyComponent.init()".
  */

package/dist/src/types/commands/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * Re-exports all command-related types from focused sub-modules.
  */
-export type { BuildOptions, DiscardOptions, DoctorOptions, DownloadOptions, ExportOptions, FurnaceApplyOptions, FurnaceCreateOptions, FurnaceDeployOptions, FurnaceOverrideOptions, FurnacePreviewOptions, FurnaceRefreshOptions, FurnaceRemoveOptions, FurnaceSyncOptions, FurnaceValidateOptions, GlobalOptions, ImportOptions, PackageOptions, PatchCompactOptions, PatchDeleteOptions, PatchLintIgnoreOptions, PatchMoveFilesOptions, PatchRenameOptions, PatchReorderOptions, PatchStagedDependencyOptions, PatchTierOptions, RebaseOptions, ReExportOptions, RegisterOptions, ResetOptions, RunOptions, SetupOptions, SourceSetOptions, StatusOptions, TestOptions, TokenAddOptions, WireOptions, } from './options.js';
+export type { BuildOptions, DiscardOptions, DoctorOptions, DownloadOptions, ExportOptions, FurnaceApplyOptions, FurnaceCreateOptions, FurnaceDeployOptions, FurnaceOverrideOptions, FurnacePreviewOptions, FurnaceRefreshOptions, FurnaceRemoveOptions, FurnaceSyncOptions, FurnaceValidateOptions, GlobalOptions, ImportOptions, LintCommandOptions, PackageOptions, PatchCompactOptions, PatchDeleteOptions, PatchLintIgnoreOptions, PatchMoveFilesOptions, PatchRenameOptions, PatchReorderOptions, PatchSplitOptions, PatchStagedDependencyOptions, PatchTierOptions, RebaseOptions, ReExportOptions, RegisterOptions, ResetOptions, RunOptions, SetupOptions, SourceSetOptions, StatusOptions, TestOptions, TokenAddOptions, WireOptions, } from './options.js';
 export type { ImportSummary, PatchCategory, PatchesManifest, PatchInfo, PatchLintIssue, PatchMetadata, PatchResult, PatchStagedDependencies, PatchStagedForwardImport, } from './patches.js';
 export type { DoctorCheck, ProjectStatus, TokenCoverageFileEntry, TokenCoverageReport, } from './project.js';

package/dist/src/types/commands/options.d.ts

@@ -304,6 +304,33 @@ export interface PatchStagedDependencyOptions {
  * It validates an ownership transfer and prints the explicit
  * `re-export --files` commands needed to perform it.
  */
+/**
+ * Options for the `patch split` command.
+ */
+export interface PatchSplitOptions {
+    /** Files to move out of the source patch (engine-relative). */
+    files: string[];
+    /** Name for the new patch (used in its filename slug). */
+    name: string;
+    /** Category for the new patch; defaults to the source patch's category. */
+    category?: string;
+    /** Description for the new patch. */
+    description?: string;
+    /** Exact sparse order for the new patch (mutually exclusive with before/after). */
+    order?: number;
+    /** Place the new patch before this patch identifier. */
+    before?: string;
+    /** Place the new patch after this patch identifier (default: the source). */
+    after?: string;
+    /** Preview without writing. */
+    dryRun?: boolean;
+    /** Skip interactive confirmation (required for non-TTY). */
+    yes?: boolean;
+    /** Bypass projected-lint refusals. */
+    forceUnsafe?: boolean;
+    /** Skip per-patch lint of the projected bodies. */
+    skipLint?: boolean;
+}
 export interface PatchMoveFilesOptions {
     /** File paths relative to engine/ to move from the source patch to the target patch. */
     file?: string[];
@@ -394,6 +421,25 @@ export interface TestOptions {
      * stale process holds the default port or CI uses another port.
      */
     marionettePort?: number;
+    /**
+     * Retry budget for recognized harness crashes (resource-monitor
+     * tracebacks, pre-test no-output hangs, post-green shutdown re-entry).
+     * 0 disables retries. Defaults to {@link DEFAULT_HARNESS_RETRIES} at the
+     * command layer.
+     */
+    harnessRetries?: number;
+    /**
+     * Commander negation flag for `--no-shard`. When false, multiple test
+     * paths run in one combined mach invocation; by default they shard into
+     * sequential single-file harness runs with an aggregate report.
+     */
+    shard?: boolean;
+    /**
+     * Project-relative (or absolute) artifact path published to the harness
+     * run as `<BINARYNAME>_PERF_SAMPLE_JSON`, for downstream perf-budget
+     * checkers that consume a sample artifact after the run.
+     */
+    perfSamples?: string;
 }
 /**
  * Options for the furnace apply command.
@@ -648,6 +694,8 @@ export interface TokenAddOptions {
     description?: string;
     darkValue?: string;
     dryRun?: boolean;
+    /** Declare the category banner in the tokens CSS when it does not exist yet. */
+    createCategory?: boolean;
 }
 /**
  * Options for the doctor command.
@@ -681,3 +729,60 @@ export interface GlobalOptions {
     /** Enable verbose/debug output */
     verbose?: boolean;
 }
+/** Options controlling how the lint command filters and tags its output. */
+export interface LintCommandOptions {
+    /**
+     * When set, tag each issue as `introduced` or `cumulative` based on
+     * whether its file changed since this git revision (e.g. `HEAD`, a
+     * branch name, or a SHA). Issues are not filtered — the full set still
+     * prints — but a diff-scoped summary makes it trivial to see which
+     * errors the current task introduced.
+     */
+    since?: string;
+    /**
+     * When set together with {@link since}, scope the exit code to issues
+     * tagged `introduced`. Cumulative pre-existing errors still print (so
+     * the operator can still see the full queue state) but do not fail
+     * lint. Motivating case: a branch whose diff is clean but whose repo
+     * already carries unrelated `raw-color` / license-header errors from
+     * older patches. Without this flag, CI treats the clean branch as
+     * failing; with it, a branch "breaks the build" only when its own diff
+     * introduced a new error.
+     *
+     * Requires {@link since}: without a revision to diff against there is
+     * no distinction between introduced and cumulative, so the flag is
+     * rejected up-front rather than silently ignored.
+     */
+    onlyIntroduced?: boolean;
+    /**
+     * Lint each patch in the queue as its own isolated diff, rather than
+     * the aggregate `git diff HEAD` across all applied patches.
+     *
+     * Motivating case: running `fireforge lint` (no args) on a repo where
+     * `fireforge import` or `fireforge rebase` has just applied the full
+     * patch queue produces an aggregate diff (every patch's changes
+     * summed). The patch-size advisory rules (`large-patch-lines`,
+     * `large-patch-files`) then fire against the sum — e.g. "Patch is
+     * 37529 lines" on a queue of 22 individually-fine patches — which
+     * reads as a task-specific regression when it is really an artefact
+     * of the aggregation. `--per-patch` rescopes the diff to each patch's
+     * own `filesAffected`, honours the patch's own `lintIgnore`, and runs
+     * the cross-patch rules once over the whole queue so queue-level
+     * findings (duplicate creations, forward imports) still surface.
+     *
+     * Mutually exclusive with passing explicit file paths — the two
+     * scope contracts are different.
+     */
+    perPatch?: boolean;
+    /**
+     * Maximum warning count tolerated before lint exits non-zero. Mirrors
+     * ESLint's `--max-warnings` shape for release gates that want advisory
+     * findings to become blocking without changing default CLI behavior.
+     */
+    maxWarnings?: number;
+    /**
+     * Bypass per-patch lint cache reads and writes. Accepted in aggregate mode
+     * for CLI consistency, but only `--per-patch` currently uses the cache.
+     */
+    noCache?: boolean;
+}

package/dist/src/types/furnace.d.ts

@@ -140,6 +140,15 @@ export interface FurnaceConfig {
      * Always includes `toolkit/content/widgets` by default.
      */
     scanPaths?: string[];
+    /**
+     * Project-relative path to a consumer-owned jsconfig/tsconfig whose
+     * `compilerOptions.paths` entries for deployed component modules
+     * (`chrome://global/content/elements/<file>.mjs`) Furnace keeps in sync
+     * on deploy. Only entries under that chrome prefix that map into
+     * `components/custom/` are managed; everything else is preserved.
+     * Unset disables jsconfig maintenance.
+     */
+    typecheckJsconfig?: string;
     /** Stock components tracked for preview */
     stock: string[];
     /** Override components */
@@ -234,7 +243,7 @@ export interface ApplyResult {
  */
 export interface DryRunAction {
     component: string;
-    action: 'copy' | 'register-ce' | 'register-jar' | 'copy-ftl' | 'undeploy-remove' | 'undeploy-restore' | 'unregister-ce' | 'unregister-jar';
+    action: 'copy' | 'expand-fragments' | 'register-ce' | 'register-jar' | 'copy-ftl' | 'undeploy-remove' | 'undeploy-restore' | 'unregister-ce' | 'unregister-jar';
     source?: string;
     target?: string;
     description: string;
@@ -277,3 +286,5 @@ export interface ValidationIssue {
     /** Human-readable description of the issue */
     message: string;
 }
+/** Resolved test-harness selection for a `furnace create` run. */
+export type ResolvedTestStyle = 'mochikit' | 'browser-chrome' | 'xpcshell' | 'none';

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

@@ -1,4 +1,2 @@
-/** Formats elapsed milliseconds for progress messages. */
-export declare function formatElapsed(ms: number): string;
 /** Returns formatted elapsed time since a start timestamp from Date.now(). */
 export declare function elapsedSince(startedAt: number): string;

package/dist/src/utils/elapsed.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 /** Formats elapsed milliseconds for progress messages. */
-export function formatElapsed(ms) {
+function formatElapsed(ms) {
     const totalSeconds = Math.max(0, Math.round(ms / 1000));
     const minutes = Math.floor(totalSeconds / 60);
     const seconds = totalSeconds % 60;

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

@@ -13,11 +13,6 @@ export declare function pathExistsStrict(path: string): Promise<boolean>;
  * @param path - Directory path to ensure
  */
 export declare function ensureDir(path: string): Promise<void>;
-/**
- * Ensures the parent directory of a file exists.
- * @param filePath - Path to a file
- */
-export declare function ensureParentDir(filePath: string): Promise<void>;
 /**
  * Removes a directory recursively.
  * @param path - Directory path to remove

package/dist/src/utils/fs.js

@@ -52,7 +52,7 @@ export async function ensureDir(path) {
  * Ensures the parent directory of a file exists.
  * @param filePath - Path to a file
  */
-export async function ensureParentDir(filePath) {
+async function ensureParentDir(filePath) {
     const parent = dirname(filePath);
     await ensureDir(parent);
 }

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

@@ -2,12 +2,6 @@
  * Escapes special regex characters in a string.
  */
 export declare function escapeRegex(str: string): string;
-/** Matches hex color values like #fff, #ff00ff, #ff00ff80 (longest-first alternation) */
-export declare const CSS_HEX_COLOR: RegExp;
-/** Matches rgb() or rgba() function calls */
-export declare const CSS_RGB_COLOR: RegExp;
-/** Matches hsl() or hsla() function calls */
-export declare const CSS_HSL_COLOR: RegExp;
 /**
  * Returns true if the content contains any raw CSS color values (hex, rgb, hsl).
  */

package/dist/src/utils/regex.js

@@ -6,11 +6,11 @@ export function escapeRegex(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 /** Matches hex color values like #fff, #ff00ff, #ff00ff80 (longest-first alternation) */
-export const CSS_HEX_COLOR = /#(?:[0-9a-fA-F]{8}|[0-9a-fA-F]{6}|[0-9a-fA-F]{3,4})\b/;
+const CSS_HEX_COLOR = /#(?:[0-9a-fA-F]{8}|[0-9a-fA-F]{6}|[0-9a-fA-F]{3,4})\b/;
 /** Matches rgb() or rgba() function calls */
-export const CSS_RGB_COLOR = /\brgba?\s*\(/;
+const CSS_RGB_COLOR = /\brgba?\s*\(/;
 /** Matches hsl() or hsla() function calls */
-export const CSS_HSL_COLOR = /\bhsla?\s*\(/;
+const CSS_HSL_COLOR = /\bhsla?\s*\(/;
 // Global variants for counting (cached to avoid re-creation per call)
 const CSS_HEX_COLOR_G = new RegExp(CSS_HEX_COLOR.source, 'g');
 const CSS_RGB_COLOR_G = new RegExp(CSS_RGB_COLOR.source, 'g');

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

@@ -90,14 +90,6 @@ export declare const PATCH_CATEGORIES: readonly ["branding", "ui", "privacy", "s
  * Validates a patch category string.
  */
 export declare function isValidPatchCategory(category: string): category is (typeof PATCH_CATEGORIES)[number];
-/**
- * Checks whether a Firefox version string has an ESR suffix.
- */
-export declare function isEsrVersion(version: string): boolean;
-/**
- * Checks whether a Firefox version string is a beta version (e.g. "147.0b1").
- */
-export declare function isBetaVersion(version: string): boolean;
 /**
  * Infers the Firefox product type from a version string.
  * Returns undefined if no clear inference can be made.

package/dist/src/utils/validation.js

@@ -134,13 +134,13 @@ export function isValidPatchCategory(category) {
 /**
  * Checks whether a Firefox version string has an ESR suffix.
  */
-export function isEsrVersion(version) {
+function isEsrVersion(version) {
     return /esr$/i.test(version);
 }
 /**
  * Checks whether a Firefox version string is a beta version (e.g. "147.0b1").
  */
-export function isBetaVersion(version) {
+function isBetaVersion(version) {
     return /b\d+$/.test(version);
 }
 /**