@hominis/fireforge 0.35.0 → 0.37.0

package/dist/src/core/xpcshell-appdir.js

@@ -41,6 +41,7 @@
 import { readdir, stat } from 'node:fs/promises';
 import { dirname, join, resolve, sep } from 'node:path';
 import { pathExists, readJson, readText } from '../utils/fs.js';
+import { escapeRegex } from '../utils/regex.js';
 import { isObject, isString } from '../utils/validation.js';
 /**
  * `[DEFAULT]` section parser shaped to the narrow case we need: pull a
@@ -88,9 +89,6 @@ export function parseAppdirFromToml(tomlText, key) {
     }
     return undefined;
 }
-function escapeRegex(input) {
-    return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
 function stripQuotes(raw) {
     if (raw.length === 0)
         return undefined;
@@ -305,4 +303,3 @@ export function operatorAlreadySetAppPath(extraArgs) {
     }
     return false;
 }
-//# sourceMappingURL=xpcshell-appdir.js.map

package/dist/src/errors/base.d.ts

@@ -54,6 +54,35 @@ export declare class InvalidArgumentError extends FireForgeError {
     constructor(message: string, argument?: string | undefined, cause?: Error);
     get userMessage(): string;
 }
+/**
+ * Error thrown when a spawned command exceeds its `timeout` option.
+ *
+ * Every `exec*` helper in `src/utils/process.ts` rejects with this type
+ * (instead of Node's bare `AbortError: The operation was aborted`) when the
+ * caller-supplied timeout fires. The bare AbortError bit an operator during
+ * the 2026-04-24 eval (see {@link GitIndexingTimeoutError} in errors/git.ts):
+ * an 854 s git indexing pass died with no command name, no elapsed time, and
+ * no hint that a timeout — not git — was responsible. The git path gained a
+ * site-local typed error then; this class extends the same courtesy to every
+ * other `timeout` caller.
+ */
+export declare class ExecTimeoutError extends FireForgeError {
+    /** Executable that was spawned (argv[0]). */
+    readonly command: string;
+    /** Arguments the executable was spawned with. */
+    readonly args: readonly string[];
+    /** Timeout that elapsed, in milliseconds. */
+    readonly timeoutMs: number;
+    readonly code: 1;
+    constructor(
+    /** Executable that was spawned (argv[0]). */
+    command: string, 
+    /** Arguments the executable was spawned with. */
+    args: readonly string[], 
+    /** Timeout that elapsed, in milliseconds. */
+    timeoutMs: number, cause?: unknown);
+    get userMessage(): string;
+}
 /**
  * Error thrown when the user cancels an interactive prompt.
  */

package/dist/src/errors/base.js

@@ -78,6 +78,41 @@ export class InvalidArgumentError extends FireForgeError {
         return msg;
     }
 }
+/**
+ * Error thrown when a spawned command exceeds its `timeout` option.
+ *
+ * Every `exec*` helper in `src/utils/process.ts` rejects with this type
+ * (instead of Node's bare `AbortError: The operation was aborted`) when the
+ * caller-supplied timeout fires. The bare AbortError bit an operator during
+ * the 2026-04-24 eval (see {@link GitIndexingTimeoutError} in errors/git.ts):
+ * an 854 s git indexing pass died with no command name, no elapsed time, and
+ * no hint that a timeout — not git — was responsible. The git path gained a
+ * site-local typed error then; this class extends the same courtesy to every
+ * other `timeout` caller.
+ */
+export class ExecTimeoutError extends FireForgeError {
+    command;
+    args;
+    timeoutMs;
+    code = ExitCode.GENERAL_ERROR;
+    constructor(
+    /** Executable that was spawned (argv[0]). */
+    command, 
+    /** Arguments the executable was spawned with. */
+    args, 
+    /** Timeout that elapsed, in milliseconds. */
+    timeoutMs, cause) {
+        super(`Command timed out after ${Math.round(timeoutMs / 1000)}s: ${[command, ...args].join(' ')}`, cause);
+        this.command = command;
+        this.args = args;
+        this.timeoutMs = timeoutMs;
+    }
+    get userMessage() {
+        return (`${this.message}\n\n` +
+            'The command was killed because it exceeded its time budget, not because it failed on its own. ' +
+            'If the host is just slow or loaded, re-running may succeed.');
+    }
+}
 /**
  * Error thrown when the user cancels an interactive prompt.
  */
@@ -108,4 +143,3 @@ export class CommandError extends Error {
         this.name = 'CommandError';
     }
 }
-//# sourceMappingURL=base.js.map

package/dist/src/errors/build.js

@@ -111,4 +111,3 @@ export class AmbiguousBuildArtifactsError extends BuildError {
             '  3. Run the command again');
     }
 }
-//# sourceMappingURL=build.js.map

package/dist/src/errors/codes.d.ts

@@ -38,5 +38,11 @@ export declare const ExitCode: {
      * missing profile, etc.).
      */
     readonly SMOKE_LAUNCH_FAILURE: 13;
+    /**
+     * The user cancelled an interactive prompt. 130 = 128 + SIGINT, the
+     * conventional "interrupted by the user" code — scripts and CI can tell
+     * a deliberate cancellation apart from a real failure (GENERAL_ERROR).
+     */
+    readonly USER_CANCELLED: 130;
 };
 export type ExitCode = (typeof ExitCode)[keyof typeof ExitCode];

package/dist/src/errors/codes.js

@@ -39,5 +39,10 @@ export const ExitCode = {
      * missing profile, etc.).
      */
     SMOKE_LAUNCH_FAILURE: 13,
+    /**
+     * The user cancelled an interactive prompt. 130 = 128 + SIGINT, the
+     * conventional "interrupted by the user" code — scripts and CI can tell
+     * a deliberate cancellation apart from a real failure (GENERAL_ERROR).
+     */
+    USER_CANCELLED: 130,
 };
-//# sourceMappingURL=codes.js.map

package/dist/src/errors/config.js

@@ -58,4 +58,3 @@ export class InvalidFieldError extends ConfigError {
         this.actualValue = actualValue;
     }
 }
-//# sourceMappingURL=config.js.map

package/dist/src/errors/download.js

@@ -129,4 +129,3 @@ export class PartialEngineExistsError extends DownloadError {
             '  3. Re-run with --verbose for the full underlying error and stack trace');
     }
 }
-//# sourceMappingURL=download.js.map

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

@@ -5,6 +5,16 @@ import { FireForgeError } from './base.js';
 export declare class FurnaceError extends FireForgeError {
     readonly component?: string | undefined;
     readonly code: 9;
-    constructor(message: string, component?: string | undefined, cause?: Error);
+    constructor(message: string, component?: string | undefined, cause?: Error, options?: {
+        /**
+         * Suppresses the "run furnace validate" advice line. Set by callers
+         * whose message already tells the user to run validate (or that ARE
+         * the validate command) — an explicit flag, because the previous
+         * `message.includes('furnace validate')` sniffing dropped the advice
+         * from any error that merely MENTIONED the command.
+         */
+        omitValidateAdvice?: boolean;
+    });
+    private readonly omitValidateAdvice;
     get userMessage(): string;
 }

package/dist/src/errors/furnace.js

@@ -7,22 +7,23 @@ import { ExitCode } from './codes.js';
 export class FurnaceError extends FireForgeError {
     component;
     code = ExitCode.FURNACE_ERROR;
-    constructor(message, component, cause) {
+    constructor(message, component, cause, options) {
         super(message, cause);
         this.component = component;
+        this.omitValidateAdvice =
+            options?.omitValidateAdvice ?? message.includes('Run "fireforge furnace validate"');
     }
+    omitValidateAdvice;
     get userMessage() {
         let msg = this.component
             ? `Furnace Error (${this.component}): ${this.message}`
             : `Furnace Error: ${this.message}`;
         msg += '\n\nTo fix this:\n';
         msg += '  1. Check the error message above for specifics\n';
-        // Avoid circular advice when the error is thrown during validation itself.
-        if (!this.message.includes('furnace validate')) {
+        if (!this.omitValidateAdvice) {
             msg += '  2. Run "fireforge furnace validate" to diagnose issues\n';
         }
-        msg += `  ${this.message.includes('furnace validate') ? '2' : '3'}. Use "fireforge doctor --repair-furnace" if state is inconsistent`;
+        msg += `  ${this.omitValidateAdvice ? '2' : '3'}. Use "fireforge doctor --repair-furnace" if state is inconsistent`;
         return msg;
     }
 }
-//# sourceMappingURL=furnace.js.map

package/dist/src/errors/git.js

@@ -135,4 +135,3 @@ export class GitIndexingTimeoutError extends GitError {
             '  3. If the problem persists, check disk throughput and free space; Firefox source indexing on a cold SSD typically completes in 1–3 minutes.');
     }
 }
-//# sourceMappingURL=git.js.map

package/dist/src/errors/patch.d.ts

@@ -1,4 +1,21 @@
 import { FireForgeError } from './base.js';
+/**
+ * Error thrown when `patches.json` exists but cannot be parsed or validated.
+ *
+ * This must be a HARD error on every mutating path. The historical behavior
+ * collapsed "corrupt" into "absent" (`loadPatchesManifest` returned null for
+ * both), so the next `fireforge export` would rebuild the manifest containing
+ * only the new patch — silently destroying every other patch's metadata
+ * (tiers, descriptions, lintIgnore, staged dependencies) — and a failed
+ * export's rollback would then delete `patches.json` outright because the
+ * "before" state looked absent (2026-07-05 review, finding H2).
+ */
+export declare class PatchManifestCorruptError extends FireForgeError {
+    readonly manifestPath: string;
+    readonly code: 6;
+    constructor(manifestPath: string, cause?: Error);
+    get userMessage(): string;
+}
 /**
  * Error thrown when patch operations fail.
  */

package/dist/src/errors/patch.js

@@ -1,6 +1,35 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { FireForgeError } from './base.js';
 import { ExitCode } from './codes.js';
+/**
+ * Error thrown when `patches.json` exists but cannot be parsed or validated.
+ *
+ * This must be a HARD error on every mutating path. The historical behavior
+ * collapsed "corrupt" into "absent" (`loadPatchesManifest` returned null for
+ * both), so the next `fireforge export` would rebuild the manifest containing
+ * only the new patch — silently destroying every other patch's metadata
+ * (tiers, descriptions, lintIgnore, staged dependencies) — and a failed
+ * export's rollback would then delete `patches.json` outright because the
+ * "before" state looked absent (2026-07-05 review, finding H2).
+ */
+export class PatchManifestCorruptError extends FireForgeError {
+    manifestPath;
+    code = ExitCode.PATCH_ERROR;
+    constructor(manifestPath, cause) {
+        super(`patches.json exists but could not be parsed: ${cause?.message ?? 'unknown parse error'}`, cause);
+        this.manifestPath = manifestPath;
+    }
+    get userMessage() {
+        return (`Patch Manifest Error: ${this.message}\n\n` +
+            `Manifest: ${this.manifestPath}\n\n` +
+            'FireForge refuses to modify the patch queue while patches.json is unreadable — ' +
+            'rewriting it now would silently discard the metadata of every patch it lists.\n\n' +
+            'To fix this:\n' +
+            '  1. Open patches.json and repair the syntax error (a recent hand-edit is the usual cause)\n' +
+            '  2. Or restore patches.json from version control\n' +
+            '  3. Then re-run the command');
+    }
+}
 /**
  * Error thrown when patch operations fail.
  */
@@ -23,4 +52,3 @@ export class PatchError extends FireForgeError {
         return msg;
     }
 }
-//# sourceMappingURL=patch.js.map

package/dist/src/errors/rebase.js

@@ -32,4 +32,3 @@ export class NoRebaseSessionError extends RebaseError {
         super('No rebase session in progress. Start one with "fireforge rebase".');
     }
 }
-//# sourceMappingURL=rebase.js.map

package/dist/src/errors/run.js

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { FireForgeError } from './base.js';
+import { ExitCode } from './codes.js';
 /**
  * Error raised by `fireforge run --smoke-exit` when the captured console
  * stream produced one or more error lines that did NOT match the
@@ -19,4 +20,3 @@ export class SmokeRunError extends FireForgeError {
         return `Smoke run failed: ${this.message}`;
     }
 }
-//# sourceMappingURL=run.js.map

package/dist/src/index.js

@@ -18,4 +18,3 @@ export { validateAllComponents, validateComponent } from './core/furnace-validat
 export { addToken, getTokensCssPath, validateTokenAdd } from './core/token-manager.js';
 export { CancellationError, CommandError, FireForgeError, GeneralError, InvalidArgumentError, ResolutionError, } from './errors/base.js';
 export { ExitCode } from './errors/codes.js';
-//# sourceMappingURL=index.js.map

package/dist/src/types/cli.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=cli.js.map

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

@@ -2,5 +2,5 @@
  * 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, 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 { ImportSummary, PatchCategory, PatchesManifest, PatchInfo, PatchLintIssue, PatchMetadata, PatchResult, PatchStagedDependencies, PatchStagedForwardImport, PatchStagedRegistration, } from './patches.js';
 export type { DoctorCheck, ProjectStatus, TokenCoverageFileEntry, TokenCoverageReport, } from './project.js';

package/dist/src/types/commands/index.js

@@ -3,4 +3,3 @@
  * Re-exports all command-related types from focused sub-modules.
  */
 export {};
-//# sourceMappingURL=index.js.map

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

@@ -99,6 +99,12 @@ export interface ExportOptions {
     forceUnsafe?: boolean;
     /** Exclude furnace-managed file paths from the export. */
     excludeFurnace?: boolean;
+    /**
+     * Export the deployed engine copy even when the `components/` source
+     * changed since the last furnace apply. Without this flag the export is
+     * refused so a stale deployed copy cannot silently land in the patch.
+     */
+    allowStaleFurnace?: boolean;
     /**
      * Acknowledge that the export will create cross-patch ownership overlap
      * with existing non-superseded patches. Without this flag, `export`
@@ -210,6 +216,12 @@ export interface ReExportOptions {
      * before the interactive/`--yes` confirmation path.
      */
     allowShrink?: boolean;
+    /**
+     * Export the deployed engine copy even when the `components/` source
+     * changed since the last furnace apply. Without this flag the re-export
+     * is refused so a stale deployed copy cannot silently land in the patch.
+     */
+    allowStaleFurnace?: boolean;
     /** Bypass cross-patch lint refusal on projected shrink state */
     forceUnsafe?: boolean;
     /**
@@ -278,16 +290,27 @@ export interface PatchLintIgnoreOptions {
  * declarations, or clear all staged dependencies from the patch.
  */
 export interface PatchStagedDependencyOptions {
-    /** Add a forward-import staged dependency. */
+    /** Add a staged dependency declaration. */
     add?: boolean;
-    /** Remove matching forward-import staged dependency declarations. */
+    /** Remove matching staged dependency declarations. */
     remove?: boolean;
     /** Drop the stagedDependencies field entirely. */
     clear?: boolean;
-    /** Importing file path relative to engine/. */
+    /**
+     * Declaration shape: `import` (forward import, the default when unset) or
+     * `registration` (jar.mn packaging line, customElements or actor
+     * registration). Registration entries use `line` instead of `specifier`.
+     */
+    kind?: string;
+    /** Declaring file path relative to engine/. */
     file?: string;
-    /** Exact import specifier as it appears in source. */
+    /** Exact import specifier as it appears in source (`kind: import`). */
     specifier?: string;
+    /**
+     * Registration/packaging line as the patch adds it, compared
+     * whitespace-trimmed (`kind: registration`).
+     */
+    line?: string;
     /** Later-created file path relative to engine/. */
     creates?: string;
     /** Optional exact patch filename expected to create `creates`. */
@@ -299,11 +322,6 @@ export interface PatchStagedDependencyOptions {
     /** Skip the confirmation prompt (required for non-TTY). */
     yes?: boolean;
 }
-/**
- * Options for the preview-only `fireforge patch move-files` subcommand.
- * It validates an ownership transfer and prints the explicit
- * `re-export --files` commands needed to perform it.
- */
 /**
  * Options for the `patch split` command.
  */
@@ -331,6 +349,11 @@ export interface PatchSplitOptions {
     /** Skip per-patch lint of the projected bodies. */
     skipLint?: boolean;
 }
+/**
+ * Options for the preview-only `fireforge patch move-files` subcommand.
+ * It validates an ownership transfer and prints the explicit
+ * `re-export --files` commands needed to perform it.
+ */
 export interface PatchMoveFilesOptions {
     /** File paths relative to engine/ to move from the source patch to the target patch. */
     file?: string[];
@@ -405,6 +428,8 @@ export interface TestOptions {
     headless?: boolean;
     /** Run incremental UI build before testing */
     build?: boolean;
+    /** Forward mach's pathless auto-selection mode. Valid only with no explicit paths. */
+    auto?: boolean;
     /**
      * Run a marionette preflight before tests. Reports PASS/FAIL in under a
      * minute. When test paths are supplied, a FAIL aborts before mach test is
@@ -428,6 +453,12 @@ export interface TestOptions {
      * stale process holds the default port or CI uses another port.
      */
     marionettePort?: number;
+    /** Kill a recognized stale browser process holding the Marionette port, then continue. */
+    killStaleMarionette?: boolean;
+    /** Permit tests against packageable engine edits newer than the last successful build. */
+    allowStaleBuild?: boolean;
+    /** Run the configured short harness canary. `true` means use `fireforge.json`'s test.canaryPath. */
+    canary?: string | boolean;
     /**
      * Retry budget for recognized harness crashes (resource-monitor
      * tracebacks, pre-test no-output hangs, post-green shutdown re-entry).

package/dist/src/types/commands/options.js

@@ -3,4 +3,3 @@
  * Command option types for CLI commands.
  */
 export {};
-//# sourceMappingURL=options.js.map

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

@@ -31,6 +31,14 @@ export interface PatchResult {
     conflictingFiles?: string[];
     /** Whether the patch was auto-resolved (new file vs existing file conflict) */
     autoResolved?: boolean;
+    /**
+     * Pre-existing content of files the auto-resolve overwrote, keyed by
+     * engine-relative path. Kept for the RUN's duration (not just the retry):
+     * if a later patch fails and `rollbackPatches` reverse-applies this one,
+     * reversing a new-file patch DELETES the file — these snapshots are the
+     * only way to restore what was there before the auto-resolve.
+     */
+    autoResolvedOriginals?: Map<string, string>;
 }
 /**
  * Extended patch information with metadata.
@@ -119,6 +127,15 @@ export interface PatchMetadata {
 export interface PatchStagedDependencies {
     /** Exact forward-import declarations allowed for this patch. */
     forwardImports?: PatchStagedForwardImport[];
+    /**
+     * Registration-shaped forward dependencies: packaging or registration
+     * LINES (a jar.mn entry, a customElements registration, an actor
+     * registration) this patch adds that reference a file a later patch
+     * creates. Unlike `forwardImports`, these are validated by matching the
+     * declared line against the patch's added content, not by finding an
+     * import specifier — packaging lines have no import to match.
+     */
+    registrations?: PatchStagedRegistration[];
 }
 /** A single intentional forward import to a later-created file. */
 export interface PatchStagedForwardImport {
@@ -133,6 +150,26 @@ export interface PatchStagedForwardImport {
     /** Optional human-readable rationale for the staged dependency. */
     reason?: string;
 }
+/**
+ * A single intentional registration/packaging line referencing a
+ * later-created file.
+ */
+export interface PatchStagedRegistration {
+    /** Declaring file path relative to engine/ (e.g. `toolkit/content/jar.mn`). */
+    file: string;
+    /**
+     * The registration/packaging line exactly as the patch adds it. Compared
+     * whitespace-trimmed against the patch's added lines in `file`, so
+     * indentation differences do not break the match.
+     */
+    line: string;
+    /** Later-created file path relative to engine/. */
+    creates: string;
+    /** Optional exact patch filename expected to create `creates`. */
+    owner?: string;
+    /** Optional human-readable rationale for the staged dependency. */
+    reason?: string;
+}
 /**
  * Schema for patches/patches.json file.
  */

package/dist/src/types/commands/patches.js

@@ -3,4 +3,3 @@
  * Types for the patch system: patch metadata, manifests, lint, and import results.
  */
 export {};
-//# sourceMappingURL=patches.js.map

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

@@ -3,19 +3,28 @@
  */
 /**
  * Result of a doctor check.
+ *
+ * Field precedence (consumers and producers must agree):
+ *   1. `severity`, when present, is authoritative — `'error'` counts as a
+ *      failure and `'warning'` as a warning REGARDLESS of `passed`.
+ *   2. Without `severity`, `passed: false` is a failure unless
+ *      `warning: true` downgrades it to a warning.
+ * Producers should prefer setting `severity` explicitly; `warning` exists
+ * for older checks that predate the field. Do not emit contradictory
+ * combinations like `passed: true, severity: 'error'`.
  */
 export interface DoctorCheck {
     /** Name of the check */
     name: string;
     /** Whether the check passed */
     passed: boolean;
-    /** Severity of the result */
+    /** Severity of the result (authoritative when present — see above) */
     severity?: 'ok' | 'warning' | 'error';
     /** Description of the result */
     message: string;
     /** Suggested fix if check failed */
     fix?: string;
-    /** Whether this check passed with a warning */
+    /** Legacy warning flag for checks that predate `severity` */
     warning?: boolean;
 }
 /**

package/dist/src/types/commands/project.js

@@ -3,4 +3,3 @@
  * Project diagnostics, status, and token coverage types.
  */
 export {};
-//# sourceMappingURL=project.js.map

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

@@ -24,6 +24,34 @@ export interface BuildConfig {
     /** Number of parallel jobs for mach build */
     jobs?: number;
 }
+/** Test command defaults stored in fireforge.json. */
+export interface TestConfig {
+    /**
+     * Engine-relative browser-chrome canary file used by `fireforge test --canary`
+     * when the command does not receive an explicit canary path.
+     */
+    canaryPath?: string;
+    /** Short no-output ceiling for `fireforge test --canary`, in seconds. */
+    canaryTimeoutSeconds?: number;
+}
+/** A single external executable required by a project-specific toolchain. */
+export interface ExternalToolRequirement {
+    /** Tool name as shown in doctor output, and PATH/xcrun lookup key when no path is set. */
+    name: string;
+    /** Absolute or project-relative executable path. */
+    path?: string;
+    /** Resolve the tool with `xcrun -find <name>` instead of PATH. */
+    xcrun?: boolean;
+    /** Missing tool is an error by default; set false for advisory probes. */
+    required?: boolean;
+}
+/** Named group of project-specific external asset/build tools. */
+export interface ExternalToolchainConfig {
+    /** Human-readable toolchain name, e.g. "seasonal-branding". */
+    name: string;
+    /** Tools this toolchain needs. */
+    tools: ExternalToolRequirement[];
+}
 /** Enforcement mode for patch policy violations during mutating commands. */
 export type PatchPolicyMutationMode = 'error' | 'warn' | 'force';
 /** A category-owned numeric range in the patch queue. */
@@ -89,6 +117,10 @@ export interface FireForgeConfig {
     firefox: FirefoxConfig;
     /** Build settings */
     build?: BuildConfig;
+    /** Test command defaults */
+    test?: TestConfig;
+    /** Optional project-specific external toolchains checked by doctor. */
+    externalToolchains?: ExternalToolchainConfig[];
     /** Project license SPDX identifier */
     license?: ProjectLicense;
     /** Wire command configuration */

package/dist/src/types/config.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=config.js.map

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

@@ -46,6 +46,19 @@ export interface CustomComponentConfig {
     targetPath: string;
     /** Whether to register in customElements.js */
     register: boolean;
+    /**
+     * What the component IS. `'element'` (the default when unset) is a custom
+     * element with its own tag. `'library'` is a base class + helpers module
+     * that defines no element of its own (e.g. a shared MozLitElement
+     * subclass other components extend): `furnace validate` skips the
+     * `no-custom-element-define` / `not-moz-lit-element` compatibility checks
+     * and the `missing-css` structural advisory for it, while headers, module
+     * shape, `relative-import`, and (when a `.css` exists) the CSS
+     * compatibility rules still apply. A library exports no element, so
+     * `kind: "library"` requires `register: false` — the combination with
+     * `register: true` is rejected at config parse time.
+     */
+    kind?: 'element' | 'library';
     /** Whether this component uses Fluent l10n */
     localized: boolean;
     /** Stock component tag names composed internally by this component */
@@ -208,6 +221,16 @@ export interface FurnaceState {
 export interface StepError {
     step: string;
     error: string;
+    /**
+     * Advisory step errors are reported as warnings and never trigger
+     * rollback or a non-zero exit. Used by the `.ftl` helpers, whose module
+     * contract is graceful degradation: a missing locale jar.mn on a fork
+     * without a locale package must not block a working `.mjs`/`.css` from
+     * shipping. Before this flag existed the contract was contradicted in
+     * practice — any FTL step error rolled back the entire apply, so a
+     * localized component on such a fork could never be applied at all.
+     */
+    advisory?: boolean;
 }
 /**
  * Result of applying all components to the engine source tree.

package/dist/src/types/furnace.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=furnace.js.map

package/dist/src/types/index.js

@@ -3,4 +3,3 @@
  * Re-exports all type definitions.
  */
 export {};
-//# sourceMappingURL=index.js.map

package/dist/src/types/typecheck.js

@@ -12,4 +12,3 @@
  * code fields that have no meaning for patch-hygiene rules.
  */
 export {};
-//# sourceMappingURL=typecheck.js.map

package/dist/src/utils/elapsed.js

@@ -12,4 +12,3 @@ function formatElapsed(ms) {
 export function elapsedSince(startedAt) {
     return formatElapsed(Date.now() - startedAt);
 }
-//# sourceMappingURL=elapsed.js.map

package/dist/src/utils/errors.js

@@ -12,4 +12,3 @@ export function toError(error) {
     }
     return new Error(typeof error === 'string' ? error : String(error), { cause: error });
 }
-//# sourceMappingURL=errors.js.map