@hominis/fireforge 0.27.0 → 0.27.1

package/CHANGELOG.md

@@ -2,11 +2,15 @@
 
 ## 0.27.0
 
+- Added first-class `firefox-devedition` source support and atomic `fireforge source set`.
 - Improved `download --force` git indexing progress with phase, count, and heartbeat output.
+- Added elapsed progress for extraction, initial source commits, and rebase/re-export patch refreshes.
 - Added `re-export --files --allow-shrink` so patch ownership shrinkage is refused unless explicitly acknowledged, with clearer dry-run previews.
 - Surfaced likely new sibling files during plain re-export and aligned verify/status ownership reporting for unowned worktree changes.
 - Preserved patch-owned branding `configure.sh` settings during build preflight.
-- Added custom element registration support for Furnace validate/apply.
+- Added custom element registration support for Furnace validate/apply and Firefox 152-style array-backed ESM registrations.
+- Normalized generated patch artifacts so blank context lines do not trip raw whitespace checks.
+- Improved rebase conflict summaries and added `doctor --post-rebase-audit` for common registration surfaces.
 
 ## 0.26.0
 

package/README.md

@@ -68,7 +68,7 @@ Use `fireforge --help` for the full set of commands.
 When Mozilla publishes a new ESR you need to update the configured Firefox version, download the new source code and reapply the patches:
 
 ```bash
-npx fireforge config firefox.version 145.0.0esr
+npx fireforge source set --version 145.0.0esr --product firefox-esr --sha256 <archive-sha256>
 npx fireforge download --force
 npx fireforge rebase
 ```

package/dist/src/commands/doctor/post-rebase-audit.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorCheckDefinition } from '../doctor-check-core.js';
+export declare const POST_REBASE_AUDIT_CHECK: DoctorCheckDefinition;

package/dist/src/commands/doctor/post-rebase-audit.js

@@ -0,0 +1,86 @@
+// 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 { ok, warning } from '../doctor-check-core.js';
+async function readEngineText(engineDir, relativePath) {
+    const fullPath = join(engineDir, relativePath);
+    if (!(await pathExists(fullPath)))
+        return null;
+    return readText(fullPath);
+}
+async function collectBrowserTomlFiles(root) {
+    const testRoot = join(root, 'browser/base/content/test');
+    if (!(await pathExists(testRoot)))
+        return [];
+    const result = [];
+    async function walk(absDir, relDir) {
+        let entries;
+        try {
+            entries = await readdir(absDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const relPath = relDir ? `${relDir}/${entry.name}` : entry.name;
+            const absPath = join(absDir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(absPath, relPath);
+            }
+            else if (entry.isFile() && entry.name === 'browser.toml') {
+                result.push(`browser/base/content/test/${relPath}`);
+            }
+        }
+    }
+    await walk(testRoot, '');
+    return result.sort();
+}
+async function runPostRebaseAudit(ctx) {
+    const issues = [];
+    const engineDir = ctx.paths.engine;
+    const mozConfigure = await readEngineText(engineDir, 'browser/moz.configure');
+    if (mozConfigure === null) {
+        issues.push('browser/moz.configure is missing');
+    }
+    else if (!mozConfigure.includes('BROWSER_CHROME_URL')) {
+        issues.push('browser/moz.configure does not mention BROWSER_CHROME_URL');
+    }
+    const browserJar = await readEngineText(engineDir, 'browser/base/jar.mn');
+    if (browserJar === null) {
+        issues.push('browser/base/jar.mn is missing');
+    }
+    else if (!/\.xhtml\b/.test(browserJar)) {
+        issues.push('browser/base/jar.mn has no chrome document .xhtml entries');
+    }
+    const customElements = await readEngineText(engineDir, 'toolkit/content/customElements.js');
+    if (customElements === null) {
+        issues.push('toolkit/content/customElements.js is missing');
+    }
+    else if (!customElements.includes('customElements')) {
+        issues.push('toolkit/content/customElements.js does not contain customElements registrations');
+    }
+    const toolkitJar = await readEngineText(engineDir, 'toolkit/content/jar.mn');
+    if (toolkitJar === null) {
+        issues.push('toolkit/content/jar.mn is missing');
+    }
+    else if (!toolkitJar.includes('content/global/widgets/') &&
+        !toolkitJar.includes('content/global/elements/')) {
+        issues.push('toolkit/content/jar.mn has no widget/element exposure entries');
+    }
+    const browserTomls = await collectBrowserTomlFiles(engineDir);
+    if (browserTomls.length === 0) {
+        issues.push('no browser.toml files found under browser/base/content/test');
+    }
+    if (issues.length === 0) {
+        return ok('Post-rebase registration audit');
+    }
+    return warning('Post-rebase registration audit', `${issues.length} suspicious registration surface${issues.length === 1 ? '' : 's'}: ${issues.join('; ')}.`, 'Inspect the named engine paths, refresh any drifted registration patches, then re-run "fireforge doctor --post-rebase-audit".');
+}
+export const POST_REBASE_AUDIT_CHECK = {
+    name: 'Post-rebase registration audit',
+    skipIf: (ctx) => !ctx.options.postRebaseAudit || !ctx.engineExists,
+    dependsOn: ['fireforge.json is valid'],
+    run: runPostRebaseAudit,
+};
+//# sourceMappingURL=post-rebase-audit.js.map

package/dist/src/commands/doctor.js

@@ -10,6 +10,7 @@ import { toError } from '../utils/errors.js';
 import { pathExists } from '../utils/fs.js';
 import { error, info, intro, outro, success, warn } from '../utils/logger.js';
 import { findExecutable } from '../utils/process.js';
+import { POST_REBASE_AUDIT_CHECK } from './doctor/post-rebase-audit.js';
 import { failure, ok, warning } from './doctor-check-core.js';
 import { FURNACE_DOCTOR_CHECKS } from './doctor-furnace.js';
 import { inspectEngineWorkingTree } from './doctor-working-tree.js';
@@ -358,6 +359,7 @@ const DOCTOR_CHECKS = [
         },
         fix: 'Re-export affected files with "fireforge export <paths...>" to create full-file patches',
     },
+    POST_REBASE_AUDIT_CHECK,
     // Furnace checks live in a sibling module so this file stays under the
     // max-lines threshold. Splicing them in as an array preserves the
     // declarative registry contract — each entry remains a single
@@ -466,6 +468,7 @@ export function registerDoctor(program, { getProjectRoot, withErrorHandling }) {
         .option('--repair-patches-manifest', 'Rebuild patches/patches.json from the current patch files before reporting results')
         .option('--repair-furnace', 'Reconcile furnace state: clear stale furnace-state.json entries, re-run furnace apply to fix engine drift, and clear the pending-repair marker set by a failed preview teardown')
         .option('--clear-resolution', 'Clear stale pendingResolution state after the patch queue health check reports no errors')
+        .option('--post-rebase-audit', 'Check common registration surfaces after a Firefox source rebase')
         .action(withErrorHandling(async (options) => {
         const result = await doctorCommand(getProjectRoot(), options);
         if (result.exitCode !== 0) {

package/dist/src/commands/download.js

@@ -249,7 +249,10 @@ export async function downloadCommand(projectRoot, options) {
                     phaseState.value = 'extract';
                     s = spinner(`Extracting Firefox ${version}... (decompressing ~600 MB of source; typically 30–90s)`);
                 }
-            }, config.firefox.sha256);
+            }, config.firefox.sha256, (message) => {
+                if (phaseState.value === 'extract')
+                    s.message(message);
+            });
             if (phaseState.value === 'extract') {
                 s.stop(`Firefox ${version} extracted`);
             }

package/dist/src/commands/manifest.js

@@ -18,6 +18,7 @@ import { registerReset } from './reset.js';
 import { registerResolve } from './resolve.js';
 import { registerRun } from './run.js';
 import { registerSetup } from './setup.js';
+import { registerSource } from './source.js';
 import { registerStatus } from './status.js';
 import { registerTest } from './test.js';
 import { registerToken } from './token.js';
@@ -31,6 +32,7 @@ import { registerWire } from './wire.js';
  */
 export const COMMAND_MANIFEST = [
     { name: 'setup', group: 'project', register: registerSetup },
+    { name: 'source', group: 'project', register: registerSource },
     { name: 'download', group: 'engine', register: registerDownload },
     { name: 'bootstrap', group: 'engine', register: registerBootstrap },
     { name: 'import', group: 'workflow', register: registerImport },

package/dist/src/commands/re-export.js

@@ -10,6 +10,7 @@ import { updatePatchAndMetadata } from '../core/patch-export.js';
 import { getClaimedFiles, loadPatchesManifest, resolvePatchIdentifier, stampPatchVersions, } from '../core/patch-manifest.js';
 import { buildProjectedManifest, enforcePatchPolicy } from '../core/patch-policy.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
+import { elapsedSince } from '../utils/elapsed.js';
 import { toError } from '../utils/errors.js';
 import { pathExists } from '../utils/fs.js';
 import { cancel, info, intro, isCancel, outro, spinner, success, warn } from '../utils/logger.js';
@@ -341,8 +342,9 @@ export async function reExportCommand(projectRoot, patches, options) {
     let reExported = 0;
     const reExportedFilenames = [];
     const progress = spinner('Preparing re-export...');
-    for (const patch of selectedPatches) {
-        progress.message(`Re-exporting ${patch.filename}...`);
+    const startedAt = Date.now();
+    for (const [index, patch] of selectedPatches.entries()) {
+        progress.message(`Re-exporting ${index + 1}/${selectedPatches.length}: ${patch.filename} (${patch.filesAffected.length} file(s), ${elapsedSince(startedAt)} elapsed)...`);
         try {
             const exported = await reExportSinglePatch(patch, paths, manifest, options, isDryRun, config);
             if (exported) {

package/dist/src/commands/rebase/conflict-summary.d.ts

@@ -0,0 +1,12 @@
+export interface RebaseConflictSummary {
+    patchFilename: string;
+    failedFiles: string[];
+    category: string;
+    nextCommands: string[];
+}
+/** Builds a concise operator-facing summary for a failed rebase patch. */
+export declare function buildRebaseConflictSummary(args: {
+    patchFilename: string;
+    error?: string;
+    rejectFiles?: string[];
+}): RebaseConflictSummary;

package/dist/src/commands/rebase/conflict-summary.js

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { extractConflictingFiles } from '../../core/patch-parse.js';
+function normalizeRejectFile(file) {
+    return file.replace(/\.rej$/, '');
+}
+function classifyConflict(files) {
+    if (files.some((file) => file.endsWith('toolkit/content/customElements.js'))) {
+        return 'registration context drift';
+    }
+    if (files.some((file) => file.endsWith('jar.mn') ||
+        file.endsWith('moz.build') ||
+        file.endsWith('browser.toml') ||
+        file.endsWith('browser/moz.configure'))) {
+        return 'manifest context drift';
+    }
+    return 'patch context drift';
+}
+/** Builds a concise operator-facing summary for a failed rebase patch. */
+export function buildRebaseConflictSummary(args) {
+    const failedFiles = [
+        ...new Set([
+            ...extractConflictingFiles(args.error),
+            ...(args.rejectFiles ?? []).map(normalizeRejectFile),
+        ]),
+    ].sort();
+    return {
+        patchFilename: args.patchFilename,
+        failedFiles,
+        category: classifyConflict(failedFiles),
+        nextCommands: [
+            "find engine -name '*.rej'",
+            'edit the affected engine/ files',
+            'fireforge rebase --continue',
+            'fireforge rebase --abort',
+        ],
+    };
+}
+//# sourceMappingURL=conflict-summary.js.map

package/dist/src/commands/rebase/patch-loop.js

@@ -15,9 +15,11 @@ import { extractConflictingFiles } from '../../core/patch-parse.js';
 import { clearRebaseSession, saveRebaseSession } from '../../core/rebase-session.js';
 import { runInSignalCriticalSection } from '../../core/signal-critical.js';
 import { RebaseError } from '../../errors/rebase.js';
+import { elapsedSince } from '../../utils/elapsed.js';
 import { toError } from '../../utils/errors.js';
 import { pathExists } from '../../utils/fs.js';
 import { error, info, outro, spinner, success, warn } from '../../utils/logger.js';
+import { buildRebaseConflictSummary } from './conflict-summary.js';
 import { printSummary } from './summary.js';
 /**
  * Runs the patch application loop, re-exports applied patches, and stamps versions.
@@ -37,7 +39,7 @@ export async function runPatchLoop(projectRoot, session, paths, maxFuzz) {
             await saveRebaseSession(projectRoot, session);
             continue;
         }
-        s.message(`Applying ${entry.filename}...`);
+        s.message(`Applying ${i + 1}/${session.patches.length}: ${entry.filename}...`);
         // Apply + session persist is wrapped in a signal-deferred critical
         // section so a SIGINT / SIGTERM between the filesystem mutation and
         // the session-file update is held until the bookkeeping write lands.
@@ -90,8 +92,24 @@ export async function runPatchLoop(projectRoot, session, paths, maxFuzz) {
                 },
             }));
             s.error(`${entry.filename} failed to apply`);
+            const summary = buildRebaseConflictSummary({
+                patchFilename: entry.filename,
+                ...(result.error !== undefined ? { error: result.error } : {}),
+                ...(result.rejectFiles !== undefined ? { rejectFiles: result.rejectFiles } : {}),
+            });
+            warn(`Conflict summary for ${summary.patchFilename}: ${summary.category}`);
+            if (summary.failedFiles.length > 0) {
+                warn(`  Failed files: ${summary.failedFiles.join(', ')}`);
+            }
+            else {
+                warn('  Failed files: not detected from git output');
+            }
+            info('  Suggested next commands:');
+            for (const command of summary.nextCommands) {
+                info(`    ${command}`);
+            }
             if (result.error) {
-                error(`  Error: ${result.error}`);
+                error(`  Raw apply detail: ${result.error}`);
             }
             if (result.rejectFiles && result.rejectFiles.length > 0) {
                 info(`  .rej files created for manual resolution`);
@@ -167,19 +185,19 @@ async function reExportAppliedPatches(session, paths) {
     if (!manifest)
         return failures;
     const s = spinner('Re-exporting patches...');
-    for (const entry of session.patches) {
-        if (entry.status !== 'applied-clean' && entry.status !== 'applied-fuzz')
-            continue;
+    const reExportable = session.patches.filter((entry) => entry.status === 'applied-clean' || entry.status === 'applied-fuzz');
+    const startedAt = Date.now();
+    for (const [index, entry] of reExportable.entries()) {
         const meta = manifest.patches.find((p) => p.filename === entry.filename);
         if (!meta)
             continue;
-        s.message(`Re-exporting ${entry.filename}...`);
         const existingFiles = [];
         for (const f of meta.filesAffected) {
             if (await pathExists(join(paths.engine, f))) {
                 existingFiles.push(f);
             }
         }
+        s.message(`Re-exporting ${index + 1}/${reExportable.length}: ${entry.filename} (${existingFiles.length}/${meta.filesAffected.length} file(s), ${elapsedSince(startedAt)} elapsed)...`);
         try {
             const diffContent = await getDiffForFilesAgainstHead(paths.engine, existingFiles);
             if (diffContent.trim()) {

package/dist/src/commands/setup-support.js

@@ -19,10 +19,13 @@ function renderLicenseTemplate(license, template, vendor, now = new Date()) {
     return template.replace(/\[year\]/g, String(now.getFullYear())).replace(/\[fullname\]/g, vendor);
 }
 function resolveFirefoxProduct(value, field) {
-    if (value === 'firefox' || value === 'firefox-esr' || value === 'firefox-beta') {
+    if (value === 'firefox' ||
+        value === 'firefox-esr' ||
+        value === 'firefox-beta' ||
+        value === 'firefox-devedition') {
         return value;
     }
-    throw new InvalidArgumentError('Invalid product (use: firefox, firefox-esr, firefox-beta)', field);
+    throw new InvalidArgumentError('Invalid product (use: firefox, firefox-esr, firefox-beta, firefox-devedition)', field);
 }
 function resolveProjectLicense(value, field) {
     if (typeof value === 'string' && isValidProjectLicense(value)) {
@@ -153,6 +156,7 @@ async function promptSetupInputs(options) {
                     { value: 'firefox', label: 'Firefox (stable releases)' },
                     { value: 'firefox-esr', label: 'Firefox ESR (extended support)' },
                     { value: 'firefox-beta', label: 'Firefox Beta (pre-release)' },
+                    { value: 'firefox-devedition', label: 'Firefox Developer Edition' },
                 ],
             });
         },

package/dist/src/commands/setup.js

@@ -71,6 +71,7 @@ export function registerSetup(program, { withErrorHandling }) {
         'firefox',
         'firefox-esr',
         'firefox-beta',
+        'firefox-devedition',
     ]))
         .addOption(new Option('--license <license>', 'Project license').choices([...PROJECT_LICENSES]))
         .option('-f, --force', 'Overwrite existing configuration without prompting')

package/dist/src/commands/source.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+import type { CommandContext } from '../types/cli.js';
+import type { SourceSetOptions } from '../types/commands/index.js';
+/**
+ * Atomically updates the Firefox source tuple in fireforge.json.
+ */
+export declare function sourceSetCommand(projectRoot: string, options: SourceSetOptions): Promise<void>;
+/** Registers the source command on the CLI program. */
+export declare function registerSource(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/source.js

@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { Option } from 'commander';
+import { configExists, loadRawConfigDocument, validateConfig, withConfigFileLock, writeConfigDocument, } from '../core/config.js';
+import { GeneralError, InvalidArgumentError } from '../errors/base.js';
+import { info, intro, outro, success } from '../utils/logger.js';
+import { isValidFirefoxProduct } from '../utils/validation.js';
+const SOURCE_PRODUCTS = [
+    'firefox',
+    'firefox-esr',
+    'firefox-beta',
+    'firefox-devedition',
+];
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function cloneRawConfig(raw) {
+    const cloned = structuredClone(raw);
+    if (!isRecord(cloned)) {
+        throw new GeneralError('Cannot update fireforge.json: config clone was not an object.');
+    }
+    return cloned;
+}
+function parseSourceProduct(product) {
+    if (isValidFirefoxProduct(product)) {
+        return product;
+    }
+    throw new InvalidArgumentError(`--product must be one of: ${SOURCE_PRODUCTS.join(', ')}`, '--product');
+}
+/**
+ * Atomically updates the Firefox source tuple in fireforge.json.
+ */
+export async function sourceSetCommand(projectRoot, options) {
+    intro('FireForge Source');
+    if (!(await configExists(projectRoot))) {
+        throw new GeneralError('No fireforge.json found. Run "fireforge setup" to create a project.');
+    }
+    if (options.sha256 !== undefined && options.clearSha256 === true) {
+        throw new InvalidArgumentError('--sha256 cannot be combined with --clear-sha256', '--sha256');
+    }
+    const written = await withConfigFileLock(projectRoot, async () => {
+        const raw = await loadRawConfigDocument(projectRoot);
+        const updated = cloneRawConfig(raw);
+        const firefox = isRecord(updated['firefox']) ? { ...updated['firefox'] } : {};
+        firefox['version'] = options.version;
+        firefox['product'] = options.product;
+        if (options.clearSha256 === true) {
+            delete firefox['sha256'];
+        }
+        else if (options.sha256 !== undefined) {
+            firefox['sha256'] = options.sha256;
+        }
+        updated['firefox'] = firefox;
+        const validated = validateConfig(updated);
+        if (validated.firefox.sha256 !== undefined) {
+            firefox['sha256'] = validated.firefox.sha256;
+        }
+        await writeConfigDocument(projectRoot, updated);
+        return validated.firefox;
+    });
+    success(`Set firefox.version = ${written.version}`);
+    success(`Set firefox.product = ${written.product}`);
+    if (written.sha256 !== undefined) {
+        success(`Set firefox.sha256 = ${written.sha256}`);
+    }
+    else if (options.clearSha256 === true) {
+        info('Cleared firefox.sha256');
+    }
+    outro('');
+}
+/** Registers the source command on the CLI program. */
+export function registerSource(program, { getProjectRoot, withErrorHandling }) {
+    const source = program.command('source').description('Manage Firefox source configuration');
+    source
+        .command('set')
+        .description('Atomically set Firefox source version, product, and optional checksum')
+        .requiredOption('--version <version>', 'Firefox version to base on')
+        .addOption(new Option('--product <product>', 'Firefox product')
+        .choices([...SOURCE_PRODUCTS])
+        .makeOptionMandatory())
+        .option('--sha256 <hash>', 'Pinned SHA-256 for the resolved source archive')
+        .option('--clear-sha256', 'Clear any existing pinned SHA-256')
+        .action(withErrorHandling(async (options) => {
+        const { product, version, sha256, clearSha256 } = options;
+        await sourceSetCommand(getProjectRoot(), {
+            version,
+            product: parseSourceProduct(product),
+            ...(sha256 !== undefined ? { sha256 } : {}),
+            ...(clearSha256 !== undefined ? { clearSha256 } : {}),
+        });
+    }));
+}
+//# sourceMappingURL=source.js.map

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

@@ -67,7 +67,7 @@ export function validateConfig(data) {
         throw new ConfigError('Config field "firefox.version" must be a valid Firefox version (e.g., "145.0")');
     }
     const firefoxProduct = requireConfigString(firefoxRec, 'product', 'firefox.product');
-    const validProducts = ['firefox', 'firefox-esr', 'firefox-beta'];
+    const validProducts = ['firefox', 'firefox-esr', 'firefox-beta', 'firefox-devedition'];
     if (!validProducts.includes(firefoxProduct)) {
         throw new ConfigError(`Config field "firefox.product" must be one of: ${validProducts.join(', ')}`);
     }

package/dist/src/core/firefox-extract.d.ts

@@ -6,7 +6,7 @@
  * @param archivePath - Path to the archive
  * @param destDir - Destination directory
  */
-export declare function extractTarXz(archivePath: string, destDir: string): Promise<void>;
+export declare function extractTarXz(archivePath: string, destDir: string, onProgress?: (message: string) => void): Promise<void>;
 /**
  * Gets the Firefox version from an existing source directory.
  * @param engineDir - Path to the engine directory

package/dist/src/core/firefox-extract.js

@@ -4,6 +4,7 @@
  */
 import { join } from 'node:path';
 import { ExtractionError } from '../errors/download.js';
+import { elapsedSince } from '../utils/elapsed.js';
 import { ensureDir, pathExists } from '../utils/fs.js';
 import { exec, executableExists } from '../utils/process.js';
 /**
@@ -11,15 +12,26 @@ import { exec, executableExists } from '../utils/process.js';
  * @param archivePath - Path to the archive
  * @param destDir - Destination directory
  */
-export async function extractTarXz(archivePath, destDir) {
+export async function extractTarXz(archivePath, destDir, onProgress) {
     if (!(await executableExists('tar'))) {
         throw new ExtractionError(archivePath, new Error('The "tar" command was not found. Please install tar (or ensure it is on your PATH) and try again.'));
     }
     await ensureDir(destDir);
+    const startedAt = Date.now();
+    onProgress?.(`Extracting source archive (${elapsedSince(startedAt)} elapsed)...`);
+    const heartbeat = onProgress
+        ? setInterval(() => {
+            onProgress(`Extracting source archive (${elapsedSince(startedAt)} elapsed)...`);
+        }, 15_000)
+        : null;
+    heartbeat?.unref();
     const result = await exec('tar', ['-xf', archivePath, '-C', destDir]);
+    if (heartbeat)
+        clearInterval(heartbeat);
     if (result.exitCode !== 0) {
         throw new ExtractionError(archivePath, new Error(`tar exited with code ${result.exitCode}:\n${result.stderr}`));
     }
+    onProgress?.(`Source archive extracted (${elapsedSince(startedAt)} elapsed)`);
 }
 /**
  * Gets the Firefox version from an existing source directory.

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

@@ -34,6 +34,7 @@ export declare function getTarballFilename(version: string, product?: FirefoxPro
 export type FirefoxSourcePhase = 'download' | 'extract';
 /** Callback fired at phase transitions during {@link downloadFirefoxSource}. */
 export type FirefoxSourcePhaseCallback = (phase: FirefoxSourcePhase) => void;
+export type FirefoxSourceProgressCallback = (message: string) => void;
 /**
  * Downloads and extracts Firefox source.
  * @param version - Firefox version to download
@@ -45,4 +46,4 @@ export type FirefoxSourcePhaseCallback = (phase: FirefoxSourcePhase) => void;
  *   between phases (`'download'` → `'extract'`). Fires exactly once per
  *   phase even if the cached archive path skips the wire entirely.
  */
-export declare function downloadFirefoxSource(version: string, product: FirefoxProduct, destDir: string, cacheDir: string, onProgress?: ProgressCallback, onPhase?: FirefoxSourcePhaseCallback, expectedSha256?: string): Promise<void>;
+export declare function downloadFirefoxSource(version: string, product: FirefoxProduct, destDir: string, cacheDir: string, onProgress?: ProgressCallback, onPhase?: FirefoxSourcePhaseCallback, expectedSha256?: string, onPhaseProgress?: FirefoxSourceProgressCallback): Promise<void>;

package/dist/src/core/firefox.js

@@ -44,7 +44,7 @@ export function getTarballFilename(version, product = 'firefox') {
  *   between phases (`'download'` → `'extract'`). Fires exactly once per
  *   phase even if the cached archive path skips the wire entirely.
  */
-export async function downloadFirefoxSource(version, product, destDir, cacheDir, onProgress, onPhase, expectedSha256) {
+export async function downloadFirefoxSource(version, product, destDir, cacheDir, onProgress, onPhase, expectedSha256, onPhaseProgress) {
     const archive = resolveArchive(version, product);
     const tarballPath = join(cacheDir, archive.filename);
     // Ensure cache directory exists
@@ -56,7 +56,7 @@ export async function downloadFirefoxSource(version, product, destDir, cacheDir,
     onPhase?.('extract');
     const tempDir = `${destDir}.tmp-${randomUUID()}`;
     try {
-        await extractTarXz(tarballPath, tempDir);
+        await extractTarXz(tarballPath, tempDir, onPhaseProgress);
     }
     catch (error) {
         await removeDir(tempDir);

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

@@ -30,3 +30,10 @@ export declare function validateTagName(tagName: string): void;
  * @param isESModule - Whether the module uses ESM (Pattern B) or not (Pattern A)
  */
 export declare function validateRegistrationPlacement(result: string, tagName: string, isESModule: boolean): void;
+/**
+ * Returns whether a tag appears in the correct customElements.js placement.
+ * ESM entries may either appear textually inside/after DOMContentLoaded or
+ * inside an array declared before DOMContentLoaded and consumed by a for-of
+ * loop inside the listener, as Firefox 152 Beta does for acornElements.
+ */
+export declare function isTagInCorrectCustomElementsPlacement(content: string, tagName: string, isESModule: boolean): boolean;

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

@@ -4,6 +4,7 @@
  * Used after both AST and legacy code paths to avoid duplicating logic.
  */
 import { FurnaceError } from '../errors/furnace.js';
+import { stripJsComments } from '../utils/regex.js';
 /**
  * Regex for valid custom element tag names. A valid name is lowercase, starts
  * with a letter, and contains one or more hyphen-separated groups where each
@@ -36,25 +37,41 @@ export function validateTagName(tagName) {
  * @param isESModule - Whether the module uses ESM (Pattern B) or not (Pattern A)
  */
 export function validateRegistrationPlacement(result, tagName, isESModule) {
-    const dclPattern = /document\.addEventListener\(\s*["']DOMContentLoaded["']/;
     const insertedPos = result.lastIndexOf(`"${tagName}"`);
     if (insertedPos === -1)
         return;
-    const contentBeforeTag = result.slice(0, insertedPos);
-    const hasDCLBefore = dclPattern.test(contentBeforeTag);
-    if (isESModule && !hasDCLBefore && !isTagInArrayConsumedInsideDOMContentLoaded(result, tagName)) {
+    if (!isTagInCorrectCustomElementsPlacement(result, tagName, isESModule)) {
+        if (!isESModule) {
+            throw new FurnaceError(`${tagName} was registered in the DOMContentLoaded/importESModule block (Pattern B) instead of the loadSubScript block (Pattern A). This will cause the component to fail at runtime. The customElements.js file structure may have changed upstream — manual intervention required.`, tagName);
+        }
         throw new FurnaceError(`${tagName} was registered in the loadSubScript block (Pattern A) instead of the DOMContentLoaded/importESModule block (Pattern B). This will cause the component to fail at runtime. The customElements.js file structure may have changed upstream — manual intervention required.`, tagName);
     }
-    if (!isESModule && hasDCLBefore) {
-        throw new FurnaceError(`${tagName} was registered in the DOMContentLoaded/importESModule block (Pattern B) instead of the loadSubScript block (Pattern A). This will cause the component to fail at runtime. The customElements.js file structure may have changed upstream — manual intervention required.`, tagName);
+}
+/**
+ * Returns whether a tag appears in the correct customElements.js placement.
+ * ESM entries may either appear textually inside/after DOMContentLoaded or
+ * inside an array declared before DOMContentLoaded and consumed by a for-of
+ * loop inside the listener, as Firefox 152 Beta does for acornElements.
+ */
+export function isTagInCorrectCustomElementsPlacement(content, tagName, isESModule) {
+    const stripped = stripJsComments(content);
+    const tagPattern = new RegExp(`["']${escapeRegex(tagName)}["']`);
+    const dclMatch = /document\.addEventListener\(\s*["']DOMContentLoaded["']/.exec(stripped);
+    if (!dclMatch) {
+        return !isESModule && tagPattern.test(stripped);
+    }
+    const beforeDcl = stripped.slice(0, dclMatch.index);
+    const afterDcl = stripped.slice(dclMatch.index);
+    const tagBeforeDcl = tagPattern.test(beforeDcl);
+    const tagAfterDcl = tagPattern.test(afterDcl);
+    if (!isESModule) {
+        return tagBeforeDcl && !tagAfterDcl;
     }
+    return (tagAfterDcl || isTagInArrayConsumedInsideDOMContentLoaded(stripped, dclMatch.index, tagName));
 }
-function isTagInArrayConsumedInsideDOMContentLoaded(content, tagName) {
-    const dclMatch = /document\.addEventListener\(\s*["']DOMContentLoaded["']/.exec(content);
-    if (!dclMatch)
-        return false;
-    const beforeDcl = content.slice(0, dclMatch.index);
-    const afterDcl = content.slice(dclMatch.index);
+function isTagInArrayConsumedInsideDOMContentLoaded(content, domContentLoadedIdx, tagName) {
+    const beforeDcl = content.slice(0, domContentLoadedIdx);
+    const afterDcl = content.slice(domContentLoadedIdx);
     const consumedArrays = new Set();
     const forOfPattern = /for\s*\(\s*(?:let|const|var)\s*\[[^)]*\]\s+of\s+([A-Za-z_$][\w$]*)\s*\)/g;
     let match;

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

@@ -9,6 +9,7 @@ import { stripJsComments } from '../utils/regex.js';
 import { getProjectPaths, loadConfig } from './config.js';
 import { getFurnacePaths } from './furnace-config.js';
 import { CUSTOM_ELEMENTS_JS, FTL_DIR, JAR_MN } from './furnace-constants.js';
+import { isTagInCorrectCustomElementsPlacement } from './furnace-registration-validate.js';
 import { getTokensCssPath } from './token-manager.js';
 /**
  * Validates that all Furnace-managed .mjs components are registered in the
@@ -27,21 +28,13 @@ export async function validateRegistrationPatterns(root, config) {
         return issues;
     }
     const content = await readText(filePath);
-    // Find the DOMContentLoaded block boundary (handles multi-line addEventListener)
-    const dclMatch = /document\.addEventListener\(\s*["']DOMContentLoaded["']/.exec(content);
-    if (!dclMatch) {
-        return issues;
-    }
-    const domContentLoadedIdx = dclMatch.index;
     // Get all custom component tag names that use .mjs (all custom components do)
     for (const [name, customConfig] of Object.entries(config.custom)) {
         if (!customConfig.register)
             continue;
-        // Check if this tag is referenced before the DOMContentLoaded block
-        const contentBeforeDCL = stripJsComments(content.slice(0, domContentLoadedIdx));
-        const tagPattern = new RegExp(`"${name}"`);
-        if (tagPattern.test(contentBeforeDCL) &&
-            !isArrayDeclaredBeforeDclAndConsumedInsideDcl(content, domContentLoadedIdx, name)) {
+        const stripped = stripJsComments(content);
+        const tagPattern = new RegExp(`["']${escapeRegex(name)}["']`);
+        if (tagPattern.test(stripped) && !isTagInCorrectCustomElementsPlacement(content, name, true)) {
             issues.push({
                 component: name,
                 severity: 'error',
@@ -52,25 +45,6 @@ export async function validateRegistrationPatterns(root, config) {
     }
     return issues;
 }
-function isArrayDeclaredBeforeDclAndConsumedInsideDcl(content, domContentLoadedIdx, tagName) {
-    const contentBeforeDCL = stripJsComments(content.slice(0, domContentLoadedIdx));
-    const contentAfterDCL = stripJsComments(content.slice(domContentLoadedIdx));
-    const consumedArrays = new Set();
-    const forOfPattern = /for\s*\(\s*(?:let|const|var)\s*\[[^)]*\]\s+of\s+([A-Za-z_$][\w$]*)\s*\)/g;
-    let match;
-    while ((match = forOfPattern.exec(contentAfterDCL)) !== null) {
-        if (match[1])
-            consumedArrays.add(match[1]);
-    }
-    for (const arrayName of consumedArrays) {
-        const declarationPattern = new RegExp(`(?:const|let|var)\\s+${escapeRegex(arrayName)}\\s*=\\s*\\[([\\s\\S]*?)\\];`);
-        const declaration = declarationPattern.exec(contentBeforeDCL);
-        if (declaration?.[1] && new RegExp(`["']${escapeRegex(tagName)}["']`).test(declaration[1])) {
-            return true;
-        }
-    }
-    return false;
-}
 function escapeRegex(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -173,13 +147,7 @@ export async function checkRegistrationConsistency(root, name, config, ftlDir) {
         status.customElementsPresent =
             ceContent.includes(`"${name}"`) || ceContent.includes(`'${name}'`);
         if (status.customElementsPresent) {
-            // Check it's in the correct block (after DOMContentLoaded)
-            const dclMatch = /document\.addEventListener\(\s*["']DOMContentLoaded["']/.exec(ceContent);
-            if (dclMatch) {
-                const afterDcl = ceContent.slice(dclMatch.index);
-                status.customElementsCorrectBlock =
-                    afterDcl.includes(`"${name}"`) || afterDcl.includes(`'${name}'`);
-            }
+            status.customElementsCorrectBlock = isTagInCorrectCustomElementsPlacement(ceContent, name, true);
         }
     }
     return status;

package/dist/src/core/git.js

@@ -2,6 +2,7 @@
 import { readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { GitError, GitIndexingTimeoutError, GitIndexLockError, PatchApplyError, } from '../errors/git.js';
+import { elapsedSince } from '../utils/elapsed.js';
 import { toError } from '../utils/errors.js';
 import { pathExists, removeFile } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
@@ -158,6 +159,7 @@ async function stageAllFilesChunked(dir, scan, options = {}) {
  * SIGINT'd mid-way assuming the process had stalled.
  */
 const GIT_ADD_HEARTBEAT_MS = 15_000;
+const GIT_COMMIT_HEARTBEAT_MS = 15_000;
 async function scanTopLevelSource(dir) {
     const entries = await readdir(dir, { withFileTypes: true });
     return {
@@ -243,6 +245,21 @@ export async function stageAllFiles(dir, options = {}) {
             clearInterval(heartbeatTimer);
     }
 }
+async function createInitialSourceCommit(dir, reportProgress) {
+    const startedAt = Date.now();
+    reportProgress(`Creating initial Firefox source commit (${elapsedSince(startedAt)} elapsed)...`);
+    const heartbeat = setInterval(() => {
+        reportProgress(`Creating initial Firefox source commit (${elapsedSince(startedAt)} elapsed)...`);
+    }, GIT_COMMIT_HEARTBEAT_MS);
+    heartbeat.unref();
+    try {
+        await git(['commit', '-m', 'Initial Firefox source'], dir);
+    }
+    finally {
+        clearInterval(heartbeat);
+    }
+    reportProgress(`Initial Firefox source commit created (${elapsedSince(startedAt)} elapsed).`);
+}
 /**
  * Initializes a new git repository with an orphan branch.
  * @param dir - Directory to initialize
@@ -279,9 +296,8 @@ export async function initRepository(dir, branchName = 'main', options = {}) {
         throw await maybeWrapIndexLockError(dir, error);
     }
     // Create initial commit
-    reportProgress('Creating initial Firefox source commit...');
     try {
-        await git(['commit', '-m', 'Initial Firefox source'], dir);
+        await createInitialSourceCommit(dir, reportProgress);
     }
     catch (error) {
         throw await maybeWrapIndexLockError(dir, error);
@@ -316,9 +332,8 @@ export async function resumeRepository(dir, options = {}) {
         throw await maybeWrapIndexLockError(dir, error);
     }
     // Create initial commit
-    reportProgress('Creating initial Firefox source commit...');
     try {
-        await git(['commit', '-m', 'Initial Firefox source'], dir);
+        await createInitialSourceCommit(dir, reportProgress);
     }
     catch (error) {
         throw await maybeWrapIndexLockError(dir, error);

package/dist/src/core/patch-artifact-normalize.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Normalizes generated patch files for repository whitespace checks.
+ *
+ * Unified diffs conventionally encode a blank context line as a physical line
+ * containing one space. `git apply` also accepts the same hunk as an empty
+ * physical line, while repository-level `git diff --check` flags the
+ * single-space artifact as trailing whitespace in `patches/*.patch`.
+ */
+export declare function normalizePatchArtifact(content: string): string;

package/dist/src/core/patch-artifact-normalize.js

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Normalizes generated patch files for repository whitespace checks.
+ *
+ * Unified diffs conventionally encode a blank context line as a physical line
+ * containing one space. `git apply` also accepts the same hunk as an empty
+ * physical line, while repository-level `git diff --check` flags the
+ * single-space artifact as trailing whitespace in `patches/*.patch`.
+ */
+export function normalizePatchArtifact(content) {
+    return content.replace(/^ $/gm, '');
+}
+//# sourceMappingURL=patch-artifact-normalize.js.map

package/dist/src/core/patch-export-update.js

@@ -4,6 +4,7 @@ import { toError } from '../utils/errors.js';
 import { pathExists, readText, writeText } from '../utils/fs.js';
 import { warn } from '../utils/logger.js';
 import { withPatchDirectoryLock } from './patch-apply.js';
+import { normalizePatchArtifact } from './patch-artifact-normalize.js';
 import { loadPatchesManifest, savePatchesManifest } from './patch-manifest.js';
 import { buildProjectedManifest, enforcePatchPolicy } from './patch-policy.js';
 /**
@@ -38,7 +39,7 @@ export async function updatePatchAndMetadata(patchesDir, filename, newContent, u
         }
         let patchWritten = false;
         try {
-            await writeText(patchPath, newContent);
+            await writeText(patchPath, normalizePatchArtifact(newContent));
             patchWritten = true;
             await savePatchesManifest(patchesDir, manifest);
         }

package/dist/src/core/patch-export.js

@@ -6,6 +6,7 @@ import { pathExists, readText, removeFile, writeText } from '../utils/fs.js';
 import { warn } from '../utils/logger.js';
 import { PATCH_CATEGORIES } from '../utils/validation.js';
 import { discoverPatches, withPatchDirectoryLock } from './patch-apply.js';
+import { normalizePatchArtifact } from './patch-artifact-normalize.js';
 import { findAllPatchesForFilesWithDetails, } from './patch-export-coverage.js';
 import { addPatchToManifest, loadPatchesManifest, PATCHES_MANIFEST, savePatchesManifest, } from './patch-manifest.js';
 import { allocatePolicyOrder, enforcePatchPolicy } from './patch-policy.js';
@@ -95,7 +96,7 @@ export async function commitExportedPatch(input) {
             }
         }
         try {
-            await writeText(patchPath, input.diff);
+            await writeText(patchPath, normalizePatchArtifact(input.diff));
             await addPatchToManifest(input.patchesDir, plan.metadata, plan.supersededPatches.map((p) => p.filename));
             for (const oldPatch of plan.supersededPatches) {
                 await removeFile(oldPatch.path);
@@ -195,7 +196,7 @@ export async function findExistingPatchForFile(patchesDir, filePath) {
  * @param newContent - New patch content
  */
 export async function updatePatch(patchPath, newContent) {
-    await writeText(patchPath, newContent);
+    await writeText(patchPath, normalizePatchArtifact(newContent));
 }
 /**
  * Deletes a patch file and removes it from the manifest.

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, 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, 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 { 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

@@ -17,7 +17,7 @@ export interface SetupOptions {
     binaryName?: string;
     /** Firefox version to base on */
     firefoxVersion?: string;
-    /** Firefox product type (firefox, firefox-esr, firefox-beta) */
+    /** Firefox product type (firefox, firefox-esr, firefox-beta, firefox-devedition) */
     product?: FirefoxProduct;
     /** Overwrite existing configuration without prompting */
     force?: boolean;
@@ -31,6 +31,19 @@ export interface DownloadOptions {
     /** Force re-download, deleting existing engine/ */
     force?: boolean;
 }
+/**
+ * Options for the source command.
+ */
+export interface SourceSetOptions {
+    /** Firefox version to set */
+    version: string;
+    /** Firefox product type */
+    product: FirefoxProduct;
+    /** Optional pinned SHA-256 for the resolved source archive */
+    sha256?: string;
+    /** Clear any existing pinned SHA-256 */
+    clearSha256?: boolean;
+}
 /**
  * Options for the build command.
  */
@@ -651,6 +664,8 @@ export interface DoctorOptions {
      * and side-effect-free.
      */
     repairFurnace?: boolean;
+    /** Run extra post-rebase checks for common Firefox registration surfaces. */
+    postRebaseAudit?: boolean;
 }
 /**
  * Global CLI options available to all commands.

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

@@ -1,7 +1,7 @@
 /**
  * Firefox product type for downloads.
  */
-export type FirefoxProduct = 'firefox' | 'firefox-esr' | 'firefox-beta';
+export type FirefoxProduct = 'firefox' | 'firefox-esr' | 'firefox-beta' | 'firefox-devedition';
 /**
  * Firefox version configuration.
  */

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

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

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: EUPL-1.2
+/** Formats elapsed milliseconds for progress messages. */
+export function formatElapsed(ms) {
+    const totalSeconds = Math.max(0, Math.round(ms / 1000));
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    if (minutes === 0)
+        return `${seconds}s`;
+    return `${minutes}m ${seconds}s`;
+}
+/** Returns formatted elapsed time since a start timestamp from Date.now(). */
+export function elapsedSince(startedAt) {
+    return formatElapsed(Date.now() - startedAt);
+}
+//# sourceMappingURL=elapsed.js.map

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

@@ -71,7 +71,7 @@ export declare function assertObject(value: unknown, name: string): asserts valu
 export declare function isValidFirefoxVersion(version: string): boolean;
 /**
  * Validates a Firefox product string.
- * Accepts: firefox, firefox-esr, firefox-beta
+ * Accepts: firefox, firefox-esr, firefox-beta, firefox-devedition
  */
 export declare function isValidFirefoxProduct(product: string): boolean;
 /**
@@ -108,7 +108,7 @@ export declare function inferProductFromVersion(version: string): 'firefox' | 'f
  *
  * Rules:
  * - `firefox-esr` requires an ESR version (e.g. "140.9.0esr", "128.0.1esr").
- * - `firefox-beta` requires a beta version (e.g. "147.0b1").
+ * - `firefox-beta` and `firefox-devedition` require a beta version (e.g. "147.0b1").
  * - `firefox` (stable) rejects both ESR and beta version strings.
  *
  * @returns An error message if incompatible, or undefined if valid.

package/dist/src/utils/validation.js

@@ -106,10 +106,10 @@ export function isValidFirefoxVersion(version) {
 }
 /**
  * Validates a Firefox product string.
- * Accepts: firefox, firefox-esr, firefox-beta
+ * Accepts: firefox, firefox-esr, firefox-beta, firefox-devedition
  */
 export function isValidFirefoxProduct(product) {
-    return ['firefox', 'firefox-esr', 'firefox-beta'].includes(product);
+    return ['firefox', 'firefox-esr', 'firefox-beta', 'firefox-devedition'].includes(product);
 }
 /**
  * Valid project license SPDX identifiers.
@@ -161,7 +161,7 @@ export function inferProductFromVersion(version) {
  *
  * Rules:
  * - `firefox-esr` requires an ESR version (e.g. "140.9.0esr", "128.0.1esr").
- * - `firefox-beta` requires a beta version (e.g. "147.0b1").
+ * - `firefox-beta` and `firefox-devedition` require a beta version (e.g. "147.0b1").
  * - `firefox` (stable) rejects both ESR and beta version strings.
  *
  * @returns An error message if incompatible, or undefined if valid.
@@ -177,9 +177,9 @@ export function validateFirefoxProductVersionCompatibility(version, product) {
             }
             break;
         case 'firefox-beta':
+        case 'firefox-devedition':
             if (!versionIsBeta) {
-                return (`Product "firefox-beta" requires a beta version (e.g. "147.0b1"), ` +
-                    `but got "${version}"`);
+                return (`Product "${product}" requires a beta version (e.g. "147.0b1"), ` + `but got "${version}"`);
             }
             break;
         case 'firefox':

package/package.json

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