@hominis/fireforge 0.15.6 → 0.15.8

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

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { join } from 'node:path';
-import { multiselect, text } from '@clack/prompts';
+import { text } from '@clack/prompts';
 import { getProjectPaths, loadConfig } from '../../core/config.js';
 import { createDefaultFurnaceConfig, detectComposesCycles, furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, writeFurnaceConfig, } from '../../core/furnace-config.js';
 import { resolveFtlChromeSubPath, tagNameToClassName } from '../../core/furnace-constants.js';
@@ -10,11 +10,14 @@ import { createRollbackJournal, recordCreatedDir, restoreRollbackJournalOrThrow,
 import { isComponentInEngine } from '../../core/furnace-scanner.js';
 import { DEFAULT_LICENSE, getLicenseHeader } from '../../core/license-headers.js';
 import { registerTestManifest } from '../../core/manifest-register.js';
+import { validateSharedFtl } from '../../core/shared-ftl.js';
 import { InvalidArgumentError } from '../../errors/base.js';
 import { FurnaceError } from '../../errors/furnace.js';
 import { toError } from '../../utils/errors.js';
 import { ensureDir, pathExists, readText, writeText } from '../../utils/fs.js';
 import { cancel, intro, isCancel, note, outro, success, warn } from '../../utils/logger.js';
+import { formatDryRunPlan, formatSuccessNote } from './create-dry-run.js';
+import { resolveCreateFeatures } from './create-features.js';
 import { scaffoldMochikitTestFiles } from './create-mochikit.js';
 import { generateCssContent, generateFtlContent, generateMjsContent } from './create-templates.js';
 import { scaffoldXpcshellTestFiles } from './create-xpcshell.js';
@@ -157,40 +160,6 @@ add_task(async function test_${underscored}_defined() {
     }
     return testFiles;
 }
-/**
- * Resolves the localized and registration feature flags for a new component.
- * @param isInteractive - Whether interactive prompts are available
- * @param options - CLI-provided feature flags
- * @returns Final feature selections, or null when creation is cancelled
- */
-async function resolveCreateFeatures(isInteractive, options) {
-    let localized = options.localized ?? false;
-    let register = options.register ?? true;
-    if (isInteractive && options.localized === undefined && options.register === undefined) {
-        const features = await multiselect({
-            message: 'Component features:',
-            options: [
-                {
-                    value: 'localized',
-                    label: 'Fluent localization (data-l10n-id)',
-                },
-                {
-                    value: 'register',
-                    label: 'Register in customElements.js',
-                },
-            ],
-            initialValues: ['register'],
-        });
-        if (isCancel(features)) {
-            cancel('Create cancelled');
-            return null;
-        }
-        const selected = features;
-        localized = selected.includes('localized');
-        register = selected.includes('register');
-    }
-    return { localized, register };
-}
 /**
  * Writes the scaffolded component source files to disk.
  * @param componentDir - Destination component directory
@@ -202,20 +171,25 @@ async function resolveCreateFeatures(isInteractive, options) {
  * @param journal - Optional rollback journal that snapshots files before writes
  * @returns Relative filenames written for the component
  */
-async function writeComponentFiles(componentDir, componentName, className, description, localized, license, ftlChromeSubPath, journal) {
+async function writeComponentFiles(componentDir, componentName, className, description, localized, license, ftlChromeSubPath, sharedFtl, journal) {
     await ensureDir(componentDir);
     const files = [`${componentName}.mjs`, `${componentName}.css`];
     const mjsPath = join(componentDir, `${componentName}.mjs`);
     if (journal)
         await snapshotFile(journal, mjsPath);
-    const mjsContent = generateMjsContent(componentName, className, description, localized, getLicenseHeader(license, 'js'), ftlChromeSubPath);
+    const mjsContent = generateMjsContent(componentName, className, description, localized, getLicenseHeader(license, 'js'), ftlChromeSubPath, sharedFtl);
     await writeText(mjsPath, mjsContent);
     const cssPath = join(componentDir, `${componentName}.css`);
     if (journal)
         await snapshotFile(journal, cssPath);
     const cssContent = generateCssContent(getLicenseHeader(license, 'css'));
     await writeText(cssPath, cssContent);
-    if (localized) {
+    // Skip the per-component .ftl stub when the component participates in a
+    // pre-existing feature-scoped bundle. The shared bundle is owned
+    // elsewhere; dropping a stub here would clutter the workspace with
+    // empty files that never get packaged (furnace apply also skips copying
+    // them in this mode).
+    if (localized && !sharedFtl) {
         const ftlPath = join(componentDir, `${componentName}.ftl`);
         if (journal)
             await snapshotFile(journal, ftlPath);
@@ -276,7 +250,7 @@ async function performCreateMutations(args) {
         // so signal-driven rollback can clean it up even if writeComponentFiles
         // is interrupted mid-ensureDir.
         recordCreatedDir(journal, args.componentDir);
-        files = await writeComponentFiles(args.componentDir, args.componentName, args.className, args.description, args.localized, args.license, args.ftlChromeSubPath, journal);
+        files = await writeComponentFiles(args.componentDir, args.componentName, args.className, args.description, args.localized, args.license, args.ftlChromeSubPath, args.sharedFtl, journal);
         const customEntry = {
             description: args.description,
             targetPath: `toolkit/content/widgets/${args.componentName}`,
@@ -286,6 +260,9 @@ async function performCreateMutations(args) {
         if (args.composes && args.composes.length > 0) {
             customEntry.composes = args.composes;
         }
+        if (args.sharedFtl) {
+            customEntry.sharedFtl = args.sharedFtl;
+        }
         args.config.custom[args.componentName] = customEntry;
         await snapshotFile(journal, args.furnacePaths.furnaceConfig);
         await writeFurnaceConfig(args.projectRoot, args.config);
@@ -374,7 +351,8 @@ function validateComposesTargets(config, componentName, composes) {
  */
 export async function furnaceCreateCommand(projectRoot, name, options = {}) {
     const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
-    intro('Furnace Create');
+    const isDryRun = options.dryRun ?? false;
+    intro(isDryRun ? 'Furnace Create (dry run)' : 'Furnace Create');
     // --- Resolve component name ---
     // Validation runs before we load/create any persisted furnace config so a
     // failed authoring command never auto-creates furnace.json in a fresh
@@ -453,6 +431,42 @@ export async function furnaceCreateCommand(projectRoot, name, options = {}) {
     // does not strand component files behind.
     const composes = options.compose;
     validateComposesTargets(config, componentName, composes);
+    // --- Normalize and validate --shared-ftl ahead of any writes. Shares the
+    // structural rules with furnace-config.ts so the command and the on-disk
+    // schema cannot diverge. Pass the resolved `localized` rather than a
+    // `true` literal so the validator's cross-field check stays anchored to
+    // the real feature selection — `resolveCreateFeatures` promotes localized
+    // upstream, but hard-coding `true` here would hide a regression if that
+    // promotion ever moved or dropped.
+    let sharedFtl;
+    if (options.sharedFtl !== undefined) {
+        const result = validateSharedFtl(options.sharedFtl, { localized });
+        if (!result.ok) {
+            throw new InvalidArgumentError(`--shared-ftl ${result.reason}.`, 'sharedFtl');
+        }
+        sharedFtl = result.value;
+    }
+    // Dry-run exits here — every validation that does not need a write has
+    // already run, so the plan we render reflects exactly what the real
+    // command would do. The mutation phase and its rollback journal are
+    // intentionally skipped so no furnace.json/engine state is touched.
+    if (isDryRun) {
+        const plan = formatDryRunPlan({
+            componentName,
+            localized,
+            register,
+            composes,
+            // Spread rather than assign so the key is absent when sharedFtl is
+            // undefined — the DryRunPlanInput type uses strict-optional shape.
+            ...(sharedFtl !== undefined ? { sharedFtl } : {}),
+            testStyle,
+            description,
+            binaryName: forgeConfig.binaryName,
+        });
+        note(plan, componentName);
+        outro('Dry run complete (no files modified)');
+        return;
+    }
     // All validation is done. Hand off to the transactional mutation helper
     // so any failure restores the workspace and engine to their pre-command
     // state via the shared rollback journal. The mutation runs under the
@@ -470,6 +484,7 @@ export async function furnaceCreateCommand(projectRoot, name, options = {}) {
         localized,
         register,
         composes,
+        sharedFtl,
         componentDir,
         furnacePaths,
         config,
@@ -480,29 +495,13 @@ export async function furnaceCreateCommand(projectRoot, name, options = {}) {
         ftlChromeSubPath,
         operationContext: ctx,
     }));
-    // --- Success ---
-    let noteParts = `Files created in components/custom/${componentName}/:\n` +
-        files.map((f) => `  ${f}`).join('\n');
-    if (testFiles.length > 0) {
-        let testRoot;
-        if (testStyle === 'xpcshell') {
-            testRoot = `engine/browser/base/content/test/${forgeConfig.binaryName}-xpcshell/${componentName}/`;
-        }
-        else if (testStyle === 'mochikit') {
-            testRoot = 'engine/toolkit/content/tests/widgets/';
-        }
-        else {
-            testRoot = `engine/browser/base/content/test/${forgeConfig.binaryName}/`;
-        }
-        noteParts += `\n\nTest files in ${testRoot}:\n` + testFiles.map((f) => `  ${f}`).join('\n');
-    }
-    noteParts +=
-        '\n\n' +
-            'Next steps:\n' +
-            `  1. Edit component files in components/custom/${componentName}/\n` +
-            '  2. Run "fireforge furnace preview" to see it\n' +
-            '  3. Run "fireforge build" to apply and build';
-    note(noteParts, componentName);
+    note(formatSuccessNote({
+        componentName,
+        files,
+        testFiles,
+        testStyle,
+        binaryName: forgeConfig.binaryName,
+    }), componentName);
     outro('Component created');
 }
 //# sourceMappingURL=create.js.map

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

@@ -73,7 +73,7 @@ function registerFurnaceInfoCommands(furnace, context) {
         .option('--localized', 'Include Fluent l10n support')
         .option('--no-register', 'Skip customElements.js registration')
         .option('--with-tests', 'Scaffold a test harness (defaults to MochiKit; see --test-style)')
-        .option('--xpcshell', 'Scaffold an xpcshell test harness (for storage-layer code on forks without tabbrowser); equivalent to --test-style=xpcshell')
+        .option('--xpcshell', 'Scaffold an xpcshell test harness (for storage-layer code on forks without tabbrowser); equivalent to --test-style=xpcshell. Note: xpcshell resolves chrome://global/* URIs but not chrome://browser/* — use --test-style=browser-chrome for browser-chrome-dependent tests.')
         .option('--test-style <style>', "Override the harness written by --with-tests: mochikit (default, runs against non-tabbrowser chrome), browser-chrome (today's scaffold, needs tabbrowser), or xpcshell (headless)", (value) => {
         if (value !== 'mochikit' && value !== 'browser-chrome' && value !== 'xpcshell') {
             throw new Error(`--test-style must be one of: mochikit, browser-chrome, xpcshell. Got: "${value}".`);
@@ -81,6 +81,8 @@ function registerFurnaceInfoCommands(furnace, context) {
         return value;
     })
         .option('--compose <tags>', 'Record stock tags composed internally (metadata only, comma-separated)', (val) => val.split(',').map((s) => s.trim()))
+        .option('--shared-ftl <path>', 'Participate in an existing feature-scoped .ftl at this path (e.g. "browser/hominis-dock.ftl"); skips the per-component .ftl scaffold (implies --localized)')
+        .option('--dry-run', 'Show the planned file set and furnace.json changes without writing')
         .action(withErrorHandling(async (name, options) => {
         await furnaceCreateCommand(getProjectRoot(), name, options);
     }));
@@ -91,6 +93,7 @@ function registerFurnaceInfoCommands(furnace, context) {
         .command('create <name>')
         .description('Scaffold a new top-level chrome document')
         .option('--no-titlebar', 'Frameless overlay-style document (omits titlebar-buttonbox)')
+        .option('--with-tests', 'Scaffold an xpcshell packaging-verification test that probes XCurProcD/chrome/browser/... directly (bypasses the xpcshell chrome:// URI limitation).')
         .action(withErrorHandling(async (name, options) => {
         await furnaceChromeDocCreateCommand(getProjectRoot(), name, pickDefined(options));
     }));

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

@@ -6,10 +6,25 @@ export interface LintCommandOptions {
      * When set, tag each issue as `introduced` or `cumulative` based on
      * whether its file changed since this git revision (e.g. `HEAD`, a
      * branch name, or a SHA). Issues are not filtered — the full set still
-     * prints and the exit code is unchanged — but a diff-scoped summary
-     * makes it trivial to see which errors the current task introduced.
+     * prints — but a diff-scoped summary makes it trivial to see which
+     * errors the current task introduced.
      */
     since?: string;
+    /**
+     * When set together with {@link since}, scope the exit code to issues
+     * tagged `introduced`. Cumulative pre-existing errors still print (so
+     * the operator can still see the full queue state) but do not fail
+     * lint. Motivating case: a branch whose diff is clean but whose repo
+     * already carries unrelated `raw-color` / license-header errors from
+     * older patches. Without this flag, CI treats the clean branch as
+     * failing; with it, a branch "breaks the build" only when its own diff
+     * introduced a new error.
+     *
+     * Requires {@link since}: without a revision to diff against there is
+     * no distinction between introduced and cumulative, so the flag is
+     * rejected up-front rather than silently ignored.
+     */
+    onlyIntroduced?: boolean;
 }
 /**
  * Runs the lint command to check engine changes against patch quality rules.

package/dist/src/commands/lint.js

@@ -19,6 +19,14 @@ import { info, intro, outro, success, warn } from '../utils/logger.js';
  */
 export async function lintCommand(projectRoot, files, options = {}) {
     intro('FireForge Lint');
+    // `--only-introduced` scopes the exit code to `--since`-tagged issues, so
+    // without a revision to anchor the diff there is no "introduced" subset
+    // to scope to — reject the combination up-front so a misconfigured CI
+    // invocation fails loud instead of silently treating every error as
+    // cumulative and passing.
+    if (options.onlyIntroduced && !options.since) {
+        throw new GeneralError('--only-introduced requires --since <git-rev> so introduced-vs-cumulative can be distinguished.');
+    }
     const paths = getProjectPaths(projectRoot);
     if (!(await pathExists(paths.engine))) {
         throw new GeneralError('Firefox source not found. Run "fireforge download" first.');
@@ -139,9 +147,20 @@ export async function lintCommand(projectRoot, files, options = {}) {
     else {
         info(`\nLint: ${errors.length} error(s), ${warnings.length} warning(s)`);
     }
-    if (errors.length > 0) {
+    // Exit-code scope: `--only-introduced` narrows the failure criterion to
+    // issues tagged `introduced`. Cumulative errors still print so the
+    // operator sees the full queue state, but do not fail lint — the
+    // motivating case is a branch whose own diff is clean but whose repo
+    // already carries pre-existing queue errors from older patches.
+    const failingErrors = options.onlyIntroduced
+        ? errors.filter((i) => i.tag === 'introduced')
+        : errors;
+    if (failingErrors.length > 0) {
         outro('Lint failed');
-        throw new GeneralError(`Patch lint found ${errors.length} error(s). Fix these before exporting.`);
+        const cumulativeSuppressed = options.onlyIntroduced && errors.length > failingErrors.length
+            ? ` (${errors.length - failingErrors.length} cumulative error(s) suppressed by --only-introduced)`
+            : '';
+        throw new GeneralError(`Patch lint found ${failingErrors.length} ${options.onlyIntroduced ? 'introduced ' : ''}error(s). Fix these before exporting.${cumulativeSuppressed}`);
     }
     outro('Lint passed with warnings');
 }
@@ -151,11 +170,15 @@ export function registerLint(program, { getProjectRoot, withErrorHandling }) {
         .command('lint [paths...]')
         .description('Lint engine changes against patch quality rules')
         .option('--since <git-rev>', 'Tag issues as [introduced] or [cumulative] based on whether the file changed since <git-rev> (e.g. HEAD, a branch, a SHA)')
+        .option('--only-introduced', 'Fail only on issues tagged [introduced] (requires --since). Cumulative errors still print but do not set a non-zero exit.')
         .action(withErrorHandling(async (paths, options) => {
         const lintOptions = {};
         if (options.since !== undefined) {
             lintOptions.since = options.since;
         }
+        if (options.onlyIntroduced !== undefined) {
+            lintOptions.onlyIntroduced = options.onlyIntroduced;
+        }
         await lintCommand(getProjectRoot(), paths, lintOptions);
     }));
 }

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

@@ -5,7 +5,7 @@ import type { RegisterOptions } from '../types/commands/index.js';
  * Registers a file in the appropriate build manifest.
  *
  * @param projectRoot - Root directory of the project
- * @param filePath - Path relative to engine/
+ * @param filePath - Path relative to engine/ (a leading `engine/` segment is stripped)
  * @param options - Command options
  */
 export declare function registerCommand(projectRoot: string, filePath: string, options?: RegisterOptions): Promise<void>;

package/dist/src/commands/register.js

@@ -6,11 +6,28 @@ import { InvalidArgumentError } from '../errors/base.js';
 import { pathExists } from '../utils/fs.js';
 import { info, intro, outro, success, warn } from '../utils/logger.js';
 import { pickDefined } from '../utils/options.js';
+/**
+ * Strips a leading `engine/` segment (either separator flavour) from a
+ * user-supplied path so operators can pass either a repo-root-relative
+ * path (`engine/browser/base/content/foo.xhtml`) or an engine-relative
+ * path (`browser/base/content/foo.xhtml`). The engine-relative form is
+ * what the manifest writers expect; without this normalisation, the
+ * former failed with a misleading "File not found in engine" pointing
+ * at a doubled path like `engine/engine/browser/...` that operators
+ * had no way to spot from the error message alone.
+ */
+function normalizeEngineRelativePath(filePath) {
+    if (filePath.startsWith('engine/'))
+        return filePath.slice('engine/'.length);
+    if (filePath.startsWith('engine\\'))
+        return filePath.slice('engine\\'.length);
+    return filePath;
+}
 /**
  * Registers a file in the appropriate build manifest.
  *
  * @param projectRoot - Root directory of the project
- * @param filePath - Path relative to engine/
+ * @param filePath - Path relative to engine/ (a leading `engine/` segment is stripped)
  * @param options - Command options
  */
 export async function registerCommand(projectRoot, filePath, options = {}) {
@@ -28,17 +45,23 @@ export async function registerCommand(projectRoot, filePath, options = {}) {
             throw new InvalidArgumentError('--after must be a non-empty substring without control characters or line terminators.', 'after');
         }
     }
+    // Accept either repo-root-relative (`engine/browser/...`) or
+    // engine-relative (`browser/...`) inputs — operators frequently paste
+    // the former from the output of tab completion or `git status`, and
+    // the mismatch used to produce a "File not found" error that named
+    // the original path with no hint that dropping `engine/` would fix it.
+    const engineRelativePath = normalizeEngineRelativePath(filePath);
     // Verify the file exists in engine/ (skip for dry-run)
     if (!options.dryRun) {
         const paths = getProjectPaths(projectRoot);
-        const fullPath = join(paths.engine, filePath);
+        const fullPath = join(paths.engine, engineRelativePath);
         if (!(await pathExists(fullPath))) {
-            throw new InvalidArgumentError(`File not found in engine: ${filePath}`, 'path');
+            throw new InvalidArgumentError(`File not found in engine: ${engineRelativePath}`, 'path');
         }
     }
-    const result = await registerFile(projectRoot, filePath, options.dryRun, options.after);
+    const result = await registerFile(projectRoot, engineRelativePath, options.dryRun, options.after);
     if (options.dryRun) {
-        info(`[dry-run] Would register ${filePath}`);
+        info(`[dry-run] Would register ${engineRelativePath}`);
         info(`  manifest: ${result.manifest}`);
         info(`  entry: ${result.entry}`);
         if (result.previousEntry) {
@@ -54,14 +77,14 @@ export async function registerCommand(projectRoot, filePath, options = {}) {
         return;
     }
     if (result.skipped) {
-        info(`Already registered: ${filePath} in ${result.manifest}`);
+        info(`Already registered: ${engineRelativePath} in ${result.manifest}`);
     }
     else {
         if (result.afterFallback) {
             warn(`--after target "${options.after}" not found, falling back to alphabetical order`);
         }
         const position = result.previousEntry ? ` (after ${result.previousEntry})` : '';
-        success(`Registered ${filePath} in ${result.manifest}${position}`);
+        success(`Registered ${engineRelativePath} in ${result.manifest}${position}`);
         info("hint: Run 'fireforge build --ui' to make the new module available at runtime");
     }
     outro('Done');

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

@@ -1,9 +1,23 @@
 import { Command } from 'commander';
 import type { CommandContext } from '../types/cli.js';
+import type { RunOptions } from '../types/commands/index.js';
+/**
+ * Exit code returned by smoke-run mode when the captured console stream
+ * produced one or more error lines that did NOT match the operator's
+ * allowlist.
+ */
+export declare const SMOKE_EXIT_FAILURE: 12;
+/**
+ * Exit code returned by smoke-run mode when the browser itself exited
+ * with a non-clean status before the smoke window elapsed — i.e. a
+ * launch-side failure we could NOT observe as a console error line
+ * (crash before console wiring, missing profile, etc.).
+ */
+export declare const SMOKE_LAUNCH_FAILURE: 13;
 /**
  * Runs the run command to launch the built browser.
  * @param projectRoot - Root directory of the project
  */
-export declare function runCommand(projectRoot: string): Promise<void>;
+export declare function runCommand(projectRoot: string, options?: RunOptions): Promise<void>;
 /** Registers the run command on the CLI program. */
 export declare function registerRun(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;