@hominis/fireforge 0.9.0 → 0.10.1

package/CHANGELOG.md

@@ -1,7 +1,33 @@
 # Changelog
 
+## 0.10.0
+
+### Patch workflow validation
+
+- Re-export now runs the same patch lint gate as export and export-all before writing patch files or manifest metadata.
+- `re-export --skip-lint` now downgrades lint errors to warnings consistently, while default re-export blocks on lint errors and keeps artifacts unchanged.
+- Raw CSS colors introduced by a patch are now patch lint errors, matching Furnace validation, without blocking on unrelated pre-existing upstream raw colors.
+- Furnace accessibility validation now warns about missing ARIA roles only for generic interactive markup, so native semantic elements are not pushed toward redundant ARIA.
+
+### General improvements
+
+- getPackageRoot up to this point expected hardcoded `@hominis/fireforge`, was changed to just the package name for potential forks and more flexibility when changing project name.
+- Some test generators were derived from early Hominis Browser fork additions, the references to Hominis have been replaced with generic naming.
+
+### Build and Git reliability
+
+- Build preflight now fails clearly when multiple build artifact directories make the target ambiguous.
+- Git diff and status helpers now surface command failures instead of silently treating failed commands as empty output.
+- Stale lock cleanup now distinguishes disappearance races from real cleanup failures.
+
+### Packaging
+
+- Package metadata and smoke tests now use version `0.10.0`.
+- npm install instructions use the scoped `@hominis/fireforge` package name.
+- Packaging and full Firefox integration helpers now handle platform-specific npm and mozconfig names more consistently.
+
 ## 0.9.0
 
 ### npm release
 
-- Package is now installable via `npm install fireforge` or `npm install -g fireforge`.
+- Package is now installable via `npm install @hominis/fireforge` or `npm install -g @hominis/fireforge`.

package/README.md

@@ -1,10 +1,16 @@
 # FireForge
 
+[![npm version](https://img.shields.io/npm/v/@hominis/fireforge)](https://www.npmjs.com/package/@hominis/fireforge)
+[![license](https://img.shields.io/npm/l/@hominis/fireforge)](LICENSE.md)
+[![node](https://img.shields.io/node/v/@hominis/fireforge)](package.json)
+[![types](https://img.shields.io/npm/types/@hominis/fireforge)](https://www.npmjs.com/package/@hominis/fireforge)
+[![npm downloads](https://img.shields.io/npm/dm/@hominis/fireforge)](https://www.npmjs.com/package/@hominis/fireforge)
+
 **Build and maintain your own Firefox-based browser with a patch-first workflow.**
 
 FireForge gives you a toolkit for forking Firefox: download a specific ESR release, manage your customisations as an ordered stack of contextual patches, survive version upgrades with semi-automated rebase, wire custom code into Mozilla's startup paths, and build the result. It also ships **Furnace**, a component system for creating and overriding Firefox custom elements.
 
-Inspired by [fern.js](https://github.com/nicktrosper/user-agent-desktop?tab=readme-ov-file#user-agent-desktop) and [Melon](https://github.com/nicktrosper/nicktrosper-melon).
+Inspired by [fern.js](https://github.com/ghostery/user-agent-desktop) and [Melon](https://github.com/dothq/melon).
 
 ---
 
@@ -13,7 +19,7 @@ Inspired by [fern.js](https://github.com/nicktrosper/user-agent-desktop?tab=read
 ```bash
 mkdir mybrowser && cd mybrowser
 npm init -y
-npm install --save-dev fireforge
+npm install --save-dev @hominis/fireforge
 
 npx fireforge setup              # interactive project init
 npx fireforge download            # fetch Firefox source (~1 GB)
@@ -165,14 +171,14 @@ If the manifest drifts after an interrupted export or manual edits, `fireforge i
 <details>
 <summary>Patch lint checks</summary>
 
-`fireforge lint` runs automatically during export. Use `--skip-lint` to downgrade errors to warnings, though I would recommend against making that a habit.
+`fireforge lint` runs automatically during export, export-all, and re-export. Use `--skip-lint` to downgrade errors to warnings, though I would recommend against making that a habit.
 
 | Check                          | Scope                           | Severity |
 | ------------------------------ | ------------------------------- | -------- |
 | `missing-license-header`       | New files (JS/CSS/FTL)          | error    |
 | `relative-import`              | JS/MJS files                    | error    |
 | `token-prefix-violation`       | CSS files (with furnace)        | error    |
-| `raw-color-value`              | CSS files                       | warning  |
+| `raw-color-value`              | Introduced CSS color values     | error    |
 | `missing-modification-comment` | Modified upstream JS/MJS        | warning  |
 | `file-too-large`               | New files >650 lines            | warning  |
 | `missing-jsdoc`                | Exports in new `.sys.mjs`       | warning  |
@@ -259,7 +265,7 @@ Furnace validates components on deploy. Errors block apply; warnings are advisor
 | `missing-css`            | warning  | No `.css` file                              |
 | `filename-mismatch`      | error    | File name does not match tag name           |
 | `missing-override-json`  | error    | Override missing `override.json`            |
-| `no-aria-role`           | warning  | No ARIA role found                          |
+| `no-aria-role`           | warning  | Generic interactive markup lacks semantics  |
 | `no-keyboard-handler`    | warning  | Has `@click` but no keyboard handler        |
 | `relative-import`        | error    | Imports must use `chrome://` URIs           |
 | `raw-color-value`        | error    | Raw hex/rgb/hsl (use CSS custom properties) |

package/dist/src/commands/build.js

@@ -5,7 +5,7 @@ import { prepareBuildEnvironment } from '../core/build-prepare.js';
 import { getProjectPaths, loadConfig } from '../core/config.js';
 import { build, buildArtifactMismatchMessage, buildUI, hasBuildArtifacts } from '../core/mach.js';
 import { GeneralError } from '../errors/base.js';
-import { BuildError } from '../errors/build.js';
+import { AmbiguousBuildArtifactsError, BuildError } from '../errors/build.js';
 import { pathExists } from '../utils/fs.js';
 import { error, info, intro, outro, verbose } from '../utils/logger.js';
 import { pickDefined } from '../utils/options.js';
@@ -45,6 +45,9 @@ export async function buildCommand(projectRoot, options) {
         throw new GeneralError('Firefox source not found. Run "fireforge download" first.');
     }
     const buildCheck = await hasBuildArtifacts(paths.engine);
+    if (buildCheck.ambiguous && buildCheck.objDirs && buildCheck.objDirs.length > 0) {
+        throw new AmbiguousBuildArtifactsError(buildCheck.objDirs);
+    }
     const mismatchMessage = buildArtifactMismatchMessage(paths.engine, buildCheck, 'Build');
     if (mismatchMessage) {
         throw new GeneralError(mismatchMessage);

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

@@ -6,13 +6,13 @@ import { isGitRepository } from '../core/git.js';
 import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { getModifiedFilesInDir, getUntrackedFilesInDir } from '../core/git-status.js';
 import { updatePatch, updatePatchMetadata } from '../core/patch-export.js';
-import { lintExportedPatch } from '../core/patch-lint.js';
 import { getClaimedFiles, loadPatchesManifest } from '../core/patch-manifest.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { toError } from '../utils/errors.js';
 import { pathExists } from '../utils/fs.js';
 import { cancel, info, intro, isCancel, outro, spinner, success, warn } from '../utils/logger.js';
 import { pickDefined } from '../utils/options.js';
+import { runPatchLint } from './export-shared.js';
 /**
  * Resolves patch identifiers (numbers or filenames) to manifest entries.
  * @param identifier - Patch number (e.g. "005") or filename (e.g. "005-ui-storage-modules.patch")
@@ -96,6 +96,7 @@ async function reExportSinglePatch(patch, paths, manifest, options, isDryRun, co
         warn(`Skipped ${patch.filename}: no changes (files unchanged from HEAD)`);
         return false;
     }
+    await runPatchLint(paths.engine, existingFiles, diffContent, config, options.skipLint);
     if (isDryRun) {
         info(`[dry-run] ${patch.filename}: ${existingFiles.length} file(s)`);
     }
@@ -115,15 +116,6 @@ async function reExportSinglePatch(patch, paths, manifest, options, isDryRun, co
                 };
             }
         }
-        const lintIssues = await lintExportedPatch(paths.engine, existingFiles, diffContent, config);
-        for (const issue of lintIssues) {
-            const prefix = issue.severity === 'error' && !options.skipLint ? 'ERROR ' : '';
-            warn(`${prefix}[${issue.check}] ${issue.file}: ${issue.message}`);
-        }
-        const lintErrors = lintIssues.filter((i) => i.severity === 'error');
-        if (lintErrors.length > 0 && !options.skipLint) {
-            warn(`${patch.filename}: ${lintErrors.length} lint error(s). Use --skip-lint to bypass.`);
-        }
         success(`Re-exported ${patch.filename}`);
     }
     return true;

package/dist/src/core/file-lock.js

@@ -12,6 +12,15 @@ function sleep(ms) {
         setTimeout(resolve, ms);
     });
 }
+function getNodeErrorCode(error) {
+    if (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        typeof error.code === 'string') {
+        return error.code;
+    }
+    return undefined;
+}
 /** Derives the sibling lock-directory path used to guard a file-based resource. */
 export function createSiblingLockPath(filePath, suffix = '.fireforge.lock') {
     return `${filePath}${suffix}`;
@@ -31,8 +40,13 @@ async function removeIfStaleLock(lockPath, staleMs, onStaleLockMessage) {
         return true;
     }
     catch (error) {
+        const code = getNodeErrorCode(error);
+        if (code === 'ENOENT') {
+            verbose(`Stale lock disappeared before cleanup completed: ${lockPath}`);
+            return true;
+        }
         verbose(`Stale lock check failed for ${lockPath}: ${toError(error).message}`);
-        return true;
+        throw toError(error);
     }
 }
 /** Runs an async operation while holding a directory lock, with stale-lock recovery. */

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

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { join } from 'node:path';
 import { pathExists, readText } from '../utils/fs.js';
-import { containsHardcodedTemplateText, createIssue, hasAriaRole, hasDelegatesFocusEnabled, hasTemplateClickHandler, hasTemplateKeyboardHandler, } from './furnace-validate-helpers.js';
+import { containsHardcodedTemplateText, createIssue, hasAriaRole, hasDelegatesFocusEnabled, hasGenericInteractiveElement, hasTemplateClickHandler, hasTemplateKeyboardHandler, } from './furnace-validate-helpers.js';
 /**
  * Validates accessibility patterns in a component's .mjs file.
  * Checks for ARIA roles, keyboard handlers, l10n, and focus delegation.
@@ -12,8 +12,8 @@ export async function validateAccessibility(componentDir, tagName) {
         return [];
     const content = await readText(mjsPath);
     const issues = [];
-    if (!hasAriaRole(content)) {
-        issues.push(createIssue(tagName, 'warning', 'no-aria-role', 'No ARIA role attribute found. Consider adding role= for screen reader support.'));
+    if (!hasAriaRole(content) && hasGenericInteractiveElement(content)) {
+        issues.push(createIssue(tagName, 'warning', 'no-aria-role', 'Generic interactive markup has no native semantics. Prefer native elements, or add role= when native markup cannot provide the semantics.'));
     }
     const hasClick = hasTemplateClickHandler(content);
     const hasKeyboardHandler = hasTemplateKeyboardHandler(content);

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

@@ -3,6 +3,8 @@ import type { ComponentType, FurnaceConfig, ValidationIssue } from '../types/fur
 export declare function createIssue(component: string, severity: ValidationIssue['severity'], check: ValidationIssue['check'], message: string): ValidationIssue;
 /** Detects whether template or script content assigns an ARIA role. */
 export declare function hasAriaRole(content: string): boolean;
+/** Detects generic elements being used as custom interactive controls. */
+export declare function hasGenericInteractiveElement(content: string): boolean;
 /** Detects Lit-style template click handlers. */
 export declare function hasTemplateClickHandler(content: string): boolean;
 /** Detects Lit-style template keyboard handlers. */

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

@@ -12,6 +12,10 @@ export function hasAriaRole(content) {
         /\.role\s*=/.test(content) ||
         /setAttribute\(\s*["']role["']/.test(content));
 }
+/** Detects generic elements being used as custom interactive controls. */
+export function hasGenericInteractiveElement(content) {
+    return /<(div|span)\b(?=[^>]*(?:@click|@key(?:down|press|up)|\btabindex\s*=|\.onclick\s*=))/i.test(content);
+}
 /** Detects Lit-style template click handlers. */
 export function hasTemplateClickHandler(content) {
     return /@click\s*=\s*\$\{/.test(content);

package/dist/src/core/git-diff.js

@@ -2,13 +2,21 @@
 import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { basename, join } from 'node:path';
+import { GitError } from '../errors/git.js';
 import { toError } from '../utils/errors.js';
 import { pathExists, readText } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
 import { exec } from '../utils/process.js';
-import { ensureGit } from './git-base.js';
+import { ensureGit, git } from './git-base.js';
 import { fileExistsInHead } from './git-file-ops.js';
 import { getUntrackedFiles } from './git-status.js';
+async function execGitWithAllowedExitCodes(repoDir, args, allowedExitCodes = [0]) {
+    const result = await exec('git', args, { cwd: repoDir });
+    if (allowedExitCodes.includes(result.exitCode)) {
+        return result;
+    }
+    throw new GitError(result.stderr.trim() || 'Git command failed', args.join(' '));
+}
 /**
  * Gets the diff for a specific file.
  * @param repoDir - Repository directory
@@ -17,8 +25,7 @@ import { getUntrackedFiles } from './git-status.js';
  */
 export async function getFileDiff(repoDir, filePath) {
     await ensureGit();
-    const result = await exec('git', ['diff', 'HEAD', '--', filePath], { cwd: repoDir });
-    return result.stdout;
+    return git(['diff', 'HEAD', '--', filePath], repoDir);
 }
 /**
  * Generates a unified diff for a new (untracked) file.
@@ -32,8 +39,7 @@ export async function generateNewFileDiff(repoDir, filePath) {
     // Compute the abbreviated git blob hash for the index line
     let blobHash = '0000000000';
     try {
-        const hashResult = await exec('git', ['hash-object', fullPath], { cwd: repoDir });
-        const fullHash = hashResult.stdout.trim();
+        const fullHash = (await git(['hash-object', fullPath], repoDir)).trim();
         if (fullHash.length >= 10) {
             blobHash = fullHash.slice(0, 10);
         }
@@ -113,9 +119,7 @@ export async function generateModificationDiff(repoDir, filePath, baseContent) {
     try {
         await writeFile(tempFile, baseContent);
         // git diff --no-index exits code 1 when files differ — that's normal
-        const result = await exec('git', ['diff', '--no-index', '--', tempFile, fullPath], {
-            cwd: repoDir,
-        });
+        const result = await execGitWithAllowedExitCodes(repoDir, ['diff', '--no-index', '--', tempFile, fullPath], [0, 1]);
         const output = result.stdout;
         if (!output) {
             return '';
@@ -154,8 +158,7 @@ export async function generateModificationDiff(repoDir, filePath, baseContent) {
 export async function getAllDiff(repoDir) {
     await ensureGit();
     // Get diff for tracked files
-    const result = await exec('git', ['diff', 'HEAD'], { cwd: repoDir });
-    const trackedDiff = result.stdout;
+    const trackedDiff = await git(['diff', 'HEAD'], repoDir);
     // Get untracked files (properly expanded, not directories)
     const untrackedFiles = await getUntrackedFiles(repoDir);
     // Generate diffs for untracked files
@@ -215,8 +218,7 @@ export async function getDiffForFilesAgainstHead(repoDir, files) {
  */
 export async function getStagedDiffForFiles(repoDir, files) {
     await ensureGit();
-    const result = await exec('git', ['diff', '--cached', 'HEAD', '--', ...files], { cwd: repoDir });
-    return result.stdout;
+    return git(['diff', '--cached', 'HEAD', '--', ...files], repoDir);
 }
 /**
  * Generates a GIT binary patch for a binary file.
@@ -229,18 +231,29 @@ export async function getStagedDiffForFiles(repoDir, files) {
 export async function generateBinaryFilePatch(repoDir, filePath) {
     await ensureGit();
     // Try tracked file diff first
-    const result = await exec('git', ['diff', '--binary', 'HEAD', '--', filePath], { cwd: repoDir });
+    const result = await execGitWithAllowedExitCodes(repoDir, [
+        'diff',
+        '--binary',
+        'HEAD',
+        '--',
+        filePath,
+    ]);
     if (result.stdout.trim())
         return result.stdout;
     // For untracked files, stage temporarily to produce a binary diff
     try {
-        await exec('git', ['add', '--intent-to-add', '--', filePath], { cwd: repoDir });
-        const diffResult = await exec('git', ['diff', '--binary', '--', filePath], { cwd: repoDir });
+        await execGitWithAllowedExitCodes(repoDir, ['add', '--intent-to-add', '--', filePath]);
+        const diffResult = await execGitWithAllowedExitCodes(repoDir, [
+            'diff',
+            '--binary',
+            '--',
+            filePath,
+        ]);
         return diffResult.stdout;
     }
     finally {
         // Always unstage, even if diff fails
-        await exec('git', ['reset', 'HEAD', '--', filePath], { cwd: repoDir });
+        await execGitWithAllowedExitCodes(repoDir, ['reset', 'HEAD', '--', filePath]);
     }
 }
 //# sourceMappingURL=git-diff.js.map

package/dist/src/core/git-file-ops.js

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { open } from 'node:fs/promises';
 import { join } from 'node:path';
+import { GitError } from '../errors/git.js';
 import { removeFile } from '../utils/fs.js';
 import { exec } from '../utils/process.js';
 import { ensureGit, git } from './git-base.js';
@@ -37,7 +38,7 @@ export async function removeUntrackedPath(repoDir, filePath) {
  */
 export async function removeAddedPath(repoDir, filePath) {
     await ensureGit();
-    await exec('git', ['reset', 'HEAD', '--', filePath], { cwd: repoDir });
+    await git(['reset', 'HEAD', '--', filePath], repoDir);
     await removeUntrackedPath(repoDir, filePath);
 }
 /**
@@ -92,8 +93,7 @@ export async function unstageFiles(repoDir, files) {
  */
 export async function fileExistsInHead(repoDir, filePath) {
     await ensureGit();
-    const result = await exec('git', ['ls-tree', 'HEAD', '--', filePath], { cwd: repoDir });
-    return result.stdout.trim().length > 0;
+    return (await git(['ls-tree', 'HEAD', '--', filePath], repoDir)).trim().length > 0;
 }
 /**
  * Gets the content of a file from HEAD commit.
@@ -105,7 +105,11 @@ export async function getFileContentFromHead(repoDir, filePath) {
     await ensureGit();
     const result = await exec('git', ['show', `HEAD:${filePath}`], { cwd: repoDir });
     if (result.exitCode !== 0) {
-        return null;
+        const stderr = result.stderr.trim();
+        if (/exists on disk, but not in 'HEAD'|path '.*' exists, but not '.*'|path '.*' does not exist in 'HEAD'/i.test(stderr)) {
+            return null;
+        }
+        throw new GitError(stderr || 'Git command failed', `show HEAD:${filePath}`);
     }
     return result.stdout;
 }

package/dist/src/core/git-status.js

@@ -1,6 +1,4 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { exec } from '../utils/process.js';
-import { ensureGit } from './git-base.js';
+import { ensureGit, git } from './git-base.js';
 /**
  * Parses NUL-delimited porcelain status output.
  * @param output - Raw git status output
@@ -43,8 +41,7 @@ export function parsePorcelainStatus(output) {
  */
 export async function getWorkingTreeStatus(repoDir) {
     await ensureGit();
-    const result = await exec('git', ['status', '--porcelain=v1', '-z'], { cwd: repoDir });
-    return parsePorcelainStatus(result.stdout);
+    return parsePorcelainStatus(await git(['status', '--porcelain=v1', '-z'], repoDir));
 }
 /**
  * Expands collapsed untracked directory entries into individual file entries.
@@ -92,10 +89,8 @@ export async function getModifiedFiles(repoDir) {
 export async function getUntrackedFiles(repoDir) {
     await ensureGit();
     // Use git ls-files to get all untracked files, which properly expands directories
-    const result = await exec('git', ['ls-files', '--others', '--exclude-standard'], {
-        cwd: repoDir,
-    });
-    return result.stdout.split('\n').filter((line) => line.trim().length > 0);
+    const output = await git(['ls-files', '--others', '--exclude-standard'], repoDir);
+    return output.split('\n').filter((line) => line.trim().length > 0);
 }
 /**
  * Gets untracked files within a specific directory.
@@ -106,10 +101,8 @@ export async function getUntrackedFiles(repoDir) {
  */
 export async function getUntrackedFilesInDir(repoDir, dir) {
     await ensureGit();
-    const result = await exec('git', ['ls-files', '--others', '--exclude-standard', '--', dir], {
-        cwd: repoDir,
-    });
-    return result.stdout.split('\n').filter((line) => line.trim().length > 0);
+    const output = await git(['ls-files', '--others', '--exclude-standard', '--', dir], repoDir);
+    return output.split('\n').filter((line) => line.trim().length > 0);
 }
 /**
  * Gets modified (tracked) files within a specific directory.
@@ -120,8 +113,8 @@ export async function getUntrackedFilesInDir(repoDir, dir) {
  */
 export async function getModifiedFilesInDir(repoDir, dir) {
     await ensureGit();
-    const result = await exec('git', ['diff', '--name-only', 'HEAD', '--', dir], { cwd: repoDir });
-    return result.stdout.split('\n').filter((line) => line.trim().length > 0);
+    const output = await git(['diff', '--name-only', 'HEAD', '--', dir], repoDir);
+    return output.split('\n').filter((line) => line.trim().length > 0);
 }
 /**
  * Checks if any of the specified files have uncommitted changes.
@@ -134,13 +127,11 @@ export async function getDirtyFiles(repoDir, files) {
         return [];
     await ensureGit();
     // Check both staged and unstaged changes for the given files
-    const result = await exec('git', ['diff', '--name-only', 'HEAD', '--', ...files], {
-        cwd: repoDir,
-    });
-    const tracked = result.stdout.split('\n').filter((line) => line.trim().length > 0);
+    const trackedOutput = await git(['diff', '--name-only', 'HEAD', '--', ...files], repoDir);
+    const tracked = trackedOutput.split('\n').filter((line) => line.trim().length > 0);
     // Also check for untracked files
-    const untrackedResult = await exec('git', ['ls-files', '--others', '--exclude-standard', '--', ...files], { cwd: repoDir });
-    const untracked = untrackedResult.stdout.split('\n').filter((line) => line.trim().length > 0);
+    const untrackedOutput = await git(['ls-files', '--others', '--exclude-standard', '--', ...files], repoDir);
+    const untracked = untrackedOutput.split('\n').filter((line) => line.trim().length > 0);
     return [...new Set([...tracked, ...untracked])].sort();
 }
 /**
@@ -152,12 +143,10 @@ export async function getDirtyFiles(repoDir, files) {
  */
 export async function listAllFilesInDir(repoDir, dir) {
     await ensureGit();
-    const tracked = await exec('git', ['ls-files', '--', dir], { cwd: repoDir });
-    const trackedFiles = tracked.stdout.split('\n').filter((line) => line.trim().length > 0);
-    const untracked = await exec('git', ['ls-files', '--others', '--exclude-standard', '--', dir], {
-        cwd: repoDir,
-    });
-    const untrackedFiles = untracked.stdout.split('\n').filter((line) => line.trim().length > 0);
+    const trackedOutput = await git(['ls-files', '--', dir], repoDir);
+    const trackedFiles = trackedOutput.split('\n').filter((line) => line.trim().length > 0);
+    const untrackedOutput = await git(['ls-files', '--others', '--exclude-standard', '--', dir], repoDir);
+    const untrackedFiles = untrackedOutput.split('\n').filter((line) => line.trim().length > 0);
     return [...new Set([...trackedFiles, ...untrackedFiles])].sort();
 }
 //# sourceMappingURL=git-status.js.map

package/dist/src/core/patch-lint.d.ts

@@ -10,13 +10,15 @@ export declare function commentStyleForFile(file: string): CommentStyle | null;
  */
 export declare function detectNewFilesInDiff(diffContent: string): Set<string>;
 /**
- * Lints patched CSS files for raw color values and non-tokenized custom properties.
+ * Lints patched CSS files for introduced raw color values and non-tokenized
+ * custom properties.
  *
  * @param repoDir - Absolute path to the engine (repository) directory
  * @param affectedFiles - File paths (relative to repoDir) affected by the patch
+ * @param diffContent - Optional unified diff used to scope raw color checks to introduced lines
  * @returns Array of lint issues found
  */
-export declare function lintPatchedCss(repoDir: string, affectedFiles: string[]): Promise<PatchLintIssue[]>;
+export declare function lintPatchedCss(repoDir: string, affectedFiles: string[], diffContent?: string): Promise<PatchLintIssue[]>;
 /**
  * Checks new files for required license headers.
  *

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

@@ -80,16 +80,18 @@ function extractAddedLinesPerFile(diffContent) {
     return result;
 }
 // ---------------------------------------------------------------------------
-// CSS lint (existing — now with severity)
+// CSS lint
 // ---------------------------------------------------------------------------
 /**
- * Lints patched CSS files for raw color values and non-tokenized custom properties.
+ * Lints patched CSS files for introduced raw color values and non-tokenized
+ * custom properties.
  *
  * @param repoDir - Absolute path to the engine (repository) directory
  * @param affectedFiles - File paths (relative to repoDir) affected by the patch
+ * @param diffContent - Optional unified diff used to scope raw color checks to introduced lines
  * @returns Array of lint issues found
  */
-export async function lintPatchedCss(repoDir, affectedFiles) {
+export async function lintPatchedCss(repoDir, affectedFiles, diffContent) {
     const cssFiles = affectedFiles.filter((f) => f.endsWith('.css'));
     if (cssFiles.length === 0)
         return [];
@@ -108,6 +110,7 @@ export async function lintPatchedCss(repoDir, affectedFiles) {
         verbose(`Skipping furnace token-prefix lint hints because furnace.json could not be loaded: ${toError(error).message}`);
     }
     const issues = [];
+    const addedLinesByFile = diffContent ? extractAddedLinesPerFile(diffContent) : undefined;
     for (const file of cssFiles) {
         const filePath = join(repoDir, file);
         if (!(await pathExists(filePath)))
@@ -115,13 +118,16 @@ export async function lintPatchedCss(repoDir, affectedFiles) {
         const rawCss = await readText(filePath);
         // Strip block comments before scanning
         const cssContent = rawCss.replace(/\/\*[\s\S]*?\*\//g, '');
-        // Check for raw color values
-        if (hasRawCssColors(cssContent)) {
+        const rawColorContent = addedLinesByFile
+            ? (addedLinesByFile.get(file) ?? []).join('\n').replace(/\/\*[\s\S]*?\*\//g, '')
+            : cssContent;
+        // Check only introduced raw color values when diff context is available.
+        if (hasRawCssColors(rawColorContent)) {
             issues.push({
                 file,
                 check: 'raw-color-value',
                 message: 'Raw color value found. Use CSS custom properties (var(--...)) for design token consistency.',
-                severity: 'warning',
+                severity: 'error',
             });
         }
         // Check for non-tokenized custom properties
@@ -384,7 +390,7 @@ export async function lintExportedPatch(repoDir, affectedFiles, diffContent, con
     const newFiles = detectNewFilesInDiff(diffContent);
     const lineCount = diffContent.split('\n').length;
     const [cssIssues, headerIssues, jsIssues, modifiedHeaderIssues] = await Promise.all([
-        lintPatchedCss(repoDir, affectedFiles),
+        lintPatchedCss(repoDir, affectedFiles, diffContent),
         lintNewFileHeaders(repoDir, [...newFiles], config),
         lintPatchedJs(repoDir, affectedFiles, newFiles, config),
         lintModifiedFileHeaders(repoDir, affectedFiles, newFiles),

package/dist/src/utils/package-root.d.ts

@@ -1,10 +1,18 @@
+interface PackageMetadata {
+    name: string;
+    version: string;
+    bin?: unknown;
+}
 /**
  * Finds the fireforge package root by walking up from the current module.
  *
  * Works from both the source tree (`src/utils/`) and the compiled
- * tree (`dist/src/utils/`) by looking for a `package.json` whose
- * `name` field is `"@hominis/fireforge"`.
+ * tree (`dist/src/utils/`) by looking for a `package.json` that exposes
+ * the `fireforge` CLI entrypoint, regardless of the npm package scope.
  */
 export declare function getPackageRoot(): string;
+/** @internal */
+export declare function isFireForgePackageMetadata(pkg: PackageMetadata): boolean;
 /** Reads the current package version from the repository root package manifest. */
 export declare function getPackageVersion(): string;
+export {};

package/dist/src/utils/package-root.js

@@ -11,7 +11,7 @@ function validatePackageMetadata(data, filePath) {
     if (typeof name !== 'string' || typeof version !== 'string') {
         throw new Error(`Invalid package metadata in ${filePath}: expected string "name" and "version" fields`);
     }
-    return { name, version };
+    return { name, version, bin: 'bin' in data ? data.bin : undefined };
 }
 function readPackageMetadata(filePath) {
     const raw = readFileSync(filePath, 'utf-8');
@@ -21,8 +21,8 @@ function readPackageMetadata(filePath) {
  * Finds the fireforge package root by walking up from the current module.
  *
  * Works from both the source tree (`src/utils/`) and the compiled
- * tree (`dist/src/utils/`) by looking for a `package.json` whose
- * `name` field is `"@hominis/fireforge"`.
+ * tree (`dist/src/utils/`) by looking for a `package.json` that exposes
+ * the `fireforge` CLI entrypoint, regardless of the npm package scope.
  */
 export function getPackageRoot() {
     let current = dirname(fileURLToPath(import.meta.url));
@@ -30,7 +30,7 @@ export function getPackageRoot() {
         try {
             const packagePath = join(current, 'package.json');
             const pkg = readPackageMetadata(packagePath);
-            if (pkg.name === '@hominis/fireforge') {
+            if (isFireForgePackageMetadata(pkg)) {
                 return current;
             }
         }
@@ -45,6 +45,14 @@ export function getPackageRoot() {
         current = parent;
     }
 }
+/** @internal */
+export function isFireForgePackageMetadata(pkg) {
+    if (typeof pkg.bin !== 'object' || pkg.bin === null || Array.isArray(pkg.bin)) {
+        return false;
+    }
+    const bin = pkg.bin;
+    return typeof bin['fireforge'] === 'string';
+}
 /** Reads the current package version from the repository root package manifest. */
 export function getPackageVersion() {
     const packageRoot = getPackageRoot();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hominis/fireforge",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "description": "FireForge — a build tool for customizing Firefox",
   "type": "module",
   "main": "./dist/src/index.js",
@@ -85,11 +85,11 @@
   "license": "EUPL-1.2",
   "repository": {
     "type": "git",
-    "url": "https://github.com/topfi/fireforge.git"
+    "url": "https://github.com/HominisBrowser/FireForge.git"
   },
-  "homepage": "https://github.com/topfi/fireforge",
+  "homepage": "https://github.com/HominisBrowser/FireForge",
   "bugs": {
-    "url": "https://github.com/topfi/fireforge/issues"
+    "url": "https://github.com/HominisBrowser/FireForge/issues"
   },
   "keywords": [
     "fireforge",