@hominis/fireforge 0.38.0 → 0.40.0

package/dist/src/core/discard-baseline.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Patch-aware restore planning for `fireforge discard` (FORGE F1, P0).
+ *
+ * The engine convention is: HEAD = pristine upstream Firefox, and the
+ * applied patch queue lives as UNCOMMITTED worktree changes on top of it
+ * (`git apply` without `--index` → patch-edited tracked files are unstaged
+ * modifications, patch-created files are untracked). The pre-0.39.0
+ * `discard` was purely git-mechanical — it restored to HEAD and deleted
+ * untracked files, silently reverting patch-backed files PAST their owning
+ * patch and deleting patch-created files outright.
+ *
+ * This module classifies each status entry against the patch manifest's
+ * ownership claims and plans the correct restore target: the PATCH-APPLIED
+ * baseline (HEAD content folded through every affecting patch in order) for
+ * claimed files, and the legacy git mechanics for unmanaged ones.
+ */
+import type { GitStatusEntry } from './git-base.js';
+/** How one status entry's canonical path will be restored. */
+export type DiscardKind = 'unmanaged' | 'patch-backed' | 'patch-created' | 'patch-deleted';
+/** Restore plan for one git status entry. */
+export interface DiscardBaselinePlan {
+    entry: GitStatusEntry;
+    kind: DiscardKind;
+    /** Claiming patch filenames for `entry.file` ∪ `entry.originalPath`. */
+    owners: string[];
+    /** True when more than one patch claims the path (ownership conflict). */
+    conflicted: boolean;
+    /** Baseline content for `entry.file`; null = absent at baseline. Unset for 'unmanaged'. */
+    expectedContent?: string | null;
+    /** Rename/copy only: baseline content for `originalPath` when that side is claimed. */
+    expectedOriginalContent?: string | null;
+}
+/** Builds an all-unmanaged plan set — the `--to-upstream` (legacy) shape. */
+export declare function planUpstreamDiscards(entries: readonly GitStatusEntry[]): DiscardBaselinePlan[];
+/**
+ * Plans the restore target for each status entry. Entries claimed by the
+ * patch manifest restore to the patch-applied baseline; unclaimed entries
+ * keep the legacy git mechanics. A missing patches dir or empty manifest
+ * degrades every plan to `unmanaged` (identical to pre-0.39.0 behavior).
+ *
+ * A corrupt manifest or an unreconstructible patch baseline REFUSES with a
+ * GeneralError naming `--to-upstream` — silently falling back to pristine
+ * HEAD is exactly the data-loss path this module exists to close.
+ */
+export declare function planDiscardBaselines(patchesDir: string, engineDir: string, entries: readonly GitStatusEntry[]): Promise<DiscardBaselinePlan[]>;
+/**
+ * Applies one restore plan. Patch-claimed paths end up exactly as `import`
+ * leaves them: patched content as an unstaged worktree state (tracked files
+ * read ` M`, created files `??`), nothing staged. Unmanaged plans delegate
+ * to the legacy {@link discardStatusEntry} mechanics.
+ */
+export declare function applyDiscardBaseline(engineDir: string, plan: DiscardBaselinePlan): Promise<void>;
+/** One-line annotation for dry-run listings and confirmation summaries. */
+export declare function describeDiscardBaseline(plan: DiscardBaselinePlan): string;
+/** Single-file outro naming the baseline that was restored. */
+export declare function describeDiscardOutcome(plan: DiscardBaselinePlan, toUpstream: boolean): string;
+/** Batch outro summarising how many files restored to which baseline. */
+export declare function summarizeDiscardBaselines(plans: readonly DiscardBaselinePlan[], succeeded: number): string;
+/** Warn text for a multi-owner (conflicted) restore. */
+export declare function describeConflictWarning(plan: DiscardBaselinePlan): string;

package/dist/src/core/discard-baseline.js

@@ -0,0 +1,232 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Patch-aware restore planning for `fireforge discard` (FORGE F1, P0).
+ *
+ * The engine convention is: HEAD = pristine upstream Firefox, and the
+ * applied patch queue lives as UNCOMMITTED worktree changes on top of it
+ * (`git apply` without `--index` → patch-edited tracked files are unstaged
+ * modifications, patch-created files are untracked). The pre-0.39.0
+ * `discard` was purely git-mechanical — it restored to HEAD and deleted
+ * untracked files, silently reverting patch-backed files PAST their owning
+ * patch and deleting patch-created files outright.
+ *
+ * This module classifies each status entry against the patch manifest's
+ * ownership claims and plans the correct restore target: the PATCH-APPLIED
+ * baseline (HEAD content folded through every affecting patch in order) for
+ * claimed files, and the legacy git mechanics for unmanaged ones.
+ */
+import { join } from 'node:path';
+import { GeneralError } from '../errors/base.js';
+import { toError } from '../utils/errors.js';
+import { readText, removeFile, writeText } from '../utils/fs.js';
+import { discardStatusEntry, fileExistsInHead, listTrackedInHead, restoreTrackedPath, unstageFiles, } from './git-file-ops.js';
+import { createPatchedContentComputer } from './patch-apply.js';
+import { loadPatchesManifestState } from './patch-manifest-io.js';
+import { parseDiffSections } from './patch-parse.js';
+import { buildPatchClaims } from './status-classify.js';
+/** Builds an all-unmanaged plan set — the `--to-upstream` (legacy) shape. */
+export function planUpstreamDiscards(entries) {
+    return entries.map((entry) => ({ entry, kind: 'unmanaged', owners: [], conflicted: false }));
+}
+/**
+ * Plans the restore target for each status entry. Entries claimed by the
+ * patch manifest restore to the patch-applied baseline; unclaimed entries
+ * keep the legacy git mechanics. A missing patches dir or empty manifest
+ * degrades every plan to `unmanaged` (identical to pre-0.39.0 behavior).
+ *
+ * A corrupt manifest or an unreconstructible patch baseline REFUSES with a
+ * GeneralError naming `--to-upstream` — silently falling back to pristine
+ * HEAD is exactly the data-loss path this module exists to close.
+ */
+export async function planDiscardBaselines(patchesDir, engineDir, entries) {
+    const state = await loadPatchesManifestState(patchesDir);
+    if (state.exists && state.parseError) {
+        throw new GeneralError('patches/patches.json is unreadable — refusing to discard while patch ownership cannot be ' +
+            'determined. Fix the manifest, or pass --to-upstream to explicitly revert to pristine ' +
+            'upstream (HEAD).');
+    }
+    const claims = state.manifest
+        ? buildPatchClaims(state.manifest.patches)
+        : new Map();
+    const plans = [];
+    const claimedEntries = entries.filter((entry) => claims.has(entry.file) || (entry.originalPath !== undefined && claims.has(entry.originalPath)));
+    if (claimedEntries.length === 0) {
+        return planUpstreamDiscards(entries);
+    }
+    const computePatched = await createPatchedContentComputer(patchesDir, engineDir);
+    const claimedFiles = [
+        ...new Set(claimedEntries.flatMap((entry) => entry.originalPath !== undefined ? [entry.file, entry.originalPath] : [entry.file])),
+    ];
+    const trackedInHead = await listTrackedInHead(engineDir, claimedFiles);
+    const computeExpected = async (path) => {
+        try {
+            return await computePatched(path);
+        }
+        catch (error) {
+            throw new GeneralError(`Cannot reconstruct the patch baseline for ${path} (${toError(error).message}). ` +
+                'Fix the owning patch, or pass --to-upstream to explicitly revert to pristine ' +
+                'upstream (HEAD).');
+        }
+    };
+    // `computePatchedContent` folds a deletion into an empty string (an
+    // apply-to-content limitation), which is indistinguishable from a
+    // legitimately empty file. Consult the owning patches' diff sections
+    // directly: the LAST section (highest-ordered owner) naming the path
+    // decides whether the baseline is "absent".
+    const sectionCache = new Map();
+    const isDeletedAtBaseline = async (path, owners) => {
+        for (let i = owners.length - 1; i >= 0; i--) {
+            const owner = owners[i];
+            if (owner === undefined)
+                continue;
+            let sections = sectionCache.get(owner);
+            if (!sections) {
+                try {
+                    sections = parseDiffSections(await readText(join(patchesDir, owner)));
+                }
+                catch {
+                    sections = [];
+                }
+                sectionCache.set(owner, sections);
+            }
+            for (const section of sections) {
+                if (section.targetPath === path || section.sourcePath === path) {
+                    return section.isDeletedFile;
+                }
+            }
+        }
+        return false;
+    };
+    for (const entry of entries) {
+        const owners = [
+            ...new Set([
+                ...(claims.get(entry.file) ?? []),
+                ...(entry.originalPath !== undefined ? (claims.get(entry.originalPath) ?? []) : []),
+            ]),
+        ];
+        if (owners.length === 0) {
+            plans.push({ entry, kind: 'unmanaged', owners, conflicted: false });
+            continue;
+        }
+        let expectedContent = claims.has(entry.file) ? await computeExpected(entry.file) : null;
+        if (expectedContent !== null &&
+            (await isDeletedAtBaseline(entry.file, claims.get(entry.file) ?? []))) {
+            expectedContent = null;
+        }
+        const expectedOriginalContent = entry.originalPath !== undefined && claims.has(entry.originalPath)
+            ? await computeExpected(entry.originalPath)
+            : undefined;
+        const kind = expectedContent === null
+            ? 'patch-deleted'
+            : trackedInHead.has(entry.file)
+                ? 'patch-backed'
+                : 'patch-created';
+        plans.push({
+            entry,
+            kind,
+            owners,
+            conflicted: owners.length > 1,
+            expectedContent,
+            ...(expectedOriginalContent !== undefined ? { expectedOriginalContent } : {}),
+        });
+    }
+    return plans;
+}
+/**
+ * Applies one restore plan. Patch-claimed paths end up exactly as `import`
+ * leaves them: patched content as an unstaged worktree state (tracked files
+ * read ` M`, created files `??`), nothing staged. Unmanaged plans delegate
+ * to the legacy {@link discardStatusEntry} mechanics.
+ */
+export async function applyDiscardBaseline(engineDir, plan) {
+    if (plan.kind === 'unmanaged') {
+        await discardStatusEntry(engineDir, plan.entry);
+        return;
+    }
+    const { entry } = plan;
+    // Drop any staged edits/adds/renames first so the rewritten content is a
+    // plain worktree state (harmless when nothing is staged; skipped for
+    // purely-untracked entries which have no index footprint).
+    if (!entry.isUntracked) {
+        const indexPaths = entry.originalPath !== undefined ? [entry.file, entry.originalPath] : [entry.file];
+        await unstageFiles(engineDir, indexPaths);
+    }
+    if (plan.expectedContent === null || plan.expectedContent === undefined) {
+        await removeFile(join(engineDir, entry.file));
+    }
+    else {
+        await writeText(join(engineDir, entry.file), plan.expectedContent);
+    }
+    // A rename/copy's original side restores to ITS baseline too: the patch
+    // baseline when claimed, else the legacy HEAD restore (matching what
+    // discardStatusEntry does for that side).
+    if (entry.originalPath !== undefined) {
+        if (plan.expectedOriginalContent !== undefined) {
+            if (plan.expectedOriginalContent === null) {
+                await removeFile(join(engineDir, entry.originalPath));
+            }
+            else {
+                await writeText(join(engineDir, entry.originalPath), plan.expectedOriginalContent);
+            }
+        }
+        else if (await fileExistsInHead(engineDir, entry.originalPath)) {
+            await restoreTrackedPath(engineDir, entry.originalPath);
+        }
+    }
+}
+/** One-line annotation for dry-run listings and confirmation summaries. */
+export function describeDiscardBaseline(plan) {
+    const owners = plan.owners.join(' + ');
+    switch (plan.kind) {
+        case 'unmanaged':
+            return plan.entry.isUntracked ? 'unmanaged — delete' : 'unmanaged — revert to upstream';
+        case 'patch-backed':
+            return `patch baseline: ${owners}${plan.conflicted ? ' (conflict)' : ''}`;
+        case 'patch-created':
+            return `re-materialize from ${owners}${plan.conflicted ? ' (conflict)' : ''}`;
+        case 'patch-deleted':
+            return `delete — ${owners} removes it`;
+    }
+}
+/** Single-file outro naming the baseline that was restored. */
+export function describeDiscardOutcome(plan, toUpstream) {
+    if (toUpstream)
+        return 'File restored to pristine upstream (HEAD)';
+    const owners = plan.owners.join(' + ');
+    switch (plan.kind) {
+        case 'unmanaged':
+            return 'File restored to original state';
+        case 'patch-backed':
+            return `File restored to patch baseline (${owners})`;
+        case 'patch-created':
+            return `File re-materialized from patch baseline (${owners})`;
+        case 'patch-deleted':
+            return `File removed to match patch baseline (${owners} deletes it)`;
+    }
+}
+/** Batch outro summarising how many files restored to which baseline. */
+export function summarizeDiscardBaselines(plans, succeeded) {
+    const patchBacked = plans.filter((p) => p.kind === 'patch-backed').length;
+    const created = plans.filter((p) => p.kind === 'patch-created').length;
+    const deleted = plans.filter((p) => p.kind === 'patch-deleted').length;
+    const unmanaged = plans.filter((p) => p.kind === 'unmanaged').length;
+    if (patchBacked + created + deleted === 0) {
+        return `${String(succeeded)} file(s) restored to upstream state`;
+    }
+    const parts = [];
+    if (patchBacked > 0)
+        parts.push(`${String(patchBacked)} to patch baseline`);
+    if (created > 0)
+        parts.push(`${String(created)} re-materialized`);
+    if (deleted > 0)
+        parts.push(`${String(deleted)} removed per patch baseline`);
+    if (unmanaged > 0)
+        parts.push(`${String(unmanaged)} to upstream state`);
+    return `${String(succeeded)} file(s) restored: ${parts.join(', ')}`;
+}
+/** Warn text for a multi-owner (conflicted) restore. */
+export function describeConflictWarning(plan) {
+    return (`${plan.entry.file} is claimed by ${String(plan.owners.length)} patches ` +
+        `(${plan.owners.join(', ')}). Restored the cumulative baseline; run ` +
+        '"fireforge status --ownership" to resolve ownership.');
+}

package/dist/src/core/license-headers.d.ts

@@ -81,6 +81,18 @@ export declare function hasAnyLicenseHeaderAnyStyle(content: string): boolean;
  * @param maxLines - Number of leading lines to inspect (default 10)
  */
 export declare function containsUpstreamLicenseText(content: string, maxLines?: number): boolean;
+/**
+ * Returns true when the head of `content` carries a recognized THIRD-PARTY
+ * permissive license banner (MIT / ISC / BSD-2 / BSD-3 / Apache-2.0), in any
+ * comment style. Used by `export` to treat such files as vendored: offering
+ * to prepend the project's own license header onto a byte-identity-pinned
+ * upstream bundle would mislicense third-party code (FORGE F15).
+ *
+ * @param content  - File content to check
+ * @param maxLines - Number of leading lines to inspect (default 30 — full
+ *   MIT/BSD license texts run longer than the 10-line project-header scan)
+ */
+export declare function hasThirdPartyPermissiveBanner(content: string, maxLines?: number): boolean;
 /**
  * Prepends the license header to a file on disk if it is not already present.
  *

package/dist/src/core/license-headers.js

@@ -252,6 +252,33 @@ export function containsUpstreamLicenseText(content, maxLines = 10) {
     ];
     return markers.some((marker) => scanText.includes(marker));
 }
+/**
+ * Returns true when the head of `content` carries a recognized THIRD-PARTY
+ * permissive license banner (MIT / ISC / BSD-2 / BSD-3 / Apache-2.0), in any
+ * comment style. Used by `export` to treat such files as vendored: offering
+ * to prepend the project's own license header onto a byte-identity-pinned
+ * upstream bundle would mislicense third-party code (FORGE F15).
+ *
+ * @param content  - File content to check
+ * @param maxLines - Number of leading lines to inspect (default 30 — full
+ *   MIT/BSD license texts run longer than the 10-line project-header scan)
+ */
+export function hasThirdPartyPermissiveBanner(content, maxLines = 30) {
+    const head = content.split('\n').slice(0, maxLines).join('\n');
+    const scanText = normalizeLicenseHeadForScan(head).toLowerCase();
+    const markers = [
+        'mit license',
+        'permission is hereby granted, free of charge',
+        'isc license',
+        'permission to use, copy, modify',
+        'redistribution and use in source and binary forms',
+        'apache license',
+        'licensed under the apache license',
+    ];
+    if (markers.some((marker) => scanText.includes(marker)))
+        return true;
+    return /spdx-license-identifier:\s*(mit|isc|bsd-2-clause|bsd-3-clause|apache-2\.0)\b/.test(scanText);
+}
 /**
  * Prepends the license header to a file on disk if it is not already present.
  *

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

@@ -1,11 +1,15 @@
 import type { PatchLintIssue, PatchMetadata } from '../types/commands/index.js';
 import type { FireForgeConfig } from '../types/config.js';
 import { type PatchQueueContext } from './patch-lint.js';
-export declare const LINT_CACHE_SCHEMA_VERSION = 1;
+export declare const LINT_CACHE_SCHEMA_VERSION = 2;
 export interface PerPatchLintCacheEntry {
     key: string;
     patchFilename: string;
     issues: PatchLintIssue[];
+    /** Issues dropped by the patch's lintIgnore waivers (FORGE G10). */
+    suppressed: PatchLintIssue[];
+    /** Non-binary diff line count measured by the cached lint run. */
+    lineCount: number;
     updatedAt: string;
 }
 export interface PerPatchLintCacheFile {
@@ -36,7 +40,13 @@ export declare function loadPerPatchLintCache(projectRoot: string): Promise<PerP
 export declare function savePerPatchLintCache(projectRoot: string, cache: PerPatchLintCacheFile): Promise<void>;
 /** Clears the per-patch lint cache by replacing it with an empty document. */
 export declare function clearPerPatchLintCache(projectRoot: string): Promise<void>;
-/** Returns cached issues for a patch when the stored key still matches. */
-export declare function getCachedPerPatchLintIssues(cache: PerPatchLintCacheFile, patchFilename: string, key: string): PatchLintIssue[] | undefined;
-/** Stores per-patch lint issues after a successful lint calculation. */
-export declare function setCachedPerPatchLintIssues(cache: PerPatchLintCacheFile, patchFilename: string, key: string, issues: PatchLintIssue[]): void;
+/** Cached per-patch lint payload returned on a key match. */
+export interface CachedPerPatchLint {
+    issues: PatchLintIssue[];
+    suppressed: PatchLintIssue[];
+    lineCount: number;
+}
+/** Returns the cached lint payload for a patch when the stored key still matches. */
+export declare function getCachedPerPatchLintIssues(cache: PerPatchLintCacheFile, patchFilename: string, key: string): CachedPerPatchLint | undefined;
+/** Stores the per-patch lint payload after a successful lint calculation. */
+export declare function setCachedPerPatchLintIssues(cache: PerPatchLintCacheFile, patchFilename: string, key: string, issues: PatchLintIssue[], suppressed: PatchLintIssue[], lineCount: number): void;

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

@@ -7,7 +7,11 @@ import { getPackageVersion } from '../utils/package-root.js';
 import { getFurnacePaths } from './furnace-config.js';
 import { git } from './git-base.js';
 import { collectNewFileCreatorsByPath } from './patch-lint.js';
-export const LINT_CACHE_SCHEMA_VERSION = 1;
+// Schema 2 (FORGE G10): entries additionally carry the lintIgnore-suppressed
+// issues and the measured non-binary line count, so a warm run can report
+// waived size measurements identically to a cold one (the F5-class hazard:
+// a cache hit must never surface LESS than a fresh lint).
+export const LINT_CACHE_SCHEMA_VERSION = 2;
 const LINT_IMPLEMENTATION_VERSION = 1;
 const LINT_CACHE_DIRNAME = 'lint-cache';
 const PER_PATCH_CACHE_FILENAME = 'per-patch-v1.json';
@@ -118,6 +122,8 @@ function isCacheEntry(value) {
     return (typeof entry.key === 'string' &&
         typeof entry.patchFilename === 'string' &&
         Array.isArray(entry.issues) &&
+        Array.isArray(entry.suppressed) &&
+        typeof entry.lineCount === 'number' &&
         typeof entry.updatedAt === 'string');
 }
 /** Loads the per-patch lint cache, treating missing or invalid files as empty. */
@@ -158,19 +164,25 @@ export async function savePerPatchLintCache(projectRoot, cache) {
 export async function clearPerPatchLintCache(projectRoot) {
     await writeJson(getPerPatchLintCachePath(projectRoot), createEmptyPerPatchLintCache());
 }
-/** Returns cached issues for a patch when the stored key still matches. */
+/** Returns the cached lint payload for a patch when the stored key still matches. */
 export function getCachedPerPatchLintIssues(cache, patchFilename, key) {
     const entry = cache.entries[patchFilename];
     if (!entry || entry.key !== key)
         return undefined;
-    return entry.issues.map((issue) => ({ ...issue }));
+    return {
+        issues: entry.issues.map((issue) => ({ ...issue })),
+        suppressed: entry.suppressed.map((issue) => ({ ...issue })),
+        lineCount: entry.lineCount,
+    };
 }
-/** Stores per-patch lint issues after a successful lint calculation. */
-export function setCachedPerPatchLintIssues(cache, patchFilename, key, issues) {
+/** Stores the per-patch lint payload after a successful lint calculation. */
+export function setCachedPerPatchLintIssues(cache, patchFilename, key, issues, suppressed, lineCount) {
     cache.entries[patchFilename] = {
         key,
         patchFilename,
         issues: issues.map((issue) => ({ ...issue })),
+        suppressed: suppressed.map((issue) => ({ ...issue })),
+        lineCount,
         updatedAt: new Date().toISOString(),
     };
 }

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

@@ -1,8 +1,8 @@
 import type { PatchCategory, PatchesManifest, PatchInfo, PatchMetadata } from '../types/commands/index.js';
 import type { FireForgeConfig } from '../types/config.js';
 import { type SupersedeCoverageDetail } from './patch-export-coverage.js';
-export { findAllPatchesForFiles, findAllPatchesForFilesWithDetails, findSupersededPatches, isPatchFullyCovered, type PatchCoverage, type SupersedeCoverageDetail, } from './patch-export-coverage.js';
-export { type ClearablePatchMetadataField, mutatePatchMetadata, type PatchMetadataMutation, type PatchMetadataMutationResult, updatePatchMetadata, } from './patch-export-metadata.js';
+export { findAllPatchesForFiles, findAllPatchesForFilesWithDetails, findSupersededPatches, isPatchFullyCovered, type SupersedeCoverageDetail, } from './patch-export-coverage.js';
+export { mutatePatchMetadata, updatePatchMetadata } from './patch-export-metadata.js';
 export { updatePatchAndMetadata } from './patch-export-update.js';
 /**
  * Gets the next patch number for a new patch.
@@ -30,7 +30,16 @@ export declare function sanitizeName(name: string): string;
  * double-prefix incident) also collapses. Exported for direct testing.
  */
 export declare function stripRedundantCategoryPrefix(sanitizedName: string, category: string): string;
-/** Sanitizes a patch name and drops redundant category/full-stem prefixes. */
+/**
+ * Sanitizes a patch name and drops redundant category/full-stem prefixes.
+ *
+ * A single trailing `.patch` extension is stripped before sanitisation:
+ * operators frequently pass a full patch FILENAME where a name is expected
+ * (`move-files <from> 348-ui-foo.patch --create`, `rename --to foo.patch`),
+ * and 0.38.0 slugged the extension into `-patch`, producing double-suffixed
+ * `...-patch.patch` files. A name that deliberately ends in a literal
+ * `-patch` slug segment must now be written without the dot form.
+ */
 export declare function patchNameSlug(name: string, category: string): string;
 /**
  * Generates the next patch filename with category.

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

@@ -10,7 +10,7 @@ import { findAllPatchesForFilesWithDetails, } from './patch-export-coverage.js';
 import { addPatchToManifest, loadPatchesManifestForWrite, PATCHES_MANIFEST, savePatchesManifest, } from './patch-manifest.js';
 import { allocatePolicyOrder, enforcePatchPolicy } from './patch-policy.js';
 export { findAllPatchesForFiles, findAllPatchesForFilesWithDetails, findSupersededPatches, isPatchFullyCovered, } from './patch-export-coverage.js';
-export { mutatePatchMetadata, updatePatchMetadata, } from './patch-export-metadata.js';
+export { mutatePatchMetadata, updatePatchMetadata } from './patch-export-metadata.js';
 export { updatePatchAndMetadata } from './patch-export-update.js';
 /**
  * Gets the next patch number for a new patch.
@@ -75,9 +75,19 @@ export function stripRedundantCategoryPrefix(sanitizedName, category) {
     }
     return stripped.length > 0 ? stripped : sanitizedName;
 }
-/** Sanitizes a patch name and drops redundant category/full-stem prefixes. */
+/**
+ * Sanitizes a patch name and drops redundant category/full-stem prefixes.
+ *
+ * A single trailing `.patch` extension is stripped before sanitisation:
+ * operators frequently pass a full patch FILENAME where a name is expected
+ * (`move-files <from> 348-ui-foo.patch --create`, `rename --to foo.patch`),
+ * and 0.38.0 slugged the extension into `-patch`, producing double-suffixed
+ * `...-patch.patch` files. A name that deliberately ends in a literal
+ * `-patch` slug segment must now be written without the dot form.
+ */
 export function patchNameSlug(name, category) {
-    return stripRedundantCategoryPrefix(sanitizeName(name), category);
+    const stem = name.replace(/\.patch$/i, '');
+    return stripRedundantCategoryPrefix(sanitizeName(stem), category);
 }
 /**
  * Generates the next patch filename with category.

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

@@ -25,11 +25,16 @@
  * while reporting only the patch under export.
  */
 import type { PatchLintIssue } from '../types/commands/index.js';
-import type { PatchLintCheckJsCompilerOptions, PatchLintConfig } from '../types/config.js';
+import type { PatchLintCheckJsCompilerOptions, PatchLintConfig, PatchLintSeverityGate } from '../types/config.js';
 /** How a checkJs run controls reporting and resolution; see module docs. */
 export interface CheckJsMode {
     strict: boolean;
     compilerOptions?: PatchLintCheckJsCompilerOptions;
+    /**
+     * How to report undefined free identifiers (TS2304/TS2552). Default
+     * 'warning' — see `patchLint.undefinedIdentifiers` (FORGE F12).
+     */
+    undefinedIdentifiers?: PatchLintSeverityGate;
 }
 /**
  * Result of {@link runCheckJsGrouped}: diagnostics attributed to the
@@ -58,7 +63,7 @@ export interface GroupedCheckJsResult {
  * @param mode - Strictness preset plus allowlisted compiler-option overrides
  * @returns Diagnostics grouped per owning file plus run-level errors
  */
-export declare function runCheckJsGrouped(repoDir: string, resolutionOwned: Set<string>, extraShimPath?: string, projectRoot?: string, mode?: CheckJsMode): Promise<GroupedCheckJsResult>;
+export declare function runCheckJsGrouped(repoDir: string, resolutionOwned: Set<string>, extraShimPath?: string, projectRoot?: string, mode?: CheckJsMode, builtinShimSuffix?: string): Promise<GroupedCheckJsResult>;
 /**
  * Flattens a {@link runCheckJsGrouped} run into a single issue list. When
  * `reportScope` is supplied, only diagnostics from files in that set are
@@ -88,6 +93,24 @@ export declare function runCheckJs(repoDir: string, patchOwnedFiles: Set<string>
  *   not surface other patches' diagnostics)
  */
 export declare function invokePatchLintCheckJs(repoDir: string, patchOwnedFiles: Set<string>, patchLint: PatchLintConfig, projectRoot: string, reportScope?: ReadonlySet<string>): Promise<PatchLintIssue[]>;
+/**
+ * Runs the checkJs pass over patch-owned test `.js` files (FORGE G5,
+ * `patchLint.checkJsTestFiles`). Each test file gets its OWN small
+ * program — mochitest scripts share top-level scope only with their
+ * directory's `head*.js` helpers, so one multi-script program would emit
+ * false cross-file redeclaration errors — with roots = the test file plus
+ * any same-directory patch-owned `head*.js`, checked against the built-in
+ * Firefox shim + {@link TEST_HARNESS_SHIM} + the optional consumer
+ * `checkJsTestShim`. Only the target file's diagnostics are reported per
+ * program (head helpers report from their own program), and run-level
+ * errors are de-duplicated across programs.
+ *
+ * @param repoDir - Absolute engine (repository) directory
+ * @param testFiles - Patch-owned test-script paths (repo-relative)
+ * @param patchLint - The resolved `patchLint` config block
+ * @param projectRoot - FireForge project root for shim resolution
+ */
+export declare function runCheckJsTestFilesGrouped(repoDir: string, testFiles: Set<string>, patchLint: PatchLintConfig, projectRoot: string): Promise<GroupedCheckJsResult>;
 /**
  * Grouped variant of {@link invokePatchLintCheckJs}: builds one queue-wide
  * checkJs program over `patchOwnedFiles` and returns its findings grouped by