npm - @hominis/fireforge - Versions diffs - 0.18.2 → 0.18.5 - Mend

@hominis/fireforge 0.18.2 → 0.18.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (36) hide show

package/README.md +29 -16
package/dist/src/commands/build.js +27 -12
package/dist/src/commands/config.js +56 -3
package/dist/src/commands/discard.js +93 -1
package/dist/src/commands/doctor.js +17 -4
package/dist/src/commands/download.js +21 -0
package/dist/src/commands/export-all.js +35 -6
package/dist/src/commands/furnace/chrome-doc-templates.d.ts +59 -8
package/dist/src/commands/furnace/chrome-doc-templates.js +95 -12
package/dist/src/commands/furnace/chrome-doc.js +24 -2
package/dist/src/commands/furnace/deploy.js +10 -1
package/dist/src/commands/furnace/init.js +28 -2
package/dist/src/commands/furnace/remove.js +68 -0
package/dist/src/commands/import.js +9 -1
package/dist/src/commands/lint.js +78 -13
package/dist/src/commands/patch/delete.js +2 -4
package/dist/src/commands/patch/lint-ignore.js +2 -4
package/dist/src/commands/patch/reorder.js +2 -4
package/dist/src/commands/patch/tier.js +2 -4
package/dist/src/commands/status.js +39 -1
package/dist/src/commands/test.js +20 -1
package/dist/src/commands/token.js +1 -1
package/dist/src/core/furnace-apply.js +11 -3
package/dist/src/core/furnace-config.js +19 -0
package/dist/src/core/furnace-marker.d.ts +16 -0
package/dist/src/core/furnace-marker.js +23 -0
package/dist/src/core/git.js +66 -10
package/dist/src/core/license-headers.d.ts +8 -0
package/dist/src/core/license-headers.js +15 -1
package/dist/src/core/manifest-rules.js +9 -1
package/dist/src/core/patch-identifier-suggest.d.ts +25 -0
package/dist/src/core/patch-identifier-suggest.js +108 -0
package/dist/src/core/patch-lint.js +8 -0
package/dist/src/core/register-shared-css.d.ts +28 -0
package/dist/src/core/register-shared-css.js +67 -3
package/package.json +1 -1

package/dist/src/commands/furnace/chrome-doc-templates.js CHANGED Viewed

@@ -25,19 +25,49 @@ export const FURNACE_CHROME_DOC_SENTINEL = 'data-furnace-chrome-doc';
  * XHTML shell for a top-level chrome document.
  *
  * The emitted document:
- * - Declares `windowtype="navigator:browser"` when `withTitlebar` is true
- *   so chrome-wide stylesheets that target the browser window still apply.
- * - Emits a titlebar-buttonbox placeholder when `withTitlebar` is true so
- *   platform-native window controls render.
+ * - When `withTitlebar` is true, declares the `navigator:browser` minimum
+ *   set: `windowtype`, `customtitlebar`, default `width`/`height`, and a
+ *   `persist` allowlist for screen position + size + sizemode. Without
+ *   these, a fork-owned chrome doc that ships as the main window opens
+ *   at the OS intrinsic minimum size on first launch and forgets the
+ *   user's last-known geometry across restarts. The titlebar-buttonbox
+ *   placeholder is emitted alongside so platform-native window controls
+ *   render with the matching CSS rules from `generateChromeDocCss`.
+ * - Loads `chrome://global/content/customElements.js` in `<head>` ahead
+ *   of the per-doc subscript. Without it, every `<moz-*>` widget the
+ *   author drops into the body silently degrades to `HTMLUnknownElement`
+ *   and the upstream a11y/keyboard semantics that motivated the use of
+ *   the toolkit widget in the first place are lost. Matches the
+ *   `webrtcIndicator.xhtml` shape upstream uses for non-`browser.xhtml`
+ *   chrome documents.
  * - Links the per-document CSS at `chrome://browser/content/<name>-chrome.css`
  *   and the Fluent bundle `browser/<name>.ftl`.
+ * - Keeps `data-l10n-id` on the leaf `<title>` only. Binding the same key
+ *   on the root `<window>` would cause Fluent's first-paint translation
+ *   pass to overwrite the entire body subtree with the message's text
+ *   value (the standard `data-l10n-id`-on-non-leaf failure mode), since
+ *   the FTL stub gives `<name>-window-title` a value rather than an
+ *   attribute-only message.
  * - Carries the `data-furnace-chrome-doc="<name>"` sentinel so fork-side
  *   patches to upstream platform modules (DevToolsStartup, PageActions, …)
  *   that assume `browser.xhtml`'s DOM can guard against it cheaply. See
  *   the README "Platform module compatibility" section for the pattern.
  */
 export function generateChromeDocXhtml(name, withTitlebar, license) {
-    const windowAttr = withTitlebar ? ' windowtype="navigator:browser"' : '';
+    // navigator:browser minimum set. Carrying every attribute together —
+    // not just `windowtype` — lets a fork that uses the scaffold output
+    // verbatim launch as a real main window: `customtitlebar` opts into the
+    // platform-native title bar handling that pairs with the buttonbox
+    // markup below, the explicit width/height avoid the OS-minimum first
+    // launch, and `persist` lets the platform remember geometry across
+    // restarts via XULStore.
+    const navigatorBrowserAttrs = withTitlebar
+        ? ` windowtype="navigator:browser"
+    customtitlebar="true"
+    width="1024"
+    height="640"
+    persist="screenX screenY width height sizemode"`
+        : '';
     const titlebarMarkup = withTitlebar
         ? `
     <hbox class="titlebar-buttonbox-container">
@@ -50,9 +80,8 @@ export function generateChromeDocXhtml(name, withTitlebar, license) {
 <window
     xmlns="http://www.w3.org/1999/xhtml"
     xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
-    id="${name}-window"${windowAttr}
+    id="${name}-window"${navigatorBrowserAttrs}
     ${FURNACE_CHROME_DOC_SENTINEL}="${name}"
-    data-l10n-id="${name}-window-title"
     role="application">
   <head>
     <meta charset="utf-8" />
@@ -60,6 +89,7 @@ export function generateChromeDocXhtml(name, withTitlebar, license) {
     <link rel="localization" href="browser/${name}.ftl" />
     <link rel="stylesheet" href="chrome://global/skin/global.css" />
     <link rel="stylesheet" href="chrome://browser/content/${name}-chrome.css" />
+    <script src="chrome://global/content/customElements.js"></script>
     <script src="chrome://browser/content/${name}.js"></script>
   </head>
   <body>${titlebarMarkup}
@@ -105,14 +135,42 @@ window.addEventListener(
 `;
 }
 /**
- * Scoped CSS for a chrome document. When `withTitlebar` is false the
- * macOS `.titlebar-button { display: none }` carve-out is emitted so
- * frameless overlay-style documents don't inherit the platform window
- * controls that `global.css` applies by default.
+ * Scoped CSS for a chrome document.
+ *
+ * When `withTitlebar` is true, the matching navigator:browser minimum
+ * CSS is emitted alongside the layout rules: the buttonbox container is
+ * a draggable region (`-moz-window-dragging: drag`) so the user can drag
+ * the window from the title bar, and the buttonbox itself opts into the
+ * platform-native window-button-box appearance so the OS renders the
+ * traffic-light / minimize-maximize-close controls in their canonical
+ * positions. Without these rules the buttonbox markup still draws but
+ * is unstyled and non-draggable, which is the failure mode a fork that
+ * ships the scaffold verbatim hits on first launch.
+ *
+ * When `withTitlebar` is false the macOS `.titlebar-button { display: none }`
+ * carve-out is emitted so frameless overlay-style documents don't inherit
+ * the platform window controls that `global.css` applies by default.
  */
 export function generateChromeDocCss(name, withTitlebar, licenseHeader) {
     const titlebarOverrides = withTitlebar
-        ? ''
+        ? `
+/* navigator:browser minimum titlebar styling. Pairs with the
+   \`customtitlebar="true"\` + \`titlebar-buttonbox\` markup the XHTML
+   template emits when --with-titlebar is set. The container is the drag
+   region; the inner buttonbox opts into the platform-native traffic
+   light / minimize-maximize-close appearance via \`-moz-window-button-box\`. */
+.titlebar-buttonbox-container {
+  -moz-window-dragging: drag;
+  display: flex;
+  align-items: center;
+}
+.titlebar-buttonbox {
+  appearance: auto;
+  -moz-default-appearance: -moz-window-button-box;
+}
+`
         : `
 /* Frameless overlay — suppress the platform titlebar buttons that
@@ -194,4 +252,29 @@ export function jarIncMnEntryForChromeDoc(name) {
 export function localeJarMnEntryForChromeDoc(name) {
     return `    locale/browser/${name}.ftl                    (%browser/${name}.ftl)`;
 }
+/**
+ * Returns true when `jarMnContents` already carries a `[localization]`-style
+ * wildcard rooted at `%browser/` whose pattern would already pick up a
+ * scaffolded `browser/<name>.ftl` file. Recognises:
+ *
+ *   - `(%browser/**\/*.ftl)` — recursive (the upstream shape).
+ *   - `(%browser/*.ftl)` — flat.
+ *
+ * Forks that have migrated entirely to `[localization]` wildcards typically
+ * keep no per-file `locale/...` entries for FTL at all; appending one
+ * there is dead weight at best, and an outright build break when the fork
+ * has also dropped the `% locale browser …` registration. The chrome-doc
+ * scaffolder consults this predicate before its locales/jar.mn append and
+ * skips the per-file write when the wildcard already covers the scaffold's
+ * target path.
+ *
+ * Conservative by design: only wildcards rooted at `%browser/` count, and
+ * a `(%browser/foo.ftl)`-style explicit reference (no `*`) is not treated
+ * as a capture. A fork with a narrower wildcard (e.g. `(%browser/about/*.ftl)`)
+ * is correctly NOT captured by this predicate, because that wildcard would
+ * not pick up the top-level `browser/<name>.ftl` the scaffold writes.
+ */
+export function localesFtlWildcardCapturesScaffoldedName(jarMnContents) {
+    return /\(%browser\/(?:\*\*\/)?\*\.ftl\)/.test(jarMnContents);
+}
 //# sourceMappingURL=chrome-doc-templates.js.map

package/dist/src/commands/furnace/chrome-doc.js CHANGED Viewed

@@ -25,7 +25,7 @@ import { InvalidArgumentError } from '../../errors/base.js';
 import { FurnaceError } from '../../errors/furnace.js';
 import { pathExists, readText, writeText } from '../../utils/fs.js';
 import { intro, note, outro } from '../../utils/logger.js';
-import { generateChromeDocCss, generateChromeDocFtl, generateChromeDocJs, generateChromeDocXhtml, jarIncMnEntryForChromeDoc, jarMnEntriesForChromeDoc, localeJarMnEntryForChromeDoc, } from './chrome-doc-templates.js';
+import { generateChromeDocCss, generateChromeDocFtl, generateChromeDocJs, generateChromeDocXhtml, jarIncMnEntryForChromeDoc, jarMnEntriesForChromeDoc, localeJarMnEntryForChromeDoc, localesFtlWildcardCapturesScaffoldedName, } from './chrome-doc-templates.js';
 import { chromeDocPackagingTestFileName, generateChromeDocPackagingManifest, generateChromeDocPackagingTest, } from './chrome-doc-tests.js';
 /** Chrome-doc name shape: lowercase ASCII, optional hyphens, no leading digit. */
 const CHROME_DOC_NAME_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
@@ -122,7 +122,29 @@ async function performChromeDocMutations(args) {
         await appendJarEntryIfAbsent(jarIncMnPath, jarIncMnEntryForChromeDoc(args.name), journal);
         written.push('browser/themes/shared/jar.inc.mn');
         const localeJarMnPath = join(args.engineDir, 'browser/locales/jar.mn');
-        await appendJarEntryIfAbsent(localeJarMnPath, localeJarMnEntryForChromeDoc(args.name), journal);
+        // Forks that have migrated to a `[localization] (%browser/**/*.ftl)`
+        // wildcard already pick up the scaffolded FTL automatically — appending
+        // a per-file `locale/...` entry on top is at best dead weight and at
+        // worst a build error when the fork has dropped the `% locale browser`
+        // registration the per-file entry depends on. The wildcard predicate
+        // is intentionally narrow: only `%browser/`-rooted globs that end in
+        // `*.ftl` count as a capture.
+        if (await pathExists(localeJarMnPath)) {
+            const existingLocaleJar = await readText(localeJarMnPath);
+            if (localesFtlWildcardCapturesScaffoldedName(existingLocaleJar)) {
+                note(`Locale jar.mn already carries a [localization] wildcard that captures browser/${args.name}.ftl — skipping the per-file entry.`, args.name);
+            }
+            else {
+                await appendJarEntryIfAbsent(localeJarMnPath, localeJarMnEntryForChromeDoc(args.name), journal);
+            }
+        }
+        else {
+            // Preserve the existing "missing locale jar.mn" failure mode: pretend
+            // we still want to append so appendJarEntryIfAbsent surfaces the same
+            // FurnaceError it does for the other two jars. Forks that move the
+            // file deserve the same explicit complaint everywhere.
+            await appendJarEntryIfAbsent(localeJarMnPath, localeJarMnEntryForChromeDoc(args.name), journal);
+        }
         written.push('browser/locales/jar.mn');
         // --with-tests scaffolds an xpcshell packaging verification. All writes
         // go through the same rollback journal so a SIGINT here restores the

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

@@ -5,6 +5,7 @@ import { applyAllComponents, applyCustomComponent, applyOverrideComponent, compu
 import { logApplyResult } from '../../core/furnace-apply-output.js';
 import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, updateFurnaceState, } from '../../core/furnace-config.js';
 import { resolveFtlDir } from '../../core/furnace-constants.js';
+import { resolveFurnaceMarkerComment } from '../../core/furnace-marker.js';
 import { recordFurnaceRollbackFailure, runFurnaceMutation, } from '../../core/furnace-operation.js';
 import { createRollbackJournal, restoreRollbackJournalOrThrow, } from '../../core/furnace-rollback.js';
 import { findOverrideBaseVersionDrift, formatOverrideBaseVersionDriftError, formatOverrideBaseVersionDriftWarning, } from '../../core/furnace-version-drift.js';
@@ -305,6 +306,14 @@ export async function furnaceDeployCommand(projectRoot, name, options = {}) {
     // the plan before deciding whether to refresh the override or acknowledge
     // the new baseline in furnace.json.
     const forgeConfig = await loadConfig(projectRoot);
+    // 2026-04-26 eval Finding 6: when `markerComment` is unset in
+    // fireforge.json, default it to `binaryName.toUpperCase()` so the
+    // furnace-emitted edits to upstream files satisfy
+    // `lintModificationComments` on the next `lint`/`export` round-trip.
+    // The lint rule keys on the same uppercased binaryName, so the
+    // implicit default is identical to what the rule expects. Threaded
+    // through `applyNamedComponent` below.
+    const resolvedMarkerComment = resolveFurnaceMarkerComment(forgeConfig);
     const driftEntries = findOverrideBaseVersionDrift(config, forgeConfig.firefox.version);
     const force = options.force ?? false;
     const scopedDrift = name ? driftEntries.filter((entry) => entry.name === name) : driftEntries;
@@ -317,7 +326,7 @@ export async function furnaceDeployCommand(projectRoot, name, options = {}) {
     // `furnace deploy` runs only contend on the actual mutation.
     const applyOutcome = await runFurnaceMutation(projectRoot, 'deploy-rollback', async (ctx) => {
         if (name) {
-            const namedApplyResult = await applyNamedComponent(name, paths.engine, furnacePaths, config, ftlDir, isDryRun, ctx, projectRoot, forgeConfig.markerComment);
+            const namedApplyResult = await applyNamedComponent(name, paths.engine, furnacePaths, config, ftlDir, isDryRun, ctx, projectRoot, resolvedMarkerComment);
             if (namedApplyResult === 'stock') {
                 return { kind: 'stock' };
             }

package/dist/src/commands/furnace/init.js CHANGED Viewed

@@ -5,6 +5,7 @@ import { text } from '@clack/prompts';
 import { getProjectPaths, loadConfig, mutateConfig, writeConfig } from '../../core/config.js';
 import { createDefaultFurnaceConfig, furnaceConfigExists, writeFurnaceConfig, } from '../../core/furnace-config.js';
 import { DEFAULT_LICENSE } from '../../core/license-headers.js';
+import { registerSharedCSS } from '../../core/register-shared-css.js';
 import { getTokensCssPath } from '../../core/token-manager.js';
 import { generateDefaultTokensCss } from '../../core/token-scaffold.js';
 import { FurnaceError } from '../../errors/furnace.js';
@@ -184,9 +185,11 @@ export async function furnaceInitCommand(projectRoot, options = {}) {
     }
     note(lines.join('\n'), 'Configuration');
     info('Next steps:\n' +
-        '  fireforge furnace scan        — discover engine components\n' +
+        '  fireforge furnace scan         — discover engine components\n' +
         '  fireforge furnace create       — create a new custom component\n' +
-        '  fireforge furnace override     — fork an existing component');
+        '  fireforge furnace override     — fork an existing component\n' +
+        '  fireforge token add            — define a token in the scaffolded tokens CSS\n' +
+        '  fireforge export <tokens.css>  — capture the tokens CSS + its registration in a patch');
     outro('Init complete');
 }
 /**
@@ -251,6 +254,29 @@ async function scaffoldTokensCss(projectRoot) {
         warn(`Could not register tokens CSS in patchLint.rawColorAllowlist: ${toError(error).message}. ` +
             `Add "${tokensCssPath}" manually under patchLint.rawColorAllowlist in fireforge.json if lint flags its contents.`);
     }
+    // 2026-04-26 eval Finding 2: register the tokens CSS in
+    // browser/themes/shared/jar.inc.mn so the file is owned end-to-end by
+    // tooling. Pre-fix, `furnace init` only scaffolded + allowlisted the
+    // file, so the very next `fireforge status` correctly flagged it as
+    // unmanaged + unregistered and `furnace deploy --dry-run` reported
+    // nothing to deploy — a documented init command turned a clean
+    // project into an unclean one. The CSS lives at the canonical
+    // `browser/themes/shared/<binaryName>-tokens.css` path that the
+    // shared-CSS rule already targets, so the tokens file gets the same
+    // `skin/classic/browser/<name>.css (../shared/<name>.css)` jar.inc.mn
+    // entry as any other shared CSS. Idempotent — running
+    // `furnace init --force` against a registered tree is a no-op.
+    try {
+        const fileBase = `${forgeConfig.binaryName}-tokens.css`;
+        const result = await registerSharedCSS(paths.engine, fileBase, undefined, false);
+        if (!result.skipped) {
+            info(`Registered ${fileBase} in browser/themes/shared/jar.inc.mn`);
+        }
+    }
+    catch (error) {
+        warn(`Could not register tokens CSS in browser/themes/shared/jar.inc.mn: ${toError(error).message}. ` +
+            `Run "fireforge register browser/themes/shared/${forgeConfig.binaryName}-tokens.css" once jar.inc.mn is reachable.`);
+    }
     return { tokensCssPath };
 }
 //# sourceMappingURL=init.js.map

package/dist/src/commands/furnace/remove.js CHANGED Viewed

@@ -212,6 +212,64 @@ async function cleanupCustomTestFiles(name, projectRoot, journal) {
     }
     return { partialFailures };
 }
+/**
+ * Removes the MochiKit test scaffold a `furnace create --with-tests
+ * --test-style mochikit` produced for the component (matches the rename
+ * counterpart in `rename.ts`). The test file is `test_<name>.html` under
+ * `engine/toolkit/content/tests/widgets/` and the registration is the
+ * `["test_<name>.html"]` entry in the same directory's `chrome.toml`.
+ *
+ * 2026-04-25 eval Finding 13: the prior cleanup only handled the
+ * browser-chrome mochitest layout under `browser/base/content/test/
+ * <binary>/`, which left mochikit-style scaffolds and their toml entries
+ * orphaned after `furnace remove`. The post-rename name passed in here
+ * is the canonical one written to disk by deploy/rename, so the file
+ * basenames match without needing to re-derive from the old name.
+ *
+ * Best-effort: each step warns on failure rather than throwing so the
+ * rest of the remove transaction proceeds. The journal still snapshots
+ * touched files so the outer rollback can restore them on a later
+ * failure in the same operation.
+ */
+async function cleanupCustomMochikitTestFiles(name, projectRoot, journal) {
+    const partialFailures = [];
+    const paths = getProjectPaths(projectRoot);
+    const widgetsTestDir = join(paths.engine, 'toolkit/content/tests/widgets');
+    if (!(await pathExists(widgetsTestDir))) {
+        return { partialFailures };
+    }
+    const testFileName = `test_${name}.html`;
+    const testFilePath = join(widgetsTestDir, testFileName);
+    try {
+        if (await pathExists(testFilePath)) {
+            await snapshotFile(journal, testFilePath);
+            await unlink(testFilePath);
+            info(`Deleted mochikit test file: toolkit/content/tests/widgets/${testFileName}`);
+        }
+    }
+    catch (error) {
+        const msg = `Could not delete mochikit test file ${testFileName} — ${toError(error).message}. Remove it manually if needed.`;
+        warn(msg);
+        partialFailures.push(msg);
+    }
+    const chromeTomlPath = join(widgetsTestDir, 'chrome.toml');
+    try {
+        if (await pathExists(chromeTomlPath)) {
+            const toml = await readText(chromeTomlPath);
+            const headerLine = `["${testFileName}"]`;
+            if (toml.includes(headerLine)) {
+                await snapshotFile(journal, chromeTomlPath);
+                await writeText(chromeTomlPath, removeTomlSection(toml, testFileName));
+            }
+        }
+    }
+    catch (error) {
+        const msg = `Could not update widgets chrome.toml — ${toError(error).message}. Remove the test entry manually if needed.`;
+        warn(msg);
+        partialFailures.push(msg);
+    }
+    return { partialFailures };
+}
 /**
  * Removes generated xpcshell test scaffolds associated with a custom
  * component. 2026-04-24 eval Finding 5: `furnace remove` handled
@@ -433,6 +491,16 @@ export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
                 // versions.
                 const xpcshellResult = await cleanupCustomXpcshellTestFiles(name, projectRoot, journal);
                 testCleanupFailures.push(...xpcshellResult.partialFailures);
+                // 2026-04-25 eval Finding 13: mochikit-style scaffolds
+                // (`--test-style mochikit`) live under
+                // `engine/toolkit/content/tests/widgets/` with `chrome.toml`
+                // entries — neither the browser-chrome path nor the xpcshell
+                // path touches them. Without this pass, a `furnace create
+                // --with-tests --test-style mochikit` followed by `furnace
+                // remove` left the test file and its toml entry referencing a
+                // component that no longer exists.
+                const mochikitResult = await cleanupCustomMochikitTestFiles(name, projectRoot, journal);
+                testCleanupFailures.push(...mochikitResult.partialFailures);
             }
             // Remove entry from furnace.json
             if (type === 'stock') {

package/dist/src/commands/import.js CHANGED Viewed

@@ -74,7 +74,15 @@ async function checkUncommittedPatchFiles(engineDir, patchesDir, forceImport) {
         if (dirtyFiles.length > 0) {
             const unmanagedDirtyFiles = await getUnmanagedDirtyFiles(engineDir, patchesDir, dirtyFiles);
             if (unmanagedDirtyFiles.length === 0) {
-                info('Patch-backed materialized files already match the stored patch stack.');
+                // Common path here: operator just ran `fireforge resolve` to
+                // regenerate a patch from manual conflict edits, so the engine
+                // already carries the patch's effects. The import below will
+                // still re-apply each patch (a no-op for files whose contents
+                // already match), so phrase the line as "no resync needed"
+                // rather than "patches already applied" — the latter contradicts
+                // the "Applied N patch(es)" summary `applyPatchesWithContinue`
+                // prints next, which the 2026-04-25 eval flagged as ambiguous.
+                info('Patch-touched files already match the stored patch stack — no engine resync needed before re-applying.');
             }
             else if (!forceImport) {
                 warn('Uncommitted changes detected in files that patches will modify:');

package/dist/src/commands/lint.js CHANGED Viewed

@@ -3,6 +3,7 @@ import { stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { isBrandingManagedPath } from '../core/branding.js';
 import { getProjectPaths, loadConfig } from '../core/config.js';
+import { collectFurnaceManagedPrefixes } from '../core/furnace-config.js';
 import { getStatusWithCodes, hasChanges, isGitRepository } from '../core/git.js';
 import { getAllDiff, getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { expandUntrackedDirectoryEntries, getModifiedFilesInDir, getUntrackedFiles, getUntrackedFilesInDir, getWorkingTreeStatus, } from '../core/git-status.js';
@@ -35,7 +36,7 @@ import { stripEnginePrefix } from '../utils/paths.js';
  * previous behaviour: passing a branding file explicitly still lints
  * it, so operators who need to audit branding content can do so.
  */
-async function resolveLintDiff(engineDir, files, binaryName) {
+async function resolveLintDiff(engineDir, files, binaryName, furnacePrefixes) {
     if (files.length > 0) {
         const collectedFiles = new Set();
         let fileStatuses;
@@ -115,16 +116,31 @@ async function resolveLintDiff(engineDir, files, binaryName) {
         const expanded = await expandUntrackedDirectoryEntries(engineDir, rawStatus);
         const allPaths = [...new Set(expanded.map((entry) => entry.file))];
         const nonBrandingPaths = allPaths.filter((path) => !isBrandingManagedPath(path, binaryName));
-        const excludedCount = allPaths.length - nonBrandingPaths.length;
-        if (excludedCount > 0) {
-            info(`Excluded ${excludedCount} tool-managed branding file${excludedCount === 1 ? '' : 's'} from lint. Pass the path explicitly or use \`fireforge lint <path>\` to include them.`);
+        const brandingExcluded = allPaths.length - nonBrandingPaths.length;
+        // Drop Furnace-managed paths the same way branding is dropped: their
+        // contents are tool output (overrides, custom widgets, preview-
+        // generated stories) that the operator did not author and never
+        // intended to land on the patch queue. Without this carve-out, a
+        // post-`furnace preview` aggregate `lint` failed with one
+        // `missing-license-header` error per generated story file (eval
+        // Finding 19) — each story is intentionally header-less because it's
+        // re-generated from component metadata on every preview run.
+        const filteredPaths = furnacePrefixes
+            ? nonBrandingPaths.filter((path) => ![...furnacePrefixes].some((p) => path.startsWith(p)))
+            : nonBrandingPaths;
+        const furnaceExcluded = nonBrandingPaths.length - filteredPaths.length;
+        if (brandingExcluded > 0) {
+            info(`Excluded ${brandingExcluded} tool-managed branding file${brandingExcluded === 1 ? '' : 's'} from lint. Pass the path explicitly or use \`fireforge lint <path>\` to include them.`);
         }
-        if (nonBrandingPaths.length === 0) {
-            info('No non-branding changes to lint.');
+        if (furnaceExcluded > 0) {
+            info(`Excluded ${furnaceExcluded} Furnace-managed file${furnaceExcluded === 1 ? '' : 's'} from lint (deployed components and preview-generated stories). Pass the path explicitly to include them.`);
+        }
+        if (filteredPaths.length === 0) {
+            info('No non-branding, non-Furnace changes to lint.');
             outro('Nothing to lint');
             return null;
         }
-        const diff = await getDiffForFilesAgainstHead(engineDir, nonBrandingPaths.sort());
+        const diff = await getDiffForFilesAgainstHead(engineDir, filteredPaths.sort());
         if (!diff.trim()) {
             info('No diff content to lint.');
             outro('Nothing to lint');
@@ -185,7 +201,13 @@ export async function lintCommand(projectRoot, files, options = {}) {
     // the diff was resolved; hoisting it is cheap and keeps the two
     // call sites close together.
     const config = await loadConfig(projectRoot);
-    const diff = await resolveLintDiff(paths.engine, files, config.binaryName);
+    // Pull the Furnace-managed prefix set up-front so aggregate lint can
+    // mirror the branding exclusion for Furnace material — without it,
+    // preview-generated stories under `browser/components/storybook/
+    // stories/furnace/` show up as license-header errors on every
+    // post-preview lint run.
+    const furnacePrefixes = await collectFurnaceManagedPrefixes(projectRoot);
+    const diff = await resolveLintDiff(paths.engine, files, config.binaryName, furnacePrefixes);
     if (diff === null)
         return;
     const filesAffected = extractAffectedFiles(diff);
@@ -284,7 +306,23 @@ export async function lintCommand(projectRoot, files, options = {}) {
             : '';
         throw new GeneralError(`Patch lint found ${failingErrors.length} ${options.onlyIntroduced ? 'introduced ' : ''}error(s). Fix these before exporting.${cumulativeSuppressed}`);
     }
-    outro('Lint passed with warnings');
+    // Notices are advisory and don't count as warnings — emitting "passed
+    // with warnings" when only notices fired contradicts the preceding
+    // `0 warning(s)` summary line and reads as a regression. Distinguish
+    // the three pass states explicitly. Errors suppressed by
+    // --only-introduced still warrant the "with warnings" outro — they
+    // print as ERROR rows but no longer fail the run, which is the same
+    // contract the operator gets from a real warning.
+    const suppressedErrors = options.onlyIntroduced && errors.length > 0;
+    if (warnings.length > 0 || suppressedErrors) {
+        outro('Lint passed with warnings');
+    }
+    else if (notices.length > 0) {
+        outro('Lint passed with notices');
+    }
+    else {
+        outro('Lint passed');
+    }
 }
 /**
  * Lints each patch in the queue as its own isolated diff, honouring
@@ -310,17 +348,22 @@ async function lintPerPatch(projectRoot, paths) {
     const ctx = await buildPatchQueueContext(paths.patches);
     const issues = [];
     let linted = 0;
+    let skipped = 0;
     for (const patch of manifest.patches) {
         const existing = [];
         for (const f of patch.filesAffected) {
             if (await pathExists(join(paths.engine, f)))
                 existing.push(f);
         }
-        if (existing.length === 0)
+        if (existing.length === 0) {
+            skipped++;
             continue;
+        }
         const diff = await getDiffForFilesAgainstHead(paths.engine, existing);
-        if (!diff.trim())
+        if (!diff.trim()) {
+            skipped++;
             continue;
+        }
         const ignore = patch.lintIgnore?.length ? new Set(patch.lintIgnore) : undefined;
         const decision = resolvePatchSizeTier(existing, patch.tier);
         if (decision.tier === 'branding') {
@@ -339,7 +382,21 @@ async function lintPerPatch(projectRoot, paths) {
     // context.
     issues.push(...lintPatchQueue(ctx));
     if (issues.length === 0) {
-        success(`No lint issues found across ${linted} patch(es).`);
+        // 2026-04-26 eval Finding 7: pre-fix the success line read
+        // `No lint issues found across 0 patch(es).` whenever the queue
+        // had not been applied to the engine — every patch's
+        // `filesAffected` filtered out, so `existing` was empty and the
+        // patch was silently skipped. Operators read that as "the queue
+        // is clean" when in reality nothing was checked. Surface the
+        // skipped count and, when nothing was linted at all, point at
+        // `fireforge import` as the missing prerequisite.
+        if (linted === 0 && skipped > 0) {
+            info(`No patches in the queue have been applied to engine/. Run "fireforge import" first if you want lint findings against the staged hunks; otherwise this is expected.`);
+        }
+        const summary = skipped > 0
+            ? `No lint issues found across ${linted} patch(es) (${skipped} skipped — files not present in engine/).`
+            : `No lint issues found across ${linted} patch(es).`;
+        success(summary);
         outro('Lint passed');
         return;
     }
@@ -357,7 +414,15 @@ async function lintPerPatch(projectRoot, paths) {
         outro('Lint failed');
         throw new GeneralError(`Patch lint found ${errors.length} error(s) across ${linted} patch(es). Fix these before exporting.`);
     }
-    outro('Lint passed with warnings');
+    if (warnings.length > 0) {
+        outro('Lint passed with warnings');
+    }
+    else if (notices.length > 0) {
+        outro('Lint passed with notices');
+    }
+    else {
+        outro('Lint passed');
+    }
 }
 /** Registers the lint command on the CLI program. */
 export function registerLint(program, { getProjectRoot, withErrorHandling }) {

package/dist/src/commands/patch/delete.js CHANGED Viewed

@@ -10,6 +10,7 @@
 import { basename } from 'node:path';
 import { getProjectPaths } from '../../core/config.js';
 import { appendHistory, confirmDestructive } from '../../core/destructive.js';
+import { formatPatchNotFoundError } from '../../core/patch-identifier-suggest.js';
 import { buildPatchQueueContext, extractImportSpecifiersWithLines, findForwardImportIgnoreLines, isForwardImportableFile, } from '../../core/patch-lint.js';
 import { withPatchDirectoryLock } from '../../core/patch-lock.js';
 import { loadPatchesManifest, removePatchFileAndManifest, resolvePatchIdentifier, } from '../../core/patch-manifest.js';
@@ -39,10 +40,7 @@ export async function patchDeleteCommand(projectRoot, identifier, options = {})
     }
     const target = resolvePatchIdentifier(identifier, manifest.patches);
     if (!target) {
-        const available = manifest.patches
-            .map((p) => p.name && p.name !== p.filename ? `${p.filename} (name: ${p.name})` : p.filename)
-            .join(', ');
-        throw new InvalidArgumentError(`Patch "${identifier}" not found. Accepted identifiers: ordinal (e.g. 2), filename (e.g. 002-ui-foo.patch), or manifest name (e.g. ui-foo). Available: ${available}`, identifier);
+        throw new InvalidArgumentError(formatPatchNotFoundError(identifier, manifest.patches), identifier);
     }
     // Build the full queue context once so we can scan each patch's newFiles
     // without re-parsing for the dependency check below.

package/dist/src/commands/patch/lint-ignore.js CHANGED Viewed

@@ -22,6 +22,7 @@
 import { getProjectPaths } from '../../core/config.js';
 import { appendHistory } from '../../core/destructive.js';
 import { mutatePatchMetadata } from '../../core/patch-export.js';
+import { formatPatchNotFoundError } from '../../core/patch-identifier-suggest.js';
 import { loadPatchesManifest, resolvePatchIdentifier } from '../../core/patch-manifest.js';
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
 import { toError } from '../../utils/errors.js';
@@ -113,10 +114,7 @@ export async function patchLintIgnoreCommand(projectRoot, identifier, options =
     }
     const target = resolvePatchIdentifier(identifier, manifest.patches);
     if (!target) {
-        const available = manifest.patches
-            .map((p) => p.name && p.name !== p.filename ? `${p.filename} (name: ${p.name})` : p.filename)
-            .join(', ');
-        throw new InvalidArgumentError(`Patch "${identifier}" not found. Accepted identifiers: ordinal (e.g. 2), filename (e.g. 002-ui-foo.patch), or manifest name (e.g. ui-foo). Available: ${available}`, identifier);
+        throw new InvalidArgumentError(formatPatchNotFoundError(identifier, manifest.patches), identifier);
     }
     if (isDryRun) {
         const existing = target.lintIgnore ?? [];

package/dist/src/commands/patch/reorder.js CHANGED Viewed

@@ -11,6 +11,7 @@
 import { Option } from 'commander';
 import { getProjectPaths } from '../../core/config.js';
 import { appendHistory, confirmDestructive, } from '../../core/destructive.js';
+import { formatPatchNotFoundError } from '../../core/patch-identifier-suggest.js';
 import { buildPatchQueueContext, lintPatchQueue, } from '../../core/patch-lint.js';
 import { withPatchDirectoryLock } from '../../core/patch-lock.js';
 import { loadPatchesManifest, renumberPatchesInManifest, resolvePatchIdentifier, } from '../../core/patch-manifest.js';
@@ -270,10 +271,7 @@ export async function patchReorderCommand(projectRoot, identifier, options = {})
     }
     const target = resolvePatchIdentifier(identifier, manifest.patches);
     if (!target) {
-        const available = manifest.patches
-            .map((p) => p.name && p.name !== p.filename ? `${p.filename} (name: ${p.name})` : p.filename)
-            .join(', ');
-        throw new InvalidArgumentError(`Patch "${identifier}" not found. Accepted identifiers: ordinal (e.g. 2), filename (e.g. 002-ui-foo.patch), or manifest name (e.g. ui-foo). Available: ${available}`, identifier);
+        throw new InvalidArgumentError(formatPatchNotFoundError(identifier, manifest.patches), identifier);
     }
     const { destinationOrder, anchorFilename } = resolveDestination(target, manifest.patches, options);
     const renameMap = computeRenameMap(manifest.patches, target, destinationOrder);

package/dist/src/commands/patch/tier.js CHANGED Viewed

@@ -18,6 +18,7 @@ import { Option } from 'commander';
 import { getProjectPaths } from '../../core/config.js';
 import { appendHistory } from '../../core/destructive.js';
 import { updatePatchMetadata } from '../../core/patch-export.js';
+import { formatPatchNotFoundError } from '../../core/patch-identifier-suggest.js';
 import { loadPatchesManifest, resolvePatchIdentifier } from '../../core/patch-manifest.js';
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
 import { toError } from '../../utils/errors.js';
@@ -56,10 +57,7 @@ export async function patchTierCommand(projectRoot, identifier, options = {}) {
     }
     const target = resolvePatchIdentifier(identifier, manifest.patches);
     if (!target) {
-        const available = manifest.patches
-            .map((p) => p.name && p.name !== p.filename ? `${p.filename} (name: ${p.name})` : p.filename)
-            .join(', ');
-        throw new InvalidArgumentError(`Patch "${identifier}" not found. Accepted identifiers: ordinal (e.g. 2), filename (e.g. 002-ui-foo.patch), or manifest name (e.g. ui-foo). Available: ${available}`, identifier);
+        throw new InvalidArgumentError(formatPatchNotFoundError(identifier, manifest.patches), identifier);
     }
     const before = target.tier;
     const after = setting ? options.tier : undefined;