@hominis/fireforge 0.38.0 → 0.39.0

package/dist/src/core/token-manager.js

@@ -4,14 +4,14 @@ import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { FurnaceError } from '../errors/furnace.js';
 import { toError } from '../utils/errors.js';
 import { pathExists, readText, writeText } from '../utils/fs.js';
-import { warn } from '../utils/logger.js';
+import { info, warn } from '../utils/logger.js';
 import { escapeRegex } from '../utils/regex.js';
 import { validateTokenName } from '../utils/validation.js';
 import { getProjectPaths, loadConfig } from './config.js';
 import { loadFurnaceConfig } from './furnace-config.js';
 import { findDarkMediaCloseIndex, findDarkRootInsertionIndex } from './token-dark-mode.js';
 import { addTokenToDocs } from './token-docs.js';
-import { insertVariantDeclaration, validateVariantSelector, variantBlockHasToken, } from './token-variant.js';
+import { insertVariantDeclaration, validateVariantSelector, variantBlockExists, variantBlockHasToken, } from './token-variant.js';
 /** Returns the token CSS path relative to engine root for a given binary name. */
 export function getTokensCssPath(binaryName) {
     return `browser/themes/shared/${binaryName}-tokens.css`;
@@ -389,6 +389,39 @@ function findCategorySection(lines, category, tokensCssPath) {
     }
     return { categoryLine, sectionEnd };
 }
+/**
+ * Explicit theme-attribute selectors the override path keeps in sync with
+ * the `@media (prefers-color-scheme: dark)` block. Consumer scaffolds that
+ * pair the media query with `:root[data-theme="dark"]` /
+ * `:root[data-theme="light"]` blocks (viewer-toggle theming) require every
+ * themed list to declare identical token sets, so an override add that only
+ * wrote the media block was a guaranteed half-finished edit (FORGE F8).
+ */
+const THEME_ATTRIBUTE_VARIANTS = [
+    { variant: '[data-theme="dark"]', pick: 'dark' },
+    { variant: '[data-theme="light"]', pick: 'light' },
+];
+/**
+ * Mirrors an override's light/dark values into existing top-level
+ * `:root[data-theme="dark"]` / `:root[data-theme="light"]` blocks. Blocks
+ * that do not exist are left alone (scaffolded files have none; behavior is
+ * unchanged there). Idempotent per block. Returns the selectors written.
+ */
+function insertThemeAttributeOverrides(lines, options) {
+    if (options.mode !== 'override' || !options.darkValue)
+        return [];
+    const written = [];
+    for (const { variant, pick } of THEME_ATTRIBUTE_VARIANTS) {
+        if (!variantBlockExists(lines, variant))
+            continue;
+        if (variantBlockHasToken(lines, variant, options.tokenName))
+            continue;
+        const value = pick === 'dark' ? options.darkValue : options.value;
+        insertVariantDeclaration(lines, variant, `  ${options.tokenName}: ${value};`);
+        written.push(`:root${variant}`);
+    }
+    return written;
+}
 function insertDarkModeOverride(lines, options) {
     if (options.mode !== 'override' || !options.darkValue)
         return;
@@ -451,6 +484,10 @@ async function addTokenToCSS(engineDir, options, tokensCssPath) {
     }
     lines.splice(insertIndex, 0, ...insertLines);
     insertDarkModeOverride(lines, options);
+    const themeBlocksWritten = insertThemeAttributeOverrides(lines, options);
+    if (themeBlocksWritten.length > 0) {
+        info(`Override also written to ${themeBlocksWritten.join(' and ')}.`);
+    }
     content = lines.join('\n');
     await writeText(filePath, content);
     return { added: true, categoryCreated };

package/dist/src/core/token-variant.d.ts

@@ -29,6 +29,13 @@ export type VariantValidation = {
  * @param raw - Raw `--variant` value from the CLI / programmatic caller.
  */
 export declare function validateVariantSelector(raw: unknown): VariantValidation;
+/**
+ * True when a top-level `:root<variant>` block exists in `lines`. Used by
+ * the override path to write theme-attribute blocks only when the scaffold
+ * already declares them — `insertVariantDeclaration` would otherwise create
+ * the block, which is only wanted for the explicit `--variant` flow.
+ */
+export declare function variantBlockExists(lines: string[], variant: string): boolean;
 /** True when the `:root<variant>` block already declares `tokenName`. */
 export declare function variantBlockHasToken(lines: string[], variant: string, tokenName: string): boolean;
 /**

package/dist/src/core/token-variant.js

@@ -107,6 +107,15 @@ function findVariantBlockInsertionPoint(lines) {
     }
     return lines.length;
 }
+/**
+ * True when a top-level `:root<variant>` block exists in `lines`. Used by
+ * the override path to write theme-attribute blocks only when the scaffold
+ * already declares them — `insertVariantDeclaration` would otherwise create
+ * the block, which is only wanted for the explicit `--variant` flow.
+ */
+export function variantBlockExists(lines, variant) {
+    return findVariantBlock(lines, variant) !== null;
+}
 /** True when the `:root<variant>` block already declares `tokenName`. */
 export function variantBlockHasToken(lines, variant, tokenName) {
     const block = findVariantBlock(lines, variant);

package/dist/src/core/typecheck-shim.d.ts

@@ -24,6 +24,19 @@ export declare const SHIM_FILENAME = "__fireforge_firefox_globals.d.ts";
  * reason the operator couldn't infer from the docs.
  */
 export declare const SUPPRESSED_DIAGNOSTIC_CODES: ReadonlySet<number>;
+/**
+ * Undefined-free-identifier codes, split out of
+ * {@link SUPPRESSED_DIAGNOSTIC_CODES} (FORGE F12). Unconditional
+ * suppression let a module reference a name with no import or declaration
+ * anywhere and still typecheck with 0 errors — the failure then surfaced
+ * as a runtime `ReferenceError`. Both flows now report these at a
+ * configurable severity (default `'warning'`: visible without breaking
+ * gates; genuine shim gaps are silenced by adding the global to
+ * `extraShim`, or per-run via the `'off'` setting).
+ */
+export declare const UNDEFINED_IDENTIFIER_CODES: ReadonlySet<number>;
+/** Hint appended to reported undefined-identifier diagnostics. */
+export declare const UNDEFINED_IDENTIFIER_HINT: string;
 /**
  * Result of {@link composeShimSource}: the source body to feed into
  * the TS host plus a flag indicating whether the user-supplied extra

package/dist/src/core/typecheck-shim.js

@@ -146,11 +146,26 @@ export const SUPPRESSED_DIAGNOSTIC_CODES = new Set([
     2306, // File '{0}' is not a module.
     2305, // Module '{0}' has no exported member '{1}'.
     2792, // Cannot find module '{0}'. Did you mean to set the 'moduleResolution' option...
-    2304, // Cannot find name '{0}'. (for globals we missed in the shim)
-    2552, // Cannot find name '{0}'. Did you mean '{1}'?
     2580, // Cannot find name '{0}'. Do you need to install type definitions...
     7016, // Could not find a declaration file for module '{0}'.
 ]);
+/**
+ * Undefined-free-identifier codes, split out of
+ * {@link SUPPRESSED_DIAGNOSTIC_CODES} (FORGE F12). Unconditional
+ * suppression let a module reference a name with no import or declaration
+ * anywhere and still typecheck with 0 errors — the failure then surfaced
+ * as a runtime `ReferenceError`. Both flows now report these at a
+ * configurable severity (default `'warning'`: visible without breaking
+ * gates; genuine shim gaps are silenced by adding the global to
+ * `extraShim`, or per-run via the `'off'` setting).
+ */
+export const UNDEFINED_IDENTIFIER_CODES = new Set([
+    2304, // Cannot find name '{0}'.
+    2552, // Cannot find name '{0}'. Did you mean '{1}'?
+]);
+/** Hint appended to reported undefined-identifier diagnostics. */
+export const UNDEFINED_IDENTIFIER_HINT = '(undefined identifier — import or declare it, add the global to the extra shim, ' +
+    'or tune the "undefinedIdentifiers" setting)';
 /** Matches a lone triple-slash `/// <reference path="…" />` directive line. */
 const TRIPLE_SLASH_REFERENCE = /^\s*\/\/\/\s*<reference\s+path\s*=\s*["']([^"']+)["']\s*\/?>\s*$/;
 /**

package/dist/src/core/typecheck.js

@@ -21,7 +21,7 @@
 import { dirname, isAbsolute, relative, resolve } from 'node:path';
 import { pathExists } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
-import { composeShimSource, SHIM_FILENAME, SUPPRESSED_DIAGNOSTIC_CODES } from './typecheck-shim.js';
+import { composeShimSource, SHIM_FILENAME, SUPPRESSED_DIAGNOSTIC_CODES, UNDEFINED_IDENTIFIER_CODES, UNDEFINED_IDENTIFIER_HINT, } from './typecheck-shim.js';
 /**
  * Sentinel string surfaced as a `TypecheckIssue.message` when the
  * project's jsconfig sets `checkJs: false`. Exported so tests can
@@ -131,7 +131,7 @@ export async function runTypecheck(projectRoot, cfg) {
             });
             continue;
         }
-        results.push(await runTypecheckForProject(ts, projectRoot, projectPath, shimSource));
+        results.push(await runTypecheckForProject(ts, projectRoot, projectPath, shimSource, cfg.undefinedIdentifiers ?? 'warning'));
     }
     return results;
 }
@@ -149,7 +149,7 @@ function resolveProjectExtraShim(cfg, projectPath) {
     return cfg.extraShim;
 }
 /** Runs typecheck for a single jsconfig path, isolating its failures. */
-async function runTypecheckForProject(ts, projectRoot, projectPath, shimSource) {
+async function runTypecheckForProject(ts, projectRoot, projectPath, shimSource, undefinedIdentifiers = 'warning') {
     const absConfig = resolve(projectRoot, projectPath);
     if (!(await pathExists(absConfig))) {
         return {
@@ -268,6 +268,17 @@ async function runTypecheckForProject(ts, projectRoot, projectPath, shimSource)
         // can't act on them and they would clutter CI logs.
         if (diag.file?.fileName === shimPath)
             continue;
+        if (UNDEFINED_IDENTIFIER_CODES.has(diag.code)) {
+            if (undefinedIdentifiers === 'off')
+                continue;
+            const issue = diagnosticToIssue(ts, diag, absConfig, projectPath);
+            issues.push({
+                ...issue,
+                category: undefinedIdentifiers,
+                message: `${issue.message} ${UNDEFINED_IDENTIFIER_HINT}`,
+            });
+            continue;
+        }
         issues.push(diagnosticToIssue(ts, diag, absConfig, projectPath));
     }
     verbose(`typecheck: ${projectPath} — analyzed ${String(parsed.fileNames.length)} file(s), found ${String(issues.length)} issue(s)`);

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

@@ -160,6 +160,12 @@ export interface ResetOptions {
  * Options for the discard command.
  */
 export interface DiscardOptions {
+    /**
+     * Restore to pristine upstream (HEAD) instead of the patch-applied
+     * baseline; deletes patch-created files (the pre-0.39.0 semantics —
+     * FORGE F1).
+     */
+    toUpstream?: boolean;
     /** Show what would be discarded without doing it */
     dryRun?: boolean;
     /** Skip confirmation prompt */
@@ -795,6 +801,12 @@ export interface StatusOptions {
      * patch as an ownership conflict.
      */
     ownership?: boolean;
+    /**
+     * Print the recorded test-packaging coverage of the last build baseline
+     * (scope, timestamp, recording invocation) and exit. Read-only — the
+     * counterpart to the out-of-coverage test refusal (FORGE F11).
+     */
+    testCoverage?: boolean;
     /** Output machine-readable JSON instead of human-readable text. */
     json?: boolean;
 }

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

@@ -181,6 +181,14 @@ export interface TypecheckConfig {
      * mismatch). A narrowed project sets `null` here to stay clean.
      */
     projectOverrides?: Record<string, string | null>;
+    /**
+     * How to report undefined free identifiers (TS2304/TS2552). These were
+     * historically suppressed as shim-gap noise, which also hid genuine
+     * missing imports until they crashed at runtime (FORGE F12). Default
+     * `'warning'`: visible without failing the gate. `'error'` makes them
+     * blocking; `'off'` restores the historical suppression.
+     */
+    undefinedIdentifiers?: PatchLintSeverityGate;
 }
 /**
  * Wire command configuration.
@@ -262,6 +270,13 @@ export interface PatchLintConfig {
      * 'off'.
      */
     chromeScriptJsDoc?: PatchLintSeverityGate;
+    /**
+     * How the checkJs pass reports undefined free identifiers
+     * (TS2304/TS2552). Same semantics as `typecheck.undefinedIdentifiers`
+     * (FORGE F12); the two flows share the suppression policy so a patch
+     * cannot pass one and fail the other. Default: 'warning'.
+     */
+    undefinedIdentifiers?: PatchLintSeverityGate;
 }
 /**
  * Build mode for mach.

package/package.json

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