@hominis/fireforge 0.21.0 → 0.21.1

package/CHANGELOG.md

@@ -9,6 +9,7 @@
 
 ### Hardening
 
+- **Eval 0.21.0 release-gate fixes.** `export --dry-run` now performs the same supersede and cross-patch ownership checks as real export before calling a plan safe; `furnace deploy --dry-run` validates successful custom-component plans against projected jar.mn registrations; generated Furnace components and browser-chrome test scaffolds are strict-checkJs and lazy-custom-element ready; chrome-doc packaging xpcshell tests no longer trip component-orphan validation; supported optional config keys such as `firefox.sha256` print `(not set)` when absent; and Furnace manifest writes preserve existing top-level/component ordering while appending new entries predictably.
 - **Override removal demotes back to stock.** Removing a Furnace override restores engine files, deletes the override workspace, clears override checksums, and re-adds the component to `stock` tracking instead of dropping it from `furnace.json`. Optional Furnace config fields, including `platformPrefixes`, are preserved across the write.
 - **Rename updates browser-chrome test bodies.** `furnace rename` now rewrites generated browser-chrome mochitest contents as well as filenames and `browser.toml`, preventing stale `waitForElement("<old>")` references after a component rename.
 - **UI build preflight is stricter.** `fireforge build --ui` now refuses before `mach build faster` when the current objdir lacks a completed launchable bundle, guiding fresh imports and partial builds through a full `fireforge build` first.

package/dist/src/commands/config.js

@@ -99,6 +99,11 @@ export async function configCommand(projectRoot, key, value, options = {}) {
         const rawConfig = await loadRawConfigDocument(projectRoot);
         const currentValue = getNestedValue(rawConfig, key);
         if (currentValue === undefined) {
+            if (SUPPORTED_CONFIG_PATHS.includes(key)) {
+                info(`${key} = ${formatValue(currentValue)}`);
+                outro('');
+                return;
+            }
             throw new InvalidArgumentError(`Unknown config key: ${key}`);
         }
         else {

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

@@ -267,6 +267,7 @@ export async function exportAllCommand(projectRoot, options = {}) {
                 filesAffected,
                 sourceEsrVersion: config.firefox.version,
                 explicitSupersede: options.supersede === true,
+                allowOverlap: options.allowOverlap === true,
             });
             outro('Dry run complete — no changes made');
             return;

package/dist/src/commands/export-flow.d.ts

@@ -82,6 +82,7 @@ export interface DryRunPreviewInput {
     filesAffected: string[];
     sourceEsrVersion: string;
     explicitSupersede: boolean;
+    allowOverlap: boolean;
     /** Optional `PatchMetadata.tier` opt-in carried from the CLI. */
     tier?: 'branding';
     /** Optional `PatchMetadata.lintIgnore` carried from the CLI. */

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

@@ -13,10 +13,11 @@ import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, detectNewFi
 import { withPatchDirectoryLock } from '../core/patch-lock.js';
 import { addPatchToManifest, loadPatchesManifest, renumberPatchesInManifest, resolvePatchIdentifier, savePatchesManifest, } from '../core/patch-manifest.js';
 import { extractNewFileContentFromDiff } from '../core/patch-transform.js';
-import { InvalidArgumentError } from '../errors/base.js';
+import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { toError } from '../utils/errors.js';
 import { pathExists, readText, removeFile, writeText } from '../utils/fs.js';
 import { info, warn } from '../utils/logger.js';
+import { findPartialOwnershipOverlap } from './export-shared.js';
 function buildFilenameForPlacement(category, name, order, width) {
     const padded = String(order).padStart(Math.max(3, width), '0');
     return `${padded}-${category}-${sanitizeName(name)}.patch`;
@@ -296,6 +297,11 @@ export async function commitPlacementExport(input) {
  */
 export async function renderDryRunPreview(input) {
     const supersedeDetails = await findAllPatchesForFilesWithDetails(input.patchesDir, input.filesAffected);
+    const supersedingFilenames = new Set(supersedeDetails.map((detail) => detail.patch.filename));
+    const manifest = await loadPatchesManifest(input.patchesDir);
+    const overlap = manifest !== null
+        ? findPartialOwnershipOverlap(manifest, input.filesAffected, supersedingFilenames)
+        : new Map();
     const plan = await planExport({
         patchesDir: input.patchesDir,
         category: input.category,
@@ -329,5 +335,19 @@ export async function renderDryRunPreview(input) {
     else {
         info('\n[dry-run] No patches would be superseded.');
     }
+    if (overlap.size > 0) {
+        const entries = [...overlap.entries()].sort(([a], [b]) => a.localeCompare(b));
+        warn(`\n[dry-run] Would create cross-patch ownership overlap on ${String(entries.length)} file${entries.length === 1 ? '' : 's'}:`);
+        for (const [file, owners] of entries) {
+            warn(`  - ${file} already claimed by: ${owners.join(', ')}`);
+        }
+        warn('The real export would leave the queue verify-failing. Repartition ownership with `fireforge re-export --files <paths> <existing-patch>` before exporting, or pass --allow-overlap to acknowledge the conflict.');
+        if (!input.allowOverlap) {
+            throw new GeneralError('Dry-run detected cross-patch ownership overlap. Pass --allow-overlap to preview the acknowledged conflict, or repartition ownership via `fireforge re-export --files`.');
+        }
+    }
+    else {
+        info('[dry-run] No cross-patch ownership overlap detected.');
+    }
 }
 //# sourceMappingURL=export-flow.js.map

package/dist/src/commands/export.js

@@ -233,6 +233,7 @@ export async function exportCommand(projectRoot, files, options) {
                 filesAffected,
                 sourceEsrVersion: config.firefox.version,
                 explicitSupersede: options.supersede === true,
+                allowOverlap: options.allowOverlap === true,
                 ...(options.tier !== undefined ? { tier: options.tier } : {}),
                 ...(options.lintIgnore !== undefined && options.lintIgnore.length > 0
                     ? { lintIgnore: options.lintIgnore }

package/dist/src/commands/furnace/create-templates.js

@@ -39,12 +39,18 @@ window.MozXULElement?.insertFTLIfNeeded("${ftlPath}");
         ? `
   connectedCallback() {
     super.connectedCallback();
-    this.ownerDocument.l10n?.connectRoot(this.shadowRoot);
+    const { shadowRoot } = this;
+    if (shadowRoot) {
+      this.ownerDocument.l10n?.connectRoot(shadowRoot);
+    }
   }
 
   disconnectedCallback() {
     super.disconnectedCallback();
-    this.ownerDocument.l10n?.disconnectRoot(this.shadowRoot);
+    const { shadowRoot } = this;
+    if (shadowRoot) {
+      this.ownerDocument.l10n?.disconnectRoot(shadowRoot);
+    }
   }
 `
         : '';
@@ -59,6 +65,7 @@ ${ftlModulePreamble}
  * @tagname ${name}
  */
 class ${className} extends MozLitElement {
+  /** @type {Record<string, unknown>} */
   static properties = {};
 
   constructor() {
@@ -72,7 +79,7 @@ ${lifecycleHooks}
     \`;
   }
 }
-customElements.define("${name}", ${className});
+customElements.define("${name}", /** @type {CustomElementConstructor} */ (${className}));
 `;
 }
 /** Generates the .css file content for a custom component. */

package/dist/src/commands/furnace/create.js

@@ -111,6 +111,7 @@ support-files = ["head.js"]
  * @returns {Promise<CustomElementConstructor>}
  */
 async function waitForElement(tag) {
+  document.createElement(tag);
   return customElements.whenDefined(tag);
 }
 `;

package/dist/src/commands/furnace/deploy.js

@@ -364,7 +364,7 @@ export async function furnaceDeployCommand(projectRoot, name, options = {}) {
     }
     const validateSpinner = spinner(isDryRun ? 'Validating (read-only)...' : 'Validating...');
     const failedComponents = getFailedComponentNames(result);
-    const validation = await runDeployValidation(validateSpinner, name, config, furnacePaths, failedComponents, isDryRun, projectRoot);
+    const validation = await runDeployValidation(validateSpinner, name, config, furnacePaths, failedComponents, isDryRun, projectRoot, result.actions);
     if (validation.done)
         return;
     const { totalErrors, totalWarnings, componentCount, skippedValidationCount } = validation;

package/dist/src/commands/furnace/validation-output.d.ts

@@ -1,5 +1,5 @@
 import type { getFurnacePaths } from '../../core/furnace-config.js';
-import type { FurnaceConfig, ValidationIssue } from '../../types/furnace.js';
+import type { DryRunAction, FurnaceConfig, ValidationIssue } from '../../types/furnace.js';
 import { type SpinnerHandle } from '../../utils/logger.js';
 /**
  * Displays validation issues and returns aggregated error and warning counts.
@@ -27,4 +27,4 @@ export type ValidationResult = {
  * @param projectRoot - Root directory of the project
  * @returns Validation counts, or `done: true` if the caller should early-return
  */
-export declare function runDeployValidation(validateSpinner: SpinnerHandle, name: string | undefined, config: FurnaceConfig, furnacePaths: ReturnType<typeof getFurnacePaths>, failedComponents: Set<string>, isDryRun: boolean, projectRoot: string): Promise<ValidationResult>;
+export declare function runDeployValidation(validateSpinner: SpinnerHandle, name: string | undefined, config: FurnaceConfig, furnacePaths: ReturnType<typeof getFurnacePaths>, failedComponents: Set<string>, isDryRun: boolean, projectRoot: string, dryRunActions?: DryRunAction[]): Promise<ValidationResult>;

package/dist/src/commands/furnace/validation-output.js

@@ -24,6 +24,18 @@ export function displayValidationIssues(issues) {
     }
     return [errors, warnings];
 }
+function filterProjectedDryRunIssues(issues, actions) {
+    if (!actions || actions.length === 0)
+        return issues;
+    const plannedJarRegistrations = new Set(actions.filter((action) => action.action === 'register-jar').map((action) => action.component));
+    return issues.filter((issue) => {
+        if (plannedJarRegistrations.has(issue.component) &&
+            (issue.check === 'missing-jar-mn-mjs' || issue.check === 'missing-jar-mn-css')) {
+            return false;
+        }
+        return true;
+    });
+}
 function resolveNamedValidationTarget(name, config, furnacePaths) {
     if (name in config.overrides) {
         return {
@@ -53,7 +65,7 @@ function resolveNamedValidationTarget(name, config, furnacePaths) {
  * @param projectRoot - Root directory of the project
  * @returns Validation counts, or `done: true` if the caller should early-return
  */
-export async function runDeployValidation(validateSpinner, name, config, furnacePaths, failedComponents, isDryRun, projectRoot) {
+export async function runDeployValidation(validateSpinner, name, config, furnacePaths, failedComponents, isDryRun, projectRoot, dryRunActions) {
     let totalErrors = 0;
     let totalWarnings = 0;
     let componentCount = 0;
@@ -75,7 +87,8 @@ export async function runDeployValidation(validateSpinner, name, config, furnace
             validateSpinner.stop('Validation failed');
             throw new FurnaceError(`Component directory not found for "${name}".`, name);
         }
-        const issues = await validateComponent(target.componentDir, name, target.type, config, projectRoot);
+        const rawIssues = await validateComponent(target.componentDir, name, target.type, config, projectRoot);
+        const issues = isDryRun ? filterProjectedDryRunIssues(rawIssues, dryRunActions) : rawIssues;
         componentCount = 1;
         validateSpinner.stop('Validation complete');
         if (issues.length === 0) {
@@ -96,11 +109,14 @@ export async function runDeployValidation(validateSpinner, name, config, furnace
                 continue;
             }
             componentCount++;
-            if (issues.length === 0) {
+            const projectedIssues = isDryRun
+                ? filterProjectedDryRunIssues(issues, dryRunActions)
+                : issues;
+            if (projectedIssues.length === 0) {
                 success(`${componentName} — all checks passed`);
             }
             else {
-                const [errors, warnings] = displayValidationIssues(issues);
+                const [errors, warnings] = displayValidationIssues(projectedIssues);
                 totalErrors += errors;
                 totalWarnings += warnings;
             }

package/dist/src/core/furnace-config-order.d.ts

@@ -0,0 +1,7 @@
+import type { FurnaceConfig } from '../types/furnace.js';
+/**
+ * Orders furnace.json output using the existing file as the primary key
+ * sequence, preserving unknown extension keys and appending newly supported
+ * fields only when needed.
+ */
+export declare function orderFurnaceConfigForWrite(existing: Record<string, unknown> | undefined, config: FurnaceConfig): Record<string, unknown>;

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

@@ -0,0 +1,86 @@
+import { isObject } from '../utils/validation.js';
+const FURNACE_CONFIG_TOP_LEVEL_KEYS = new Set([
+    'version',
+    'componentPrefix',
+    'tokenPrefix',
+    'tokenAllowlist',
+    'platformPrefixes',
+    'runtimeVariables',
+    'tokenHostDocuments',
+    'ftlBasePath',
+    'scanPaths',
+    'stock',
+    'overrides',
+    'custom',
+]);
+function orderObjectLikeExisting(existing, next) {
+    if (!existing)
+        return next;
+    const ordered = {};
+    for (const key of Object.keys(existing)) {
+        if (Object.hasOwn(next, key)) {
+            ordered[key] = next[key];
+        }
+    }
+    for (const key of Object.keys(next)) {
+        if (!Object.hasOwn(ordered, key)) {
+            ordered[key] = next[key];
+        }
+    }
+    return ordered;
+}
+function orderComponentMapLikeExisting(existing, next) {
+    if (!isObject(next))
+        return next;
+    if (!isObject(existing))
+        return next;
+    const ordered = {};
+    for (const key of Object.keys(existing)) {
+        if (Object.hasOwn(next, key)) {
+            const existingValue = existing[key];
+            const nextValue = next[key];
+            ordered[key] =
+                isObject(existingValue) && isObject(nextValue)
+                    ? orderObjectLikeExisting(existingValue, nextValue)
+                    : nextValue;
+        }
+    }
+    for (const key of Object.keys(next)) {
+        if (!Object.hasOwn(ordered, key)) {
+            ordered[key] = next[key];
+        }
+    }
+    return ordered;
+}
+/**
+ * Orders furnace.json output using the existing file as the primary key
+ * sequence, preserving unknown extension keys and appending newly supported
+ * fields only when needed.
+ */
+export function orderFurnaceConfigForWrite(existing, config) {
+    const next = config;
+    if (!existing)
+        return next;
+    const ordered = {};
+    for (const key of Object.keys(existing)) {
+        if (key === 'overrides' || key === 'custom') {
+            ordered[key] = orderComponentMapLikeExisting(existing[key], next[key]);
+        }
+        else if (Object.hasOwn(next, key)) {
+            ordered[key] = next[key];
+        }
+        else if (!FURNACE_CONFIG_TOP_LEVEL_KEYS.has(key)) {
+            ordered[key] = existing[key];
+        }
+    }
+    for (const key of Object.keys(next)) {
+        if (Object.hasOwn(ordered, key))
+            continue;
+        ordered[key] =
+            key === 'overrides' || key === 'custom'
+                ? orderComponentMapLikeExisting(existing[key], next[key])
+                : next[key];
+    }
+    return ordered;
+}
+//# sourceMappingURL=furnace-config-order.js.map

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

@@ -8,6 +8,7 @@ import { isObject, isString } from '../utils/validation.js';
 import { FIREFORGE_DIR } from './config.js';
 import { parseStringArray } from './furnace-config-array-utils.js';
 import { parseCustomConfig } from './furnace-config-custom.js';
+import { orderFurnaceConfigForWrite } from './furnace-config-order.js';
 import { validateRuntimeVariables, validateTokenHostDocuments } from './furnace-config-tokens.js';
 import { resolveFtlDir } from './furnace-constants.js';
 import { detectComposesCycles, validateComposesReferences } from './furnace-graph-utils.js';
@@ -410,7 +411,18 @@ export async function loadFurnaceConfig(root) {
  */
 export async function writeFurnaceConfig(root, config) {
     const paths = getFurnacePaths(root);
-    await writeJson(paths.furnaceConfig, config);
+    let existing;
+    if (await pathExists(paths.furnaceConfig)) {
+        try {
+            const raw = await readJson(paths.furnaceConfig);
+            if (isObject(raw))
+                existing = raw;
+        }
+        catch {
+            existing = undefined;
+        }
+    }
+    await writeJson(paths.furnaceConfig, orderFurnaceConfigForWrite(existing, config));
 }
 /**
  * Stamps every override's `baseVersion` to the supplied version. Used by

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

@@ -233,6 +233,9 @@ async function findOrphanXpcshellScaffolds(root, config) {
     for (const entry of entries) {
         if (known.has(entry))
             continue;
+        const chromeDocPackagingTest = join(parentAbs, entry, `test_${entry}_packaging.js`);
+        if (await pathExists(chromeDocPackagingTest))
+            continue;
         issues.push({
             component: entry,
             severity: 'error',

package/package.json

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