@hominis/fireforge 0.27.0 → 0.27.2

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

@@ -4,6 +4,7 @@
  * Used after both AST and legacy code paths to avoid duplicating logic.
  */
 import { FurnaceError } from '../errors/furnace.js';
+import { stripJsComments } from '../utils/regex.js';
 /**
  * Regex for valid custom element tag names. A valid name is lowercase, starts
  * with a letter, and contains one or more hyphen-separated groups where each
@@ -36,25 +37,41 @@ export function validateTagName(tagName) {
  * @param isESModule - Whether the module uses ESM (Pattern B) or not (Pattern A)
  */
 export function validateRegistrationPlacement(result, tagName, isESModule) {
-    const dclPattern = /document\.addEventListener\(\s*["']DOMContentLoaded["']/;
     const insertedPos = result.lastIndexOf(`"${tagName}"`);
     if (insertedPos === -1)
         return;
-    const contentBeforeTag = result.slice(0, insertedPos);
-    const hasDCLBefore = dclPattern.test(contentBeforeTag);
-    if (isESModule && !hasDCLBefore && !isTagInArrayConsumedInsideDOMContentLoaded(result, tagName)) {
+    if (!isTagInCorrectCustomElementsPlacement(result, tagName, isESModule)) {
+        if (!isESModule) {
+            throw new FurnaceError(`${tagName} was registered in the DOMContentLoaded/importESModule block (Pattern B) instead of the loadSubScript block (Pattern A). This will cause the component to fail at runtime. The customElements.js file structure may have changed upstream — manual intervention required.`, tagName);
+        }
         throw new FurnaceError(`${tagName} was registered in the loadSubScript block (Pattern A) instead of the DOMContentLoaded/importESModule block (Pattern B). This will cause the component to fail at runtime. The customElements.js file structure may have changed upstream — manual intervention required.`, tagName);
     }
-    if (!isESModule && hasDCLBefore) {
-        throw new FurnaceError(`${tagName} was registered in the DOMContentLoaded/importESModule block (Pattern B) instead of the loadSubScript block (Pattern A). This will cause the component to fail at runtime. The customElements.js file structure may have changed upstream — manual intervention required.`, tagName);
+}
+/**
+ * Returns whether a tag appears in the correct customElements.js placement.
+ * ESM entries may either appear textually inside/after DOMContentLoaded or
+ * inside an array declared before DOMContentLoaded and consumed by a for-of
+ * loop inside the listener, as Firefox 152 Beta does for acornElements.
+ */
+export function isTagInCorrectCustomElementsPlacement(content, tagName, isESModule) {
+    const stripped = stripJsComments(content);
+    const tagPattern = new RegExp(`["']${escapeRegex(tagName)}["']`);
+    const dclMatch = /document\.addEventListener\(\s*["']DOMContentLoaded["']/.exec(stripped);
+    if (!dclMatch) {
+        return !isESModule && tagPattern.test(stripped);
+    }
+    const beforeDcl = stripped.slice(0, dclMatch.index);
+    const afterDcl = stripped.slice(dclMatch.index);
+    const tagBeforeDcl = tagPattern.test(beforeDcl);
+    const tagAfterDcl = tagPattern.test(afterDcl);
+    if (!isESModule) {
+        return tagBeforeDcl && !tagAfterDcl;
     }
+    return (tagAfterDcl || isTagInArrayConsumedInsideDOMContentLoaded(stripped, dclMatch.index, tagName));
 }
-function isTagInArrayConsumedInsideDOMContentLoaded(content, tagName) {
-    const dclMatch = /document\.addEventListener\(\s*["']DOMContentLoaded["']/.exec(content);
-    if (!dclMatch)
-        return false;
-    const beforeDcl = content.slice(0, dclMatch.index);
-    const afterDcl = content.slice(dclMatch.index);
+function isTagInArrayConsumedInsideDOMContentLoaded(content, domContentLoadedIdx, tagName) {
+    const beforeDcl = content.slice(0, domContentLoadedIdx);
+    const afterDcl = content.slice(domContentLoadedIdx);
     const consumedArrays = new Set();
     const forOfPattern = /for\s*\(\s*(?:let|const|var)\s*\[[^)]*\]\s+of\s+([A-Za-z_$][\w$]*)\s*\)/g;
     let match;

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

@@ -9,6 +9,7 @@ import { stripJsComments } from '../utils/regex.js';
 import { getProjectPaths, loadConfig } from './config.js';
 import { getFurnacePaths } from './furnace-config.js';
 import { CUSTOM_ELEMENTS_JS, FTL_DIR, JAR_MN } from './furnace-constants.js';
+import { isTagInCorrectCustomElementsPlacement } from './furnace-registration-validate.js';
 import { getTokensCssPath } from './token-manager.js';
 /**
  * Validates that all Furnace-managed .mjs components are registered in the
@@ -27,21 +28,13 @@ export async function validateRegistrationPatterns(root, config) {
         return issues;
     }
     const content = await readText(filePath);
-    // Find the DOMContentLoaded block boundary (handles multi-line addEventListener)
-    const dclMatch = /document\.addEventListener\(\s*["']DOMContentLoaded["']/.exec(content);
-    if (!dclMatch) {
-        return issues;
-    }
-    const domContentLoadedIdx = dclMatch.index;
     // Get all custom component tag names that use .mjs (all custom components do)
     for (const [name, customConfig] of Object.entries(config.custom)) {
         if (!customConfig.register)
             continue;
-        // Check if this tag is referenced before the DOMContentLoaded block
-        const contentBeforeDCL = stripJsComments(content.slice(0, domContentLoadedIdx));
-        const tagPattern = new RegExp(`"${name}"`);
-        if (tagPattern.test(contentBeforeDCL) &&
-            !isArrayDeclaredBeforeDclAndConsumedInsideDcl(content, domContentLoadedIdx, name)) {
+        const stripped = stripJsComments(content);
+        const tagPattern = new RegExp(`["']${escapeRegex(name)}["']`);
+        if (tagPattern.test(stripped) && !isTagInCorrectCustomElementsPlacement(content, name, true)) {
             issues.push({
                 component: name,
                 severity: 'error',
@@ -52,25 +45,6 @@ export async function validateRegistrationPatterns(root, config) {
     }
     return issues;
 }
-function isArrayDeclaredBeforeDclAndConsumedInsideDcl(content, domContentLoadedIdx, tagName) {
-    const contentBeforeDCL = stripJsComments(content.slice(0, domContentLoadedIdx));
-    const contentAfterDCL = stripJsComments(content.slice(domContentLoadedIdx));
-    const consumedArrays = new Set();
-    const forOfPattern = /for\s*\(\s*(?:let|const|var)\s*\[[^)]*\]\s+of\s+([A-Za-z_$][\w$]*)\s*\)/g;
-    let match;
-    while ((match = forOfPattern.exec(contentAfterDCL)) !== null) {
-        if (match[1])
-            consumedArrays.add(match[1]);
-    }
-    for (const arrayName of consumedArrays) {
-        const declarationPattern = new RegExp(`(?:const|let|var)\\s+${escapeRegex(arrayName)}\\s*=\\s*\\[([\\s\\S]*?)\\];`);
-        const declaration = declarationPattern.exec(contentBeforeDCL);
-        if (declaration?.[1] && new RegExp(`["']${escapeRegex(tagName)}["']`).test(declaration[1])) {
-            return true;
-        }
-    }
-    return false;
-}
 function escapeRegex(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -173,13 +147,7 @@ export async function checkRegistrationConsistency(root, name, config, ftlDir) {
         status.customElementsPresent =
             ceContent.includes(`"${name}"`) || ceContent.includes(`'${name}'`);
         if (status.customElementsPresent) {
-            // Check it's in the correct block (after DOMContentLoaded)
-            const dclMatch = /document\.addEventListener\(\s*["']DOMContentLoaded["']/.exec(ceContent);
-            if (dclMatch) {
-                const afterDcl = ceContent.slice(dclMatch.index);
-                status.customElementsCorrectBlock =
-                    afterDcl.includes(`"${name}"`) || afterDcl.includes(`'${name}'`);
-            }
+            status.customElementsCorrectBlock = isTagInCorrectCustomElementsPlacement(ceContent, name, true);
         }
     }
     return status;

package/dist/src/core/git.js

@@ -2,6 +2,7 @@
 import { readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { GitError, GitIndexingTimeoutError, GitIndexLockError, PatchApplyError, } from '../errors/git.js';
+import { elapsedSince } from '../utils/elapsed.js';
 import { toError } from '../utils/errors.js';
 import { pathExists, removeFile } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
@@ -158,6 +159,7 @@ async function stageAllFilesChunked(dir, scan, options = {}) {
  * SIGINT'd mid-way assuming the process had stalled.
  */
 const GIT_ADD_HEARTBEAT_MS = 15_000;
+const GIT_COMMIT_HEARTBEAT_MS = 15_000;
 async function scanTopLevelSource(dir) {
     const entries = await readdir(dir, { withFileTypes: true });
     return {
@@ -204,9 +206,10 @@ export async function stageAllFiles(dir, options = {}) {
     heartbeatTimer?.unref();
     try {
         try {
+            reportProgress?.('Git phase: starting git add -A source indexing.');
             reportProgress?.(`Starting monolithic git add -A for ${scan.directories.length} director${scan.directories.length === 1 ? 'y' : 'ies'} and ${scan.topLevelFiles.length} top-level file${scan.topLevelFiles.length === 1 ? '' : 's'}...`);
             await git(['add', '-A'], dir, { timeout, env: GIT_ADD_ENV });
-            reportProgress?.('Monolithic git add -A completed.');
+            reportProgress?.('Git phase complete: git add -A source indexing finished.');
             return;
         }
         catch (error) {
@@ -231,6 +234,7 @@ export async function stageAllFiles(dir, options = {}) {
         phaseStartedAt = Date.now();
         try {
             await stageAllFilesChunked(dir, scan, options);
+            reportProgress?.('Git phase complete: chunked source indexing finished.');
         }
         catch (error) {
             if (error instanceof GitIndexingTimeoutError)
@@ -243,6 +247,22 @@ export async function stageAllFiles(dir, options = {}) {
             clearInterval(heartbeatTimer);
     }
 }
+async function createInitialSourceCommit(dir, reportProgress) {
+    const startedAt = Date.now();
+    reportProgress('Git phase: creating initial source commit.');
+    reportProgress(`Creating initial Firefox source commit (${elapsedSince(startedAt)} elapsed)...`);
+    const heartbeat = setInterval(() => {
+        reportProgress(`Creating initial Firefox source commit (${elapsedSince(startedAt)} elapsed)...`);
+    }, GIT_COMMIT_HEARTBEAT_MS);
+    heartbeat.unref();
+    try {
+        await git(['commit', '-m', 'Initial Firefox source'], dir);
+    }
+    finally {
+        clearInterval(heartbeat);
+    }
+    reportProgress(`Git phase complete: initial source commit created (${elapsedSince(startedAt)} elapsed).`);
+}
 /**
  * Initializes a new git repository with an orphan branch.
  * @param dir - Directory to initialize
@@ -252,6 +272,7 @@ export async function initRepository(dir, branchName = 'main', options = {}) {
     await ensureGit();
     const reportProgress = options.onProgress ?? (() => { });
     // Initialize repository
+    reportProgress('Git phase: initializing source git repository.');
     reportProgress('Creating git repository...');
     await git(['init'], dir);
     // Create orphan branch
@@ -269,6 +290,7 @@ export async function initRepository(dir, branchName = 'main', options = {}) {
     // fail.  Nothing is ever fetched from or pushed to this remote.
     reportProgress('Configuring origin remote for build compatibility...');
     await git(['remote', 'add', 'origin', 'https://github.com/mozilla-firefox/firefox'], dir);
+    reportProgress('Git phase complete: source git repository metadata initialized.');
     // Add all files
     reportProgress('Indexing Firefox source with git add -A (this can take several minutes on large trees)...');
     await assertNoGitIndexLock(dir);
@@ -279,9 +301,8 @@ export async function initRepository(dir, branchName = 'main', options = {}) {
         throw await maybeWrapIndexLockError(dir, error);
     }
     // Create initial commit
-    reportProgress('Creating initial Firefox source commit...');
     try {
-        await git(['commit', '-m', 'Initial Firefox source'], dir);
+        await createInitialSourceCommit(dir, reportProgress);
     }
     catch (error) {
         throw await maybeWrapIndexLockError(dir, error);
@@ -316,9 +337,8 @@ export async function resumeRepository(dir, options = {}) {
         throw await maybeWrapIndexLockError(dir, error);
     }
     // Create initial commit
-    reportProgress('Creating initial Firefox source commit...');
     try {
-        await git(['commit', '-m', 'Initial Firefox source'], dir);
+        await createInitialSourceCommit(dir, reportProgress);
     }
     catch (error) {
         throw await maybeWrapIndexLockError(dir, error);

package/dist/src/core/ownership-table.d.ts

@@ -1,4 +1,5 @@
 import type { PatchMetadata } from '../types/commands/index.js';
+import type { FileClassification } from './status-classify.js';
 /**
  * A row in the flat path → owning-patch ownership table.
  */
@@ -8,6 +9,7 @@ export interface OwnershipRow {
     conflict: boolean;
     conflictReason: 'files-affected' | 'duplicate-create' | null;
     unmanaged: boolean;
+    state: 'owned' | 'patch-backed' | 'patch-owned-drift' | 'unmanaged' | 'conflict';
 }
 interface StatusFile {
     status: string;
@@ -42,7 +44,7 @@ interface StatusFile {
  *   {@link import('../core/patch-lint.js').collectNewFileCreatorsByPath};
  *   paths with a `.length > 1` owner list become duplicate-create conflicts
  */
-export declare function buildOwnershipTable(manifestPatches: PatchMetadata[], worktreeFiles: StatusFile[], newFileCreatorsByPath: Map<string, string[]>): OwnershipRow[];
+export declare function buildOwnershipTable(manifestPatches: PatchMetadata[], worktreeFiles: StatusFile[], newFileCreatorsByPath: Map<string, string[]>, classifications?: Map<string, FileClassification>): OwnershipRow[];
 /**
  * Renders the ownership table as a GitHub-flavored Markdown pipe table.
  * Using markdown-table's own serializer would require a seed document to

package/dist/src/core/ownership-table.js

@@ -28,7 +28,7 @@ import { info } from '../utils/logger.js';
  *   {@link import('../core/patch-lint.js').collectNewFileCreatorsByPath};
  *   paths with a `.length > 1` owner list become duplicate-create conflicts
  */
-export function buildOwnershipTable(manifestPatches, worktreeFiles, newFileCreatorsByPath) {
+export function buildOwnershipTable(manifestPatches, worktreeFiles, newFileCreatorsByPath, classifications = new Map()) {
     const ownersByPath = new Map();
     for (const patch of manifestPatches) {
         for (const file of patch.filesAffected) {
@@ -86,6 +86,13 @@ export function buildOwnershipTable(manifestPatches, worktreeFiles, newFileCreat
             conflict: isFilesAffectedConflict || isDuplicateCreateConflict,
             conflictReason,
             unmanaged: false,
+            state: isFilesAffectedConflict || isDuplicateCreateConflict
+                ? 'conflict'
+                : classifications.get(path) === 'patch-backed'
+                    ? 'patch-backed'
+                    : classifications.get(path) === 'patch-owned-drift'
+                        ? 'patch-owned-drift'
+                        : 'owned',
         });
     }
     for (const path of unmanagedOnly) {
@@ -95,6 +102,7 @@ export function buildOwnershipTable(manifestPatches, worktreeFiles, newFileCreat
             conflict: false,
             conflictReason: null,
             unmanaged: true,
+            state: 'unmanaged',
         });
     }
     rows.sort((a, b) => a.path.localeCompare(b.path));
@@ -115,6 +123,22 @@ function renderConflictCell(row) {
         return 'CONFLICT (dup-create)';
     return 'CONFLICT';
 }
+function renderStateCell(row) {
+    if (row.conflict)
+        return renderConflictCell(row);
+    switch (row.state) {
+        case 'owned':
+            return 'owned';
+        case 'patch-backed':
+            return 'patch-backed';
+        case 'patch-owned-drift':
+            return 'patch-owned drift';
+        case 'unmanaged':
+            return 'unmanaged';
+        case 'conflict':
+            return renderConflictCell(row);
+    }
+}
 /**
  * Renders the ownership table as a GitHub-flavored Markdown pipe table.
  * Using markdown-table's own serializer would require a seed document to
@@ -128,17 +152,17 @@ export function renderOwnershipTable(rows) {
     }
     const pathHeader = 'path';
     const ownerHeader = 'owning patch';
-    const conflictHeader = 'conflict';
+    const stateHeader = 'state';
     const pathWidth = Math.max(pathHeader.length, ...rows.map((r) => r.path.length));
     const ownerWidth = Math.max(ownerHeader.length, ...rows.map((r) => (r.unmanaged ? 1 : r.owners.join(', ').length)));
-    const conflictWidth = Math.max(conflictHeader.length, ...rows.map((r) => renderConflictCell(r).length), 8);
+    const stateWidth = Math.max(stateHeader.length, ...rows.map((r) => renderStateCell(r).length), 8);
     const pad = (text, width) => text + ' '.repeat(width - text.length);
-    info(`| ${pad(pathHeader, pathWidth)} | ${pad(ownerHeader, ownerWidth)} | ${pad(conflictHeader, conflictWidth)} |`);
-    info(`| ${'-'.repeat(pathWidth)} | ${'-'.repeat(ownerWidth)} | ${'-'.repeat(conflictWidth)} |`);
+    info(`| ${pad(pathHeader, pathWidth)} | ${pad(ownerHeader, ownerWidth)} | ${pad(stateHeader, stateWidth)} |`);
+    info(`| ${'-'.repeat(pathWidth)} | ${'-'.repeat(ownerWidth)} | ${'-'.repeat(stateWidth)} |`);
     for (const row of rows) {
         const ownerCell = row.unmanaged ? '-' : row.owners.join(', ');
-        const conflictCell = renderConflictCell(row);
-        info(`| ${pad(row.path, pathWidth)} | ${pad(ownerCell, ownerWidth)} | ${pad(conflictCell, conflictWidth)} |`);
+        const stateCell = renderStateCell(row);
+        info(`| ${pad(row.path, pathWidth)} | ${pad(ownerCell, ownerWidth)} | ${pad(stateCell, stateWidth)} |`);
     }
 }
 //# sourceMappingURL=ownership-table.js.map

package/dist/src/core/patch-artifact-normalize.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Normalizes generated patch files for repository whitespace checks.
+ *
+ * Unified diffs conventionally encode a blank context line as a physical line
+ * containing one space. `git apply` also accepts the same hunk as an empty
+ * physical line, while repository-level `git diff --check` flags the
+ * single-space artifact as trailing whitespace in `patches/*.patch`.
+ */
+export declare function normalizePatchArtifact(content: string): string;

package/dist/src/core/patch-artifact-normalize.js

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Normalizes generated patch files for repository whitespace checks.
+ *
+ * Unified diffs conventionally encode a blank context line as a physical line
+ * containing one space. `git apply` also accepts the same hunk as an empty
+ * physical line, while repository-level `git diff --check` flags the
+ * single-space artifact as trailing whitespace in `patches/*.patch`.
+ */
+export function normalizePatchArtifact(content) {
+    return content.replace(/^ $/gm, '');
+}
+//# sourceMappingURL=patch-artifact-normalize.js.map

package/dist/src/core/patch-export-update.js

@@ -4,6 +4,7 @@ import { toError } from '../utils/errors.js';
 import { pathExists, readText, writeText } from '../utils/fs.js';
 import { warn } from '../utils/logger.js';
 import { withPatchDirectoryLock } from './patch-apply.js';
+import { normalizePatchArtifact } from './patch-artifact-normalize.js';
 import { loadPatchesManifest, savePatchesManifest } from './patch-manifest.js';
 import { buildProjectedManifest, enforcePatchPolicy } from './patch-policy.js';
 /**
@@ -38,7 +39,7 @@ export async function updatePatchAndMetadata(patchesDir, filename, newContent, u
         }
         let patchWritten = false;
         try {
-            await writeText(patchPath, newContent);
+            await writeText(patchPath, normalizePatchArtifact(newContent));
             patchWritten = true;
             await savePatchesManifest(patchesDir, manifest);
         }

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

@@ -36,6 +36,8 @@ export interface CommitExportedPatchInput {
     diff: string;
     filesAffected: string[];
     sourceEsrVersion: string;
+    sourceProduct?: FireForgeConfig['firefox']['product'];
+    sourceVersion?: string;
     /** Optional `PatchMetadata.tier` opt-in (only `"branding"` recognised). */
     tier?: 'branding';
     /** Optional `PatchMetadata.lintIgnore` (empty array treated as absent). */
@@ -126,6 +128,8 @@ export interface PlanExportInput {
     description: string;
     filesAffected: string[];
     sourceEsrVersion: string;
+    sourceProduct?: FireForgeConfig['firefox']['product'];
+    sourceVersion?: string;
     /**
      * Optional `PatchMetadata.tier` opt-in carried from the CLI flag.
      * Only `"branding"` is currently recognised. When provided the field

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

@@ -6,6 +6,7 @@ import { pathExists, readText, removeFile, writeText } from '../utils/fs.js';
 import { warn } from '../utils/logger.js';
 import { PATCH_CATEGORIES } from '../utils/validation.js';
 import { discoverPatches, withPatchDirectoryLock } from './patch-apply.js';
+import { normalizePatchArtifact } from './patch-artifact-normalize.js';
 import { findAllPatchesForFilesWithDetails, } from './patch-export-coverage.js';
 import { addPatchToManifest, loadPatchesManifest, PATCHES_MANIFEST, savePatchesManifest, } from './patch-manifest.js';
 import { allocatePolicyOrder, enforcePatchPolicy } from './patch-policy.js';
@@ -74,6 +75,8 @@ export async function commitExportedPatch(input) {
             description: input.description,
             filesAffected: input.filesAffected,
             sourceEsrVersion: input.sourceEsrVersion,
+            ...(input.sourceProduct !== undefined ? { sourceProduct: input.sourceProduct } : {}),
+            ...(input.sourceVersion !== undefined ? { sourceVersion: input.sourceVersion } : {}),
             ...(input.tier !== undefined ? { tier: input.tier } : {}),
             ...(input.lintIgnore !== undefined ? { lintIgnore: input.lintIgnore } : {}),
             ...(input.config !== undefined ? { config: input.config } : {}),
@@ -95,7 +98,7 @@ export async function commitExportedPatch(input) {
             }
         }
         try {
-            await writeText(patchPath, input.diff);
+            await writeText(patchPath, normalizePatchArtifact(input.diff));
             await addPatchToManifest(input.patchesDir, plan.metadata, plan.supersededPatches.map((p) => p.filename));
             for (const oldPatch of plan.supersededPatches) {
                 await removeFile(oldPatch.path);
@@ -195,7 +198,7 @@ export async function findExistingPatchForFile(patchesDir, filePath) {
  * @param newContent - New patch content
  */
 export async function updatePatch(patchPath, newContent) {
-    await writeText(patchPath, newContent);
+    await writeText(patchPath, normalizePatchArtifact(newContent));
 }
 /**
  * Deletes a patch file and removes it from the manifest.
@@ -261,6 +264,8 @@ async function computeExportPlanUnderLock(input) {
         description: input.description,
         createdAt: new Date().toISOString(),
         sourceEsrVersion: input.sourceEsrVersion,
+        ...(input.sourceProduct !== undefined ? { sourceProduct: input.sourceProduct } : {}),
+        sourceVersion: input.sourceVersion ?? input.sourceEsrVersion,
         filesAffected: input.filesAffected,
         ...(input.tier !== undefined ? { tier: input.tier } : {}),
         ...(input.lintIgnore !== undefined && input.lintIgnore.length > 0

package/dist/src/core/patch-manifest-consistency.d.ts

@@ -37,7 +37,7 @@ export interface RebuildPatchesManifestResult {
  * Existing metadata is preserved when possible; missing entries are recovered
  * from filename structure, patch contents, and file mtimes.
  * @param patchesDir - Path to the patches directory
- * @param fallbackSourceEsrVersion - ESR version to use for recovered entries
+ * @param fallbackSourceEsrVersion - source version to use for recovered legacy entries
  * @returns {@link RebuildPatchesManifestResult} — the persisted manifest
  *   plus the filenames that were reconstructed from generic defaults.
  */

package/dist/src/core/patch-manifest-consistency.js

@@ -84,7 +84,7 @@ export async function validatePatchesManifestConsistency(patchesDir) {
  * Existing metadata is preserved when possible; missing entries are recovered
  * from filename structure, patch contents, and file mtimes.
  * @param patchesDir - Path to the patches directory
- * @param fallbackSourceEsrVersion - ESR version to use for recovered entries
+ * @param fallbackSourceEsrVersion - source version to use for recovered legacy entries
  * @returns {@link RebuildPatchesManifestResult} — the persisted manifest
  *   plus the filenames that were reconstructed from generic defaults.
  */
@@ -135,9 +135,11 @@ export async function rebuildPatchesManifest(patchesDir, fallbackSourceEsrVersio
             category: existing?.category ?? inferred.category,
             name: existing?.name ?? inferred.name,
             description: existing?.description ??
-                `Recovered manifest entry for ${patch.filename}. Review description and ESR version.`,
+                `Recovered manifest entry for ${patch.filename}. Review description and source version.`,
             createdAt: existing?.createdAt ?? new Date(patchStats.mtimeMs).toISOString(),
             sourceEsrVersion: existing?.sourceEsrVersion ?? fallbackSourceEsrVersion,
+            sourceVersion: existing?.sourceVersion ?? existing?.sourceEsrVersion ?? fallbackSourceEsrVersion,
+            ...(existing?.sourceProduct !== undefined ? { sourceProduct: existing.sourceProduct } : {}),
             filesAffected,
         };
         if (existing?.lintIgnore !== undefined)

package/dist/src/core/patch-manifest-query.d.ts

@@ -2,6 +2,7 @@
  * Query helpers: finding patches by file, integrity checks, version compat, stamping.
  */
 import type { PatchesManifest, PatchInfo, PatchMetadata } from '../types/commands/index.js';
+import type { FirefoxProduct } from '../types/config.js';
 /**
  * Gets all file paths claimed by patches other than the excluded one.
  * @param manifest - The patches manifest
@@ -10,7 +11,7 @@ import type { PatchesManifest, PatchInfo, PatchMetadata } from '../types/command
  */
 export declare function getClaimedFiles(manifest: PatchesManifest, excludeFilename: string): Set<string>;
 /**
- * Checks ESR version compatibility.
+ * Checks Firefox source version compatibility.
  * @param patchVersion - Version the patch was created for
  * @param currentVersion - Current project version
  * @returns Warning message if versions differ, null if compatible
@@ -39,10 +40,10 @@ export declare function validatePatchIntegrity(patchesDir: string, engineDir: st
     targetFile: string | null;
 }>>;
 /**
- * Stamps multiple patches with a new `sourceEsrVersion` in a single
+ * Stamps multiple patches with a new source version in a single
  * manifest read-modify-write cycle.
  * @param patchesDir - Path to the patches directory
  * @param filenames - Patch filenames to update
  * @param newVersion - Version string to set (e.g. "140.9.0esr")
  */
-export declare function stampPatchVersions(patchesDir: string, filenames: string[], newVersion: string): Promise<void>;
+export declare function stampPatchVersions(patchesDir: string, filenames: string[], newVersion: string, newProduct?: FirefoxProduct): Promise<void>;

package/dist/src/core/patch-manifest-query.js

@@ -25,7 +25,7 @@ export function getClaimedFiles(manifest, excludeFilename) {
     return claimed;
 }
 /**
- * Checks ESR version compatibility.
+ * Checks Firefox source version compatibility.
  * @param patchVersion - Version the patch was created for
  * @param currentVersion - Current project version
  * @returns Warning message if versions differ, null if compatible
@@ -99,21 +99,29 @@ export async function validatePatchIntegrity(patchesDir, engineDir) {
     return issues;
 }
 /**
- * Stamps multiple patches with a new `sourceEsrVersion` in a single
+ * Stamps multiple patches with a new source version in a single
  * manifest read-modify-write cycle.
  * @param patchesDir - Path to the patches directory
  * @param filenames - Patch filenames to update
  * @param newVersion - Version string to set (e.g. "140.9.0esr")
  */
-export async function stampPatchVersions(patchesDir, filenames, newVersion) {
+export async function stampPatchVersions(patchesDir, filenames, newVersion, newProduct) {
     const manifest = await loadPatchesManifest(patchesDir);
     if (!manifest)
         return;
     const filenameSet = new Set(filenames);
     let modified = false;
     for (const patch of manifest.patches) {
-        if (filenameSet.has(patch.filename) && patch.sourceEsrVersion !== newVersion) {
+        if (!filenameSet.has(patch.filename))
+            continue;
+        if (patch.sourceEsrVersion !== newVersion ||
+            patch.sourceVersion !== newVersion ||
+            (newProduct !== undefined && patch.sourceProduct !== newProduct)) {
             patch.sourceEsrVersion = newVersion;
+            patch.sourceVersion = newVersion;
+            if (newProduct !== undefined) {
+                patch.sourceProduct = newProduct;
+            }
             modified = true;
         }
     }

package/dist/src/core/patch-manifest-validate.js

@@ -3,7 +3,7 @@
  * Schema validation for patches.json manifest data.
  */
 import { parseObject } from '../utils/parse.js';
-import { isArray, isObject, isValidFirefoxVersion, PATCH_CATEGORIES } from '../utils/validation.js';
+import { isArray, isObject, isValidFirefoxProduct, isValidFirefoxVersion, PATCH_CATEGORIES, } from '../utils/validation.js';
 function parseForwardImports(data, label) {
     if (!isArray(data)) {
         throw new Error(`${label} must be an array`);
@@ -45,10 +45,25 @@ export function validatePatchMetadata(data, index) {
     const name = rec.string('name');
     const description = rec.string('description');
     const createdAt = rec.string('createdAt');
-    const sourceEsrVersion = rec.string('sourceEsrVersion');
+    const sourceEsrVersion = rec.optionalString('sourceEsrVersion');
+    const sourceVersion = rec.optionalString('sourceVersion') ?? sourceEsrVersion;
+    if (sourceVersion === undefined) {
+        throw new Error(`patches[${index}] must include sourceVersion or legacy sourceEsrVersion`);
+    }
+    const sourceProductRaw = rec.optionalString('sourceProduct');
+    let sourceProduct;
+    if (sourceProductRaw !== undefined) {
+        if (!isValidFirefoxProduct(sourceProductRaw)) {
+            throw new Error(`patches[${index}].sourceProduct must be one of: firefox, firefox-esr, firefox-beta, firefox-devedition`);
+        }
+        sourceProduct = sourceProductRaw;
+    }
     const order = rec.nonNegativeInteger('order');
     const category = rec.validatedString('category', (value) => /^[a-z][a-z0-9-]*$/.test(value), 'a lowercase category identifier (letters, numbers, hyphens)');
-    if (!isValidFirefoxVersion(sourceEsrVersion)) {
+    if (!isValidFirefoxVersion(sourceVersion)) {
+        throw new Error(`patches[${index}].sourceVersion must be a valid Firefox version string`);
+    }
+    if (sourceEsrVersion !== undefined && !isValidFirefoxVersion(sourceEsrVersion)) {
         throw new Error(`patches[${index}].sourceEsrVersion must be a valid Firefox version string`);
     }
     const filesAffected = rec.stringArray('filesAffected');
@@ -78,9 +93,12 @@ export function validatePatchMetadata(data, index) {
         name,
         description,
         createdAt,
-        sourceEsrVersion,
+        sourceEsrVersion: sourceEsrVersion ?? sourceVersion,
+        sourceVersion,
         filesAffected,
     };
+    if (sourceProduct !== undefined)
+        result.sourceProduct = sourceProduct;
     if (lintIgnore !== undefined)
         result.lintIgnore = lintIgnore;
     if (tier !== undefined)

package/dist/src/core/patch-source-metadata.d.ts

@@ -0,0 +1,8 @@
+import type { PatchMetadata } from '../types/commands/index.js';
+import type { FirefoxConfig, FirefoxProduct } from '../types/config.js';
+/** Metadata fields stamped on new or refreshed patch entries. */
+export declare function buildPatchSourceMetadata(firefox: Pick<FirefoxConfig, 'product' | 'version'>): Pick<PatchMetadata, 'sourceEsrVersion' | 'sourceProduct' | 'sourceVersion'>;
+/** Backward-compatible source version reader for legacy manifests. */
+export declare function getPatchSourceVersion(patch: Pick<PatchMetadata, 'sourceEsrVersion' | 'sourceVersion'>): string;
+/** Backward-compatible source product reader for legacy manifests. */
+export declare function getPatchSourceProduct(patch: Pick<PatchMetadata, 'sourceProduct'>): FirefoxProduct | undefined;

package/dist/src/core/patch-source-metadata.js

@@ -0,0 +1,17 @@
+/** Metadata fields stamped on new or refreshed patch entries. */
+export function buildPatchSourceMetadata(firefox) {
+    return {
+        sourceEsrVersion: firefox.version,
+        sourceProduct: firefox.product,
+        sourceVersion: firefox.version,
+    };
+}
+/** Backward-compatible source version reader for legacy manifests. */
+export function getPatchSourceVersion(patch) {
+    return patch.sourceVersion ?? patch.sourceEsrVersion;
+}
+/** Backward-compatible source product reader for legacy manifests. */
+export function getPatchSourceProduct(patch) {
+    return patch.sourceProduct;
+}
+//# sourceMappingURL=patch-source-metadata.js.map