@hominis/fireforge 0.10.1 → 0.11.0

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

@@ -56,13 +56,35 @@ export interface ExportOptions {
     supersede?: boolean;
     /** Skip patch lint checks (downgrade errors to warnings) */
     skipLint?: boolean;
+    /**
+     * Print the computed export plan without writing anything. With
+     * `--supersede`, the dry-run output includes which existing patches would
+     * be superseded and which files caused the coverage.
+     */
+    dryRun?: boolean;
+    /** Place the new patch at a specific ordinal, shifting subsequent patches. */
+    order?: number;
+    /** Place the new patch immediately before the named patch. */
+    before?: string;
+    /** Place the new patch immediately after the named patch. */
+    after?: string;
+    /**
+     * Skip the confirmation prompt when placement forces a renumber of more
+     * than one existing patch. Required for non-TTY runs that use placement
+     * flags.
+     */
+    yes?: boolean;
+    /** Bypass cross-patch lint refusal for projected placement state. */
+    forceUnsafe?: boolean;
+    /** Exclude furnace-managed file paths from the export. */
+    excludeFurnace?: boolean;
 }
 /**
  * Options for the reset command.
  */
 export interface ResetOptions {
     /** Skip confirmation prompt */
-    force?: boolean;
+    yes?: boolean;
     /** Show what would be reset without doing it */
     dryRun?: boolean;
 }
@@ -73,7 +95,7 @@ export interface DiscardOptions {
     /** Show what would be discarded without doing it */
     dryRun?: boolean;
     /** Skip confirmation prompt */
-    force?: boolean;
+    yes?: boolean;
 }
 /**
  * Options for the package command.
@@ -92,6 +114,14 @@ export interface ImportOptions {
     continue?: boolean;
     /** Force import even when engine HEAD has drifted from base commit */
     force?: boolean;
+    /**
+     * Apply patches only up to and including this patch (by name or ordinal).
+     * Subsequent patches are left unapplied. Useful for bisection and curated
+     * rebuild workflows.
+     */
+    until?: string;
+    /** Preview which patches would be applied without modifying the engine */
+    dryRun?: boolean;
 }
 /**
  * Options for the re-export command.
@@ -101,10 +131,22 @@ export interface ReExportOptions {
     all?: boolean;
     /** Scan directories for new/removed files and update filesAffected */
     scan?: boolean;
+    /**
+     * Restrict the re-exported patch's filesAffected to this explicit list.
+     * Files currently in the patch but not in this list are dropped (shrink);
+     * files in this list but not currently in the patch are added. Mutually
+     * exclusive with `--scan` and `--all`; applies to a single target patch
+     * at a time.
+     */
+    files?: string[];
     /** Show what would change without writing */
     dryRun?: boolean;
     /** Skip patch lint checks (downgrade errors to warnings) */
     skipLint?: boolean;
+    /** Skip confirmation prompt on shrink (required for non-TTY) */
+    yes?: boolean;
+    /** Bypass cross-patch lint refusal on projected shrink state */
+    forceUnsafe?: boolean;
 }
 /**
  * Options for the rebase command.
@@ -119,7 +161,7 @@ export interface RebaseOptions {
     /** Maximum fuzz factor for git apply (default 3) */
     maxFuzz?: number;
     /** Skip dirty-tree confirmation prompt */
-    force?: boolean;
+    yes?: boolean;
 }
 /**
  * Options for the run command.
@@ -143,6 +185,10 @@ export interface TestOptions {
 export interface FurnaceApplyOptions {
     /** Show what would be changed without writing */
     dryRun?: boolean;
+    /** Proceed despite baseVersion drift (stale overrides) */
+    force?: boolean;
+    /** Watch component directories and re-apply on changes */
+    watch?: boolean;
 }
 /**
  * Options for the furnace preview command.
@@ -157,6 +203,39 @@ export interface FurnacePreviewOptions {
 export interface FurnaceDeployOptions {
     /** Show what would be changed without writing */
     dryRun?: boolean;
+    /** Proceed despite baseVersion drift (stale overrides) */
+    force?: boolean;
+    /** Skip the validation step (apply only, no accessibility/compatibility checks) */
+    skipValidate?: boolean;
+}
+/**
+ * Options for the furnace refresh command.
+ */
+export interface FurnaceRefreshOptions {
+    /** Show what would change without modifying files */
+    dryRun?: boolean;
+    /** Refresh all overrides in a single batch */
+    all?: boolean;
+    /** Conflict resolution strategy for automated use (ours = keep local, theirs = accept upstream) */
+    strategy?: 'ours' | 'theirs';
+    /** Reset the override's baseline to the current engine HEAD, skipping three-way merge */
+    resetBase?: boolean;
+}
+/**
+ * Options for the furnace sync command.
+ */
+export interface FurnaceSyncOptions {
+    /** Show what would change without modifying files */
+    dryRun?: boolean;
+    /** Conflict resolution strategy for three-way merge (ours = keep local, theirs = accept upstream) */
+    strategy?: 'ours' | 'theirs';
+}
+/**
+ * Options for the furnace validate command.
+ */
+export interface FurnaceValidateOptions {
+    /** Auto-fix registration issues (missing jar.mn entries, customElements.js registration) */
+    fix?: boolean;
 }
 /**
  * Options for the furnace override command.
@@ -172,7 +251,7 @@ export interface FurnaceOverrideOptions {
  */
 export interface FurnaceRemoveOptions {
     /** Skip confirmation prompt */
-    force?: boolean;
+    yes?: boolean;
 }
 /**
  * Options for the furnace create command.
@@ -207,12 +286,43 @@ export interface RegisterOptions {
     dryRun?: boolean;
     after?: string;
 }
+/**
+ * Options for the patch delete command.
+ */
+export interface PatchDeleteOptions {
+    /** Skip confirmation prompt; required for non-TTY runs. */
+    yes?: boolean;
+    /** Print what would happen without writing anything. */
+    dryRun?: boolean;
+    /** Bypass the hard refusal when later patches depend on the target. */
+    forceUnsafe?: boolean;
+}
+/**
+ * Options for the patch reorder command.
+ */
+export interface PatchReorderOptions {
+    to?: number;
+    before?: string;
+    after?: string;
+    yes?: boolean;
+    dryRun?: boolean;
+    forceUnsafe?: boolean;
+}
 /**
  * Options for the status command.
  */
 export interface StatusOptions {
     raw?: boolean;
     unmanaged?: boolean;
+    /**
+     * Render a flat file→owning-patch ownership table instead of the three-
+     * bucket classification. Sources the path list from the manifest's
+     * `filesAffected` per patch and flags any path claimed by more than one
+     * patch as an ownership conflict.
+     */
+    ownership?: boolean;
+    /** Output machine-readable JSON instead of human-readable text. */
+    json?: boolean;
 }
 /**
  * Options for the token add command.
@@ -229,6 +339,17 @@ export interface TokenAddOptions {
  */
 export interface DoctorOptions {
     repairPatchesManifest?: boolean;
+    /**
+     * Opt-in repair path for furnace-specific checks. When true, doctor will:
+     * - clear stale `.fireforge/furnace-state.json` entries whose component is
+     *   no longer in `furnace.json`,
+     * - run `applyAllComponents` to reconcile any engine drift,
+     * - clear the `pendingRepair` marker on success.
+     * Mirrors `repairPatchesManifest` in that the repair is only attempted when
+     * the caller explicitly asks for it, so a read-only `doctor` run stays cheap
+     * and side-effect-free.
+     */
+    repairFurnace?: boolean;
 }
 /**
  * Global CLI options available to all commands.

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

@@ -47,7 +47,7 @@ export interface PatchMetadata {
     description: string;
     /** ISO timestamp of when the patch was created */
     createdAt: string;
-    /** ESR version the patch was created against (e.g., "140.0esr") */
+    /** ESR version the patch was created against (e.g., "146.0esr") */
     sourceEsrVersion: string;
     /** Array of file paths affected by this patch */
     filesAffected: string[];
@@ -82,6 +82,16 @@ export interface PatchLintIssue {
     file: string;
     /** Check identifier (e.g. "raw-color-value", "token-prefix-violation") */
     check: string;
+    /**
+     * Stable machine-readable identity for this finding.
+     *
+     * Use when the human-readable `message` may drift between otherwise
+     * equivalent runs (for example because a rule embeds line numbers,
+     * rename-sensitive patch filenames, or other contextual detail).
+     * Consumers that diff lint outputs should prefer this over `message`
+     * when it is present.
+     */
+    fingerprint?: string;
     /** Human-readable description of the issue */
     message: string;
     /** Severity: errors block export, warnings are advisory */

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

@@ -6,7 +6,7 @@ export type FirefoxProduct = 'firefox' | 'firefox-esr' | 'firefox-beta';
  * Firefox version configuration.
  */
 export interface FirefoxConfig {
-    /** Firefox release version (e.g., "140.0esr") */
+    /** Firefox release version (e.g., "146.0esr") */
     version: string;
     /** Firefox product type */
     product: FirefoxProduct;

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

@@ -33,6 +33,8 @@ export interface OverrideComponentConfig {
     basePath: string;
     /** Firefox version this override was based on */
     baseVersion: string;
+    /** Git commit SHA the override was based on. Older overrides may lack this field. */
+    baseCommit?: string;
 }
 /**
  * Metadata for a custom component in the workspace.
@@ -61,6 +63,16 @@ export interface FurnaceConfig {
     tokenPrefix?: string;
     /** Custom properties allowed even though they don't match tokenPrefix (e.g. ["--background-color-box"]) */
     tokenAllowlist?: string[];
+    /**
+     * Override the default Fluent (.ftl) base path within the engine.
+     * Defaults to `toolkit/locales/en-US/toolkit/global` when not set.
+     */
+    ftlBasePath?: string;
+    /**
+     * Additional directories to scan for components (relative to engine root).
+     * Always includes `toolkit/content/widgets` by default.
+     */
+    scanPaths?: string[];
     /** Stock components tracked for preview */
     stock: string[];
     /** Override components */
@@ -68,6 +80,28 @@ export interface FurnaceConfig {
     /** Custom components */
     custom: Record<string, CustomComponentConfig>;
 }
+/**
+ * Operations that can leave a pending-repair marker when they fail to roll
+ * back cleanly. The marker is consumed by `fireforge doctor`, which either
+ * re-runs apply for engine-side failures or validates the current authoring
+ * state before clearing authoring markers. The string is surfaced in doctor's
+ * failure message verbatim, so new entries should be self-explanatory.
+ */
+export type FurnacePendingRepairOperation = 'preview-teardown' | 'apply-rollback' | 'deploy-rollback' | 'remove-rollback' | 'create-rollback' | 'override-rollback' | 'scan-rollback' | 'rename-rollback' | 'refresh-rollback';
+/**
+ * Marker persisted into `.fireforge/furnace-state.json` when a furnace
+ * mutation failed to roll back cleanly. Its presence tells the next
+ * `fireforge doctor` run that the engine and workspace may have drifted
+ * out-of-band from what the state file records.
+ */
+export interface FurnacePendingRepair {
+    /** The operation that failed to clean up; used by doctor to route the fix. */
+    operation: FurnacePendingRepairOperation;
+    /** ISO timestamp of when the repair marker was written. */
+    timestamp: string;
+    /** Human-readable summary of the failure; shown by doctor. */
+    reason: string;
+}
 /**
  * State tracking for apply operations (stored in .fireforge/furnace-state.json).
  */
@@ -76,6 +110,20 @@ export interface FurnaceState {
     lastApply?: string;
     /** Checksums of component files at last apply, keyed by relative path */
     appliedChecksums?: Record<string, string>;
+    /**
+     * SHA-256 hashes of engine-side files written during the last apply, keyed
+     * by engine-relative path. Used by drift detection to avoid byte-comparing
+     * engine files against workspace sources when the cached hash still matches
+     * the on-disk content. Populated alongside `appliedChecksums` on successful
+     * apply.
+     */
+    engineChecksums?: Record<string, string>;
+    /**
+     * Set when a furnace mutation failed to roll back cleanly and the engine
+     * may be in an inconsistent state. Cleared by `fireforge doctor` after
+     * reconciliation. See {@link FurnacePendingRepair}.
+     */
+    pendingRepair?: FurnacePendingRepair;
 }
 /**
  * A registration-step error captured while applying a component.
@@ -107,13 +155,19 @@ export interface ApplyResult {
         name: string;
         error: string;
     }>;
+    /**
+     * Set to true when the rollback journal was restored after a partial failure.
+     * When true, entries in `applied` reflect what was attempted, not what
+     * persisted — the engine has been restored to its pre-apply state.
+     */
+    rolledBack?: boolean;
 }
 /**
  * An action that would be performed during a dry-run deploy.
  */
 export interface DryRunAction {
     component: string;
-    action: 'copy' | 'register-ce' | 'register-jar' | 'copy-ftl';
+    action: 'copy' | 'register-ce' | 'register-jar' | 'copy-ftl' | 'undeploy-remove' | 'undeploy-restore' | 'unregister-ce' | 'unregister-jar';
     source?: string;
     target?: string;
     description: string;

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

@@ -70,3 +70,15 @@ export declare function writeFileAtomic(path: string, content: string | Buffer):
  * @param dest - Destination directory path
  */
 export declare function copyDir(src: string, dest: string): Promise<void>;
+/**
+ * Checks available disk space at a path and warns via the provided
+ * callback when it falls below `minBytes`.
+ *
+ * @param path - Directory to check (must exist)
+ * @param minBytes - Minimum free bytes before emitting a warning
+ * @param onLowSpace - Callback invoked with a human-readable message
+ *   when available space is below the threshold
+ * @returns The available bytes, or `undefined` when the check could not
+ *   be performed (unsupported platform, permission error, etc.)
+ */
+export declare function checkDiskSpace(path: string, minBytes: number, onLowSpace: (message: string) => void): Promise<number | undefined>;

package/dist/src/utils/fs.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { randomUUID } from 'node:crypto';
-import { access, copyFile as fsCopyFile, mkdir, open, readdir, readFile, rename, rm, } from 'node:fs/promises';
+import { access, copyFile as fsCopyFile, mkdir, open, readdir, readFile, rename, rm, statfs, } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 const RETRIABLE_REMOVE_ERRORS = new Set(['ENOTEMPTY', 'EBUSY', 'EPERM']);
 function sleep(ms) {
@@ -176,4 +176,33 @@ function createAtomicTempPath(path) {
     const filename = path.slice(directory.length + 1);
     return join(directory, `.${filename}.fireforge-tmp-${process.pid}-${randomUUID()}`);
 }
+/**
+ * Checks available disk space at a path and warns via the provided
+ * callback when it falls below `minBytes`.
+ *
+ * @param path - Directory to check (must exist)
+ * @param minBytes - Minimum free bytes before emitting a warning
+ * @param onLowSpace - Callback invoked with a human-readable message
+ *   when available space is below the threshold
+ * @returns The available bytes, or `undefined` when the check could not
+ *   be performed (unsupported platform, permission error, etc.)
+ */
+export async function checkDiskSpace(path, minBytes, onLowSpace) {
+    try {
+        const stats = await statfs(path);
+        const availableBytes = stats.bfree * stats.bsize;
+        if (availableBytes < minBytes) {
+            const availableGB = (availableBytes / (1024 * 1024 * 1024)).toFixed(1);
+            const requiredGB = (minBytes / (1024 * 1024 * 1024)).toFixed(1);
+            onLowSpace(`Low disk space: ${availableGB} GB available, ${requiredGB} GB recommended. ` +
+                'The operation may fail if the disk fills up.');
+        }
+        return availableBytes;
+    }
+    catch {
+        // statfs may not be available on all platforms or the path may
+        // not exist yet — silently degrade rather than blocking the operation.
+        return undefined;
+    }
+}
 //# sourceMappingURL=fs.js.map

package/dist/src/utils/package-root.d.ts

@@ -9,8 +9,13 @@ interface PackageMetadata {
  * Works from both the source tree (`src/utils/`) and the compiled
  * tree (`dist/src/utils/`) by looking for a `package.json` that exposes
  * the `fireforge` CLI entrypoint, regardless of the npm package scope.
+ *
+ * The result is cached after the first call since it is deterministic
+ * within a process.
  */
 export declare function getPackageRoot(): string;
+/** Clears the cached package root for testing. */
+export declare function resetPackageRootCacheForTests(): void;
 /** @internal */
 export declare function isFireForgePackageMetadata(pkg: PackageMetadata): boolean;
 /** Reads the current package version from the repository root package manifest. */

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

@@ -17,20 +17,28 @@ function readPackageMetadata(filePath) {
     const raw = readFileSync(filePath, 'utf-8');
     return validatePackageMetadata(JSON.parse(raw), filePath);
 }
+let cachedPackageRoot;
 /**
  * Finds the fireforge package root by walking up from the current module.
  *
  * Works from both the source tree (`src/utils/`) and the compiled
  * tree (`dist/src/utils/`) by looking for a `package.json` that exposes
  * the `fireforge` CLI entrypoint, regardless of the npm package scope.
+ *
+ * The result is cached after the first call since it is deterministic
+ * within a process.
  */
 export function getPackageRoot() {
+    if (cachedPackageRoot !== undefined) {
+        return cachedPackageRoot;
+    }
     let current = dirname(fileURLToPath(import.meta.url));
     for (;;) {
         try {
             const packagePath = join(current, 'package.json');
             const pkg = readPackageMetadata(packagePath);
             if (isFireForgePackageMetadata(pkg)) {
+                cachedPackageRoot = current;
                 return current;
             }
         }
@@ -45,6 +53,10 @@ export function getPackageRoot() {
         current = parent;
     }
 }
+/** Clears the cached package root for testing. */
+export function resetPackageRootCacheForTests() {
+    cachedPackageRoot = undefined;
+}
 /** @internal */
 export function isFireForgePackageMetadata(pkg) {
     if (typeof pkg.bin !== 'object' || pkg.bin === null || Array.isArray(pkg.bin)) {

package/dist/src/utils/process.js

@@ -29,6 +29,11 @@ function createStreamCollector(mirror) {
         getText: () => chunks.join(''),
     };
 }
+function buildSignalFromTimeout(timeout) {
+    if (timeout === undefined)
+        return undefined;
+    return AbortSignal.timeout(timeout);
+}
 function exitCodeFromClose(code, signal) {
     if (code !== null) {
         return code;
@@ -54,7 +59,7 @@ export async function exec(command, args, options = {}) {
             cwd: options.cwd,
             env: { ...process.env, ...options.env },
             stdio: ['ignore', 'pipe', 'pipe'],
-            timeout: options.timeout,
+            signal: buildSignalFromTimeout(options.timeout),
         });
         const out = createStreamCollector();
         const err = createStreamCollector();
@@ -85,7 +90,7 @@ export async function execStream(command, args, options = {}) {
             cwd: options.cwd,
             env: { ...process.env, ...options.env },
             stdio: ['ignore', 'pipe', 'pipe'],
-            timeout: options.timeout,
+            signal: buildSignalFromTimeout(options.timeout),
         });
         child.stdout.on('data', (data) => {
             options.onStdout?.(data.toString());
@@ -114,7 +119,7 @@ export async function execInherit(command, args, options = {}) {
             cwd: options.cwd,
             env: { ...process.env, ...options.env },
             stdio: 'inherit',
-            timeout: options.timeout,
+            signal: buildSignalFromTimeout(options.timeout),
         });
         child.on('error', (error) => {
             reject(error);
@@ -138,7 +143,7 @@ export async function execInheritCapture(command, args, options = {}) {
             cwd: options.cwd,
             env: { ...process.env, ...options.env },
             stdio: ['inherit', 'pipe', 'pipe'],
-            timeout: options.timeout,
+            signal: buildSignalFromTimeout(options.timeout),
         });
         const out = createStreamCollector(process.stdout);
         const err = createStreamCollector(process.stderr);

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

@@ -16,6 +16,24 @@ export declare function isNumber(value: unknown): value is number;
  * @returns True if value is a positive integer
  */
 export declare function isPositiveInteger(value: unknown): value is number;
+/**
+ * Parses a CLI flag value as a positive integer. Throws
+ * {@link InvalidArgumentError} on NaN, non-integer, or non-positive input.
+ *
+ * Intended for use inside Commander `argParser` bodies where the raw
+ * input arrives as a string. Without this wrapper the default pattern
+ * (`parseInt(v, 10)`) silently hands NaN to downstream planners, which
+ * then embed it into filenames / orders instead of failing fast.
+ *
+ * Rejects leading-zero forms ("01"), decimals ("1.5"), whitespace, and
+ * non-numeric garbage via a strict regex — we only accept the canonical
+ * representation so there is no ambiguity between what the user typed
+ * and what the value becomes on disk.
+ *
+ * @param flagName - Flag name to include in the error (e.g. `--order`)
+ * @param rawValue - Raw string value from Commander
+ */
+export declare function parsePositiveIntegerFlag(flagName: string, rawValue: string): number;
 /**
  * Checks whether a value is a boolean.
  * @param value - Value to check
@@ -48,7 +66,7 @@ export declare function assertString(value: unknown, name: string): asserts valu
 export declare function assertObject(value: unknown, name: string): asserts value is Record<string, unknown>;
 /**
  * Validates a Firefox version string.
- * Accepts formats like "146.0", "146.0.1", "140.0esr", "147.0b1"
+ * Accepts formats like "146.0", "146.0.1", "146.0esr", "147.0b1"
  */
 export declare function isValidFirefoxVersion(version: string): boolean;
 /**
@@ -89,7 +107,7 @@ export declare function inferProductFromVersion(version: string): 'firefox' | 'f
  * Validates that a Firefox product and version are compatible.
  *
  * Rules:
- * - `firefox-esr` requires an ESR version (e.g. "140.0esr", "128.0.1esr").
+ * - `firefox-esr` requires an ESR version (e.g. "146.0esr", "128.0.1esr").
  * - `firefox-beta` requires a beta version (e.g. "147.0b1").
  * - `firefox` (stable) rejects both ESR and beta version strings.
  *

package/dist/src/utils/validation.js

@@ -28,6 +28,29 @@ export function isNumber(value) {
 export function isPositiveInteger(value) {
     return isNumber(value) && Number.isInteger(value) && value > 0;
 }
+/**
+ * Parses a CLI flag value as a positive integer. Throws
+ * {@link InvalidArgumentError} on NaN, non-integer, or non-positive input.
+ *
+ * Intended for use inside Commander `argParser` bodies where the raw
+ * input arrives as a string. Without this wrapper the default pattern
+ * (`parseInt(v, 10)`) silently hands NaN to downstream planners, which
+ * then embed it into filenames / orders instead of failing fast.
+ *
+ * Rejects leading-zero forms ("01"), decimals ("1.5"), whitespace, and
+ * non-numeric garbage via a strict regex — we only accept the canonical
+ * representation so there is no ambiguity between what the user typed
+ * and what the value becomes on disk.
+ *
+ * @param flagName - Flag name to include in the error (e.g. `--order`)
+ * @param rawValue - Raw string value from Commander
+ */
+export function parsePositiveIntegerFlag(flagName, rawValue) {
+    if (!/^[1-9]\d*$/.test(rawValue)) {
+        throw new InvalidArgumentError(`${flagName} must be a positive integer, got "${rawValue}".`, flagName);
+    }
+    return Number.parseInt(rawValue, 10);
+}
 /**
  * Checks whether a value is a boolean.
  * @param value - Value to check
@@ -74,10 +97,10 @@ export function assertObject(value, name) {
 }
 /**
  * Validates a Firefox version string.
- * Accepts formats like "146.0", "146.0.1", "140.0esr", "147.0b1"
+ * Accepts formats like "146.0", "146.0.1", "146.0esr", "147.0b1"
  */
 export function isValidFirefoxVersion(version) {
-    // Stable/ESR: 146.0, 146.0.1, 140.0esr, 128.0.1esr
+    // Stable/ESR: 146.0, 146.0.1, 146.0esr, 128.0.1esr
     // Beta: 147.0b1, 147.0b2
     return /^[1-9]\d{0,2}\.\d+(?:b[1-9]\d*|\.\d+(?:esr)?|esr)?$/.test(version);
 }
@@ -137,7 +160,7 @@ export function inferProductFromVersion(version) {
  * Validates that a Firefox product and version are compatible.
  *
  * Rules:
- * - `firefox-esr` requires an ESR version (e.g. "140.0esr", "128.0.1esr").
+ * - `firefox-esr` requires an ESR version (e.g. "146.0esr", "128.0.1esr").
  * - `firefox-beta` requires a beta version (e.g. "147.0b1").
  * - `firefox` (stable) rejects both ESR and beta version strings.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hominis/fireforge",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "FireForge — a build tool for customizing Firefox",
   "type": "module",
   "main": "./dist/src/index.js",