@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,45 +0,0 @@
-/**
- * The checkJs part of the per-patch lint cache key.
- *
- * A patch's checkJs verdict depends on more than the files it owns. Its
- * `.sys.mjs` modules are checked in one program that resolves every
- * patch-owned `.sys.mjs` in the queue, and each of its test scripts in a
- * program that also loads the directory's patch-owned `head*.js`, the
- * modules the queue creates up to the test's own patch, the targets of a
- * reviewed `checkJsCompilerOptions.paths` mapping and, for the hint text,
- * the unmanaged companions a head pulls in. Which modules a test can
- * resolve depends on the queue order. A key over only the patch's own
- * files replays a verdict after another patch's module changed, and keeps
- * replaying a red after that module was restored byte for byte.
- *
- * {@link checkJsWorldDigest} hashes that world: the ordered queue (each
- * patch's created files, and the test scripts it modifies), the content of
- * every file in the union of those programs, and the TypeScript version.
- * The digest is shared by every checkJs-relevant patch in a run, so a
- * change anywhere in the world misses every such patch. That costs no
- * extra program build: the first miss builds the queue-wide program, and
- * every later miss slices from it.
- *
- * Memoised per queue context, which is one run's snapshot: file contents
- * are hashed once per context, and the digest is recomputed only after an
- * in-place entry update (see `invalidateNewFileCreatorsCache`). Engine
- * edits made while a context is alive are not observed.
- */
-import type { PatchLintConfig } from '../types/config.js';
-import type { PatchQueueContext } from './patch-lint-cross.js';
-/**
- * True when a patch that has `file` among its affected files can carry a
- * checkJs verdict: a `.sys.mjs` module, or a test script when
- * `patchLint.checkJsTestFiles` is on.
- */
-export declare function isCheckJsCacheRelevant(file: string, patchLint: PatchLintConfig): boolean;
-/**
- * Digest of everything outside a patch's own files that its per-patch
- * checkJs verdict can depend on. See the module docs for what it covers
- * and how it is memoised.
- *
- * @param engineDir - Absolute engine directory the programs read
- * @param patchLint - The resolved `patchLint` block
- * @param ctx - The run's queue context
- */
-export declare function checkJsWorldDigest(engineDir: string, patchLint: PatchLintConfig, ctx: PatchQueueContext): Promise<string>;

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

@@ -1,195 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The checkJs part of the per-patch lint cache key.
- *
- * A patch's checkJs verdict depends on more than the files it owns. Its
- * `.sys.mjs` modules are checked in one program that resolves every
- * patch-owned `.sys.mjs` in the queue, and each of its test scripts in a
- * program that also loads the directory's patch-owned `head*.js`, the
- * modules the queue creates up to the test's own patch, the targets of a
- * reviewed `checkJsCompilerOptions.paths` mapping and, for the hint text,
- * the unmanaged companions a head pulls in. Which modules a test can
- * resolve depends on the queue order. A key over only the patch's own
- * files replays a verdict after another patch's module changed, and keeps
- * replaying a red after that module was restored byte for byte.
- *
- * {@link checkJsWorldDigest} hashes that world: the ordered queue (each
- * patch's created files, and the test scripts it modifies), the content of
- * every file in the union of those programs, and the TypeScript version.
- * The digest is shared by every checkJs-relevant patch in a run, so a
- * change anywhere in the world misses every such patch. That costs no
- * extra program build: the first miss builds the queue-wide program, and
- * every later miss slices from it.
- *
- * Memoised per queue context, which is one run's snapshot: file contents
- * are hashed once per context, and the digest is recomputed only after an
- * in-place entry update (see `invalidateNewFileCreatorsCache`). Engine
- * edits made while a context is alive are not observed.
- */
-import { readdir, readFile } from 'node:fs/promises';
-import { join, relative, resolve } from 'node:path';
-import { sha256Hex } from '../utils/hash.js';
-import { normalizePathSlashes } from '../utils/paths.js';
-import { collectNewFileCreatorsByPath } from './patch-lint-cross.js';
-import { isTestScriptFile } from './patch-lint-ownership.js';
-import { collectUnmanagedCompanions } from './patch-lint-unmanaged-companion.js';
-/** Files visited under one wildcard `paths` target before giving up on it. */
-const PATHS_TARGET_WALK_LIMIT = 10_000;
-const HEAD_SCRIPT = /^head(?:_.*)?\.js$/;
-/** Content hashes per run, keyed by absolute path. Survives entry updates. */
-const fileHashMemo = new WeakMap();
-/** Digests per creators map, which an in-place entry update replaces. */
-const digestMemo = new WeakMap();
-let typescriptVersion;
-/**
- * True when a patch that has `file` among its affected files can carry a
- * checkJs verdict: a `.sys.mjs` module, or a test script when
- * `patchLint.checkJsTestFiles` is on.
- */
-export function isCheckJsCacheRelevant(file, patchLint) {
-    return (file.endsWith('.sys.mjs') || (patchLint.checkJsTestFiles === true && isTestScriptFile(file)));
-}
-async function readTypescriptVersion() {
-    try {
-        return (await import('typescript')).version;
-    }
-    catch {
-        return null;
-    }
-}
-function hashFile(ctx, absolute) {
-    let perRun = fileHashMemo.get(ctx);
-    if (!perRun) {
-        perRun = new Map();
-        fileHashMemo.set(ctx, perRun);
-    }
-    let pending = perRun.get(absolute);
-    if (!pending) {
-        pending = readFile(absolute).then((content) => sha256Hex(content), () => null);
-        perRun.set(absolute, pending);
-    }
-    return pending;
-}
-/**
- * Engine-relative files a wildcard `paths` target can resolve to: the files
- * under the target's static directory that match its prefix and suffix.
- * Returns undefined when the walk passes {@link PATHS_TARGET_WALK_LIMIT}
- * (a target rooted high in the tree), so the key falls back to the target
- * string alone instead of walking Firefox.
- */
-async function expandPathsTarget(engineDir, target) {
-    const star = target.indexOf('*');
-    if (star === -1)
-        return [target];
-    const prefix = target.slice(0, star);
-    const suffix = target.slice(star + 1);
-    const staticDir = prefix.slice(0, prefix.lastIndexOf('/') + 1);
-    const matches = [];
-    const pending = [resolve(engineDir, staticDir)];
-    let visited = 0;
-    while (pending.length > 0) {
-        const dir = pending.pop();
-        let entries;
-        try {
-            entries = await readdir(dir, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            visited += 1;
-            if (visited > PATHS_TARGET_WALK_LIMIT)
-                return undefined;
-            const absolute = join(dir, entry.name);
-            if (entry.isDirectory()) {
-                pending.push(absolute);
-                continue;
-            }
-            const rel = normalizePathSlashes(relative(engineDir, absolute));
-            if (rel.length >= prefix.length + suffix.length &&
-                rel.startsWith(prefix) &&
-                rel.endsWith(suffix)) {
-                matches.push(rel);
-            }
-        }
-    }
-    return matches;
-}
-/** The queue order part of the digest: what each patch creates, in order. */
-function queueShape(ctx) {
-    return ctx.entries.map((entry) => [
-        entry.filename,
-        [...new Set([...entry.newFiles.keys(), ...entry.createdFiles])].sort(),
-        [...entry.modifiedFileAdditions.keys()].filter(isTestScriptFile).sort(),
-    ]);
-}
-async function computeDigest(engineDir, patchLint, ctx, created) {
-    const universe = new Set();
-    for (const file of created) {
-        if (file.endsWith('.mjs'))
-            universe.add(file);
-    }
-    const tests = created.filter(isTestScriptFile);
-    if (patchLint.checkJsTestFiles === true) {
-        for (const file of tests) {
-            if (HEAD_SCRIPT.test(file.slice(file.lastIndexOf('/') + 1)))
-                universe.add(file);
-        }
-        const companions = await collectUnmanagedCompanions(engineDir, tests, new Set(tests));
-        for (const companion of companions)
-            universe.add(companion.file);
-    }
-    const unwalked = [];
-    for (const targets of Object.values(patchLint.checkJsCompilerOptions?.paths ?? {})) {
-        for (const target of targets) {
-            const expanded = await expandPathsTarget(engineDir, target);
-            if (expanded === undefined)
-                unwalked.push(target);
-            else
-                for (const file of expanded)
-                    universe.add(file);
-        }
-    }
-    const files = [...universe].sort();
-    const hashes = await Promise.all(files.map((file) => hashFile(ctx, resolve(engineDir, file))));
-    typescriptVersion ??= readTypescriptVersion();
-    return sha256Hex(JSON.stringify({
-        queue: queueShape(ctx),
-        files: files.map((file, index) => [file, hashes[index] ?? null]),
-        unwalkedPathsTargets: unwalked.sort(),
-        typescript: await typescriptVersion,
-    }));
-}
-/**
- * Digest of everything outside a patch's own files that its per-patch
- * checkJs verdict can depend on. See the module docs for what it covers
- * and how it is memoised.
- *
- * @param engineDir - Absolute engine directory the programs read
- * @param patchLint - The resolved `patchLint` block
- * @param ctx - The run's queue context
- */
-export function checkJsWorldDigest(engineDir, patchLint, ctx) {
-    const creators = collectNewFileCreatorsByPath(ctx);
-    let perCreators = digestMemo.get(creators);
-    if (!perCreators) {
-        perCreators = new Map();
-        digestMemo.set(creators, perCreators);
-    }
-    const memoKey = JSON.stringify([
-        engineDir,
-        patchLint.checkJsTestFiles === true,
-        patchLint.checkJsCompilerOptions?.paths ?? null,
-    ]);
-    let digest = perCreators.get(memoKey);
-    if (!digest) {
-        const created = new Set(creators.keys());
-        for (const entry of ctx.entries) {
-            for (const file of entry.newFiles.keys())
-                created.add(file);
-        }
-        digest = computeDigest(engineDir, patchLint, ctx, [...created].sort());
-        perCreators.set(memoKey, digest);
-    }
-    return digest;
-}

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

@@ -1,79 +0,0 @@
-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 = 5;
-export interface PerPatchLintCacheEntry {
-    key: string;
-    patchFilename: string;
-    issues: PatchLintIssue[];
-    /** Issues dropped by the patch's lintIgnore waivers. */
-    suppressed: PatchLintIssue[];
-    /** Non-binary diff line count measured by the cached lint run. */
-    lineCount: number;
-    /**
-     * Sorted lint-ignore waiver ids in force when this entry was computed.
-     * A lookup presenting a different effective set misses.
-     */
-    lintIgnore: string[];
-    updatedAt: string;
-}
-export interface PerPatchLintCacheFile {
-    schemaVersion: typeof LINT_CACHE_SCHEMA_VERSION;
-    entries: Record<string, PerPatchLintCacheEntry>;
-}
-export interface PerPatchLintCacheKeyInput {
-    projectRoot: string;
-    engineDir: string;
-    patchesDir: string;
-    patch: PatchMetadata;
-    existingFiles: string[];
-    config: FireForgeConfig;
-    queueContext: PatchQueueContext;
-    engineHeadSha?: string;
-    packageVersion?: string;
-}
-/** Returns the engine git HEAD identity used to guard diff-derived cache hits. */
-export declare function getPerPatchLintCacheHeadSha(engineDir: string): Promise<string>;
-/**
- * Builds the complete per-patch lint cache key for one lintable patch.
- * The key includes source, metadata, config, engine state, and ownership
- * inputs, plus the checkJs world when the patch has a checkJs-relevant file.
- */
-export declare function buildPerPatchLintCacheKey(input: PerPatchLintCacheKeyInput): Promise<string>;
-/** Loads the per-patch lint cache, treating missing or invalid files as empty. */
-export declare function loadPerPatchLintCache(projectRoot: string): Promise<PerPatchLintCacheFile>;
-/** Persists the per-patch lint cache atomically through the shared JSON writer. */
-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>;
-/** 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 and the entry was computed under the same lint-ignore waiver set.
- * A waiver change makes a replayed verdict actively wrong, so the waiver set
- * is compared explicitly rather than trusted to the key.
- */
-export declare function getCachedPerPatchLintIssues(cache: PerPatchLintCacheFile, patchFilename: string, key: string, lintIgnore?: Iterable<string>): CachedPerPatchLint | undefined;
-export interface SetCachedPerPatchLintIssuesInput {
-    /** Cache file to mutate in place. */
-    cache: PerPatchLintCacheFile;
-    /** Patch the payload belongs to, and also the cache entry key. */
-    patchFilename: string;
-    /** Fingerprint the payload is valid for. */
-    key: string;
-    /** Reported issues, stored as copies. */
-    issues: PatchLintIssue[];
-    /** Issues suppressed by `lintIgnore`, stored as copies. */
-    suppressed: PatchLintIssue[];
-    /** Line count the run measured. */
-    lineCount: number;
-    /** Suppression ids in force for the run, normalized on store. */
-    lintIgnore?: Iterable<string> | undefined;
-}
-/** Stores the per-patch lint payload after a successful lint calculation. */
-export declare function setCachedPerPatchLintIssues(input: SetCachedPerPatchLintIssuesInput): void;

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

@@ -1,247 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { readFile } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
-import { pathExists, readJson, writeJson } from '../utils/fs.js';
-import { sha256Hex } from '../utils/hash.js';
-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';
-import { checkJsWorldDigest, isCheckJsCacheRelevant } from './patch-lint-cache-checkjs.js';
-// Schema 2: 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. A cache hit must never surface
-// less than a fresh lint.
-// Schema 3: the key additionally content-hashes the
-// `patchLint.checkJsTestShim` file exactly as `checkJsExtraShim`'s already
-// was. Without it, editing the test shim in place replays every cached
-// verdict.
-// Schema 4: each entry records the lint-ignore waiver set that produced it,
-// and a lookup whose effective waiver set differs is refused even when the
-// key matches. The key already hashes `patch.lintIgnore`, so this is
-// belt-and-braces on purpose: a waiver change is the one mutation that makes
-// a replayed verdict actively wrong (an operator writes a waiver, re-runs,
-// and is shown the finding they just waived), and the class must not depend
-// on every future key input staying complete. Bumping the schema also
-// discards every pre-4 entry, which is itself the cure for a cache that
-// already holds a mismatched verdict.
-// Schema 5: a patch with a checkJs-relevant file additionally keys on the
-// checkJs world its programs read (see patch-lint-cache-checkjs.ts): the
-// queue order, the content of other patches' modules, test heads and
-// `paths` targets, and the TypeScript version.
-export const LINT_CACHE_SCHEMA_VERSION = 5;
-const LINT_IMPLEMENTATION_VERSION = 1;
-const LINT_CACHE_DIRNAME = 'lint-cache';
-const PER_PATCH_CACHE_FILENAME = 'per-patch-v1.json';
-function stableJson(value) {
-    if (value === null || typeof value !== 'object') {
-        return JSON.stringify(value);
-    }
-    if (Array.isArray(value)) {
-        return `[${value.map((item) => stableJson(item)).join(',')}]`;
-    }
-    const entries = Object.entries(value)
-        .filter(([, item]) => item !== undefined)
-        .sort(([a], [b]) => a.localeCompare(b));
-    return `{${entries
-        .map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`)
-        .join(',')}}`;
-}
-/** Computes a stable SHA-256 digest for JSON-compatible data. */
-function stableHash(value) {
-    return sha256Hex(stableJson(value));
-}
-/** Returns the repo-local per-patch lint cache file path. */
-function getPerPatchLintCachePath(projectRoot) {
-    return join(projectRoot, '.fireforge', LINT_CACHE_DIRNAME, PER_PATCH_CACHE_FILENAME);
-}
-/** Returns the engine git HEAD identity used to guard diff-derived cache hits. */
-export async function getPerPatchLintCacheHeadSha(engineDir) {
-    return (await git(['rev-parse', 'HEAD'], engineDir)).trim();
-}
-async function fileHash(path) {
-    if (!(await pathExists(path))) {
-        return { exists: false };
-    }
-    return { exists: true, sha256: sha256Hex(await readFile(path)) };
-}
-function normalizePatchMetadata(patch) {
-    return {
-        filesAffected: patch.filesAffected,
-        lintIgnore: patch.lintIgnore,
-        stagedDependencies: patch.stagedDependencies,
-        tier: patch.tier,
-    };
-}
-function normalizeLintConfig(config) {
-    return {
-        binaryName: config.binaryName,
-        license: config.license,
-        patchLint: config.patchLint,
-    };
-}
-function isOwnershipRelevantFile(file) {
-    return file.endsWith('.js') || file.endsWith('.mjs') || file.endsWith('.jsm');
-}
-function buildOwnershipFingerprint(files, ctx) {
-    const creators = collectNewFileCreatorsByPath(ctx);
-    const entries = {};
-    const relevantFiles = [...files]
-        .filter(isOwnershipRelevantFile)
-        .sort((a, b) => a.localeCompare(b));
-    for (const file of relevantFiles) {
-        entries[file] = [...(creators.get(file) ?? [])].sort((a, b) => a.localeCompare(b));
-    }
-    return entries;
-}
-/**
- * Builds the complete per-patch lint cache key for one lintable patch.
- * The key includes source, metadata, config, engine state, and ownership
- * inputs, plus the checkJs world when the patch has a checkJs-relevant file.
- */
-export async function buildPerPatchLintCacheKey(input) {
-    // Hash in parallel, then insert in sorted order. The sort is load-bearing:
-    // `stableHash` below serialises this record, so insertion order is part of
-    // the cache key, and assigning as results land would make the key
-    // nondeterministic.
-    const sortedFiles = [...input.existingFiles].sort((a, b) => a.localeCompare(b));
-    const hashes = await Promise.all(sortedFiles.map((file) => fileHash(join(input.engineDir, file))));
-    const engineFiles = {};
-    hashes.forEach((hash, index) => {
-        const file = sortedFiles[index];
-        if (file !== undefined)
-            engineFiles[file] = hash;
-    });
-    const furnaceConfigPath = getFurnacePaths(input.projectRoot).furnaceConfig;
-    const shimHashOf = async (shimPath) => shimPath === undefined
-        ? null
-        : { path: shimPath, hash: await fileHash(resolve(input.projectRoot, shimPath)) };
-    // Both shims feed compiled checkJs programs, so both are content-hashed.
-    // The config block alone only carries their paths, and an in-place edit
-    // must invalidate the programs it feeds.
-    const [extraShim, testShim] = await Promise.all([
-        shimHashOf(input.config.patchLint?.checkJsExtraShim),
-        shimHashOf(input.config.patchLint?.checkJsTestShim),
-    ]);
-    // Only a patch that can carry a checkJs verdict pays for (and is
-    // invalidated by) the world its programs read.
-    const patchLint = input.config.patchLint;
-    const checkJsWorld = patchLint?.checkJs === true &&
-        input.existingFiles.some((file) => isCheckJsCacheRelevant(file, patchLint))
-        ? await checkJsWorldDigest(input.engineDir, patchLint, input.queueContext)
-        : null;
-    return stableHash({
-        cacheSchemaVersion: LINT_CACHE_SCHEMA_VERSION,
-        engineHeadSha: input.engineHeadSha ?? null,
-        lintImplementationVersion: LINT_IMPLEMENTATION_VERSION,
-        // The plain semver, not the +g<sha> build identity: that identity
-        // churns every commit at the same version and would invalidate the
-        // cache for no correctness gain.
-        packageVersion: input.packageVersion ?? getPackageVersion(),
-        patchFile: await fileHash(join(input.patchesDir, input.patch.filename)),
-        patchMetadata: normalizePatchMetadata(input.patch),
-        lintConfig: normalizeLintConfig(input.config),
-        furnaceConfig: await fileHash(furnaceConfigPath),
-        checkJsExtraShim: extraShim,
-        checkJsTestShim: testShim,
-        engineFiles,
-        queueOwnership: buildOwnershipFingerprint(input.existingFiles, input.queueContext),
-        checkJsWorld,
-    });
-}
-/** Creates an empty cache document using the current cache schema. */
-function createEmptyPerPatchLintCache() {
-    return { schemaVersion: LINT_CACHE_SCHEMA_VERSION, entries: {} };
-}
-function isCacheEntry(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        return false;
-    const entry = value;
-    return (typeof entry.key === 'string' &&
-        typeof entry.patchFilename === 'string' &&
-        Array.isArray(entry.issues) &&
-        Array.isArray(entry.suppressed) &&
-        typeof entry.lineCount === 'number' &&
-        Array.isArray(entry.lintIgnore) &&
-        entry.lintIgnore.every((id) => typeof id === 'string') &&
-        typeof entry.updatedAt === 'string');
-}
-/** Loads the per-patch lint cache, treating missing or invalid files as empty. */
-export async function loadPerPatchLintCache(projectRoot) {
-    const cachePath = getPerPatchLintCachePath(projectRoot);
-    if (!(await pathExists(cachePath))) {
-        return createEmptyPerPatchLintCache();
-    }
-    try {
-        const raw = await readJson(cachePath);
-        if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
-            return createEmptyPerPatchLintCache();
-        }
-        const candidate = raw;
-        if (candidate.schemaVersion !== LINT_CACHE_SCHEMA_VERSION || !candidate.entries) {
-            return createEmptyPerPatchLintCache();
-        }
-        const entries = {};
-        for (const [filename, entry] of Object.entries(candidate.entries)) {
-            if (isCacheEntry(entry)) {
-                entries[filename] = entry;
-            }
-        }
-        return { schemaVersion: LINT_CACHE_SCHEMA_VERSION, entries };
-    }
-    catch {
-        // Any unreadable or malformed cache file is treated as a cold cache. The
-        // cache is a pure optimisation, so discarding it is always safe. The
-        // alternative is failing lint over a corrupt sidecar.
-        return createEmptyPerPatchLintCache();
-    }
-}
-/** Persists the per-patch lint cache atomically through the shared JSON writer. */
-export async function savePerPatchLintCache(projectRoot, cache) {
-    await writeJson(getPerPatchLintCachePath(projectRoot), {
-        schemaVersion: LINT_CACHE_SCHEMA_VERSION,
-        entries: cache.entries,
-    });
-}
-/** Clears the per-patch lint cache by replacing it with an empty document. */
-export async function clearPerPatchLintCache(projectRoot) {
-    await writeJson(getPerPatchLintCachePath(projectRoot), createEmptyPerPatchLintCache());
-}
-/** Canonical (sorted, de-duplicated) form of a waiver set for comparison. */
-function normalizeLintIgnoreSet(lintIgnore) {
-    return [...new Set(lintIgnore ?? [])].sort((a, b) => a.localeCompare(b));
-}
-/**
- * Returns the cached lint payload for a patch when the stored key still
- * matches and the entry was computed under the same lint-ignore waiver set.
- * A waiver change makes a replayed verdict actively wrong, so the waiver set
- * is compared explicitly rather than trusted to the key.
- */
-export function getCachedPerPatchLintIssues(cache, patchFilename, key, lintIgnore) {
-    const entry = cache.entries[patchFilename];
-    if (!entry || entry.key !== key)
-        return undefined;
-    const expected = normalizeLintIgnoreSet(lintIgnore);
-    const stored = normalizeLintIgnoreSet(entry.lintIgnore);
-    if (expected.length !== stored.length || expected.some((id, i) => id !== stored[i])) {
-        return undefined;
-    }
-    return {
-        issues: entry.issues.map((issue) => ({ ...issue })),
-        suppressed: entry.suppressed.map((issue) => ({ ...issue })),
-        lineCount: entry.lineCount,
-    };
-}
-/** Stores the per-patch lint payload after a successful lint calculation. */
-export function setCachedPerPatchLintIssues(input) {
-    const { cache, patchFilename, key, issues, suppressed, lineCount, lintIgnore } = input;
-    cache.entries[patchFilename] = {
-        key,
-        patchFilename,
-        issues: issues.map((issue) => ({ ...issue })),
-        suppressed: suppressed.map((issue) => ({ ...issue })),
-        lineCount,
-        lintIgnore: normalizeLintIgnoreSet(lintIgnore),
-        updatedAt: new Date().toISOString(),
-    };
-}

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

@@ -1,57 +0,0 @@
-/**
- * Explains an implicit-`any` checkJs finding that comes from a URL import
- * the per-patch program cannot resolve.
- *
- * The program resolves URL imports only to modules the queue creates (for
- * a test, those created up to its own patch, plus its directory's
- * head.js), so a `resource:///` or `chrome://` import of a module a later
- * patch creates, an upstream module, or a basename two patches create
- * falls back to the shim's `declare module 'resource:*'` wildcard and
- * types as `any`. A callback
- * over its values then has implicitly-`any` parameters under
- * `checkJsStrict`, while the whole-tree `fireforge typecheck`, which sees
- * the module, is clean. Without the note the two disagree with no
- * explanation. A type-member reference through such an import (TS2694 on
- * the wildcard) is dropped instead, so it types as `any` like the whole
- * module. Split out of patch-lint-checkjs.ts for the line budget.
- */
-/** Unresolved URL import specifiers, keyed by the importing file's TS path. */
-export type AnyTypedImports = Map<string, Set<string>>;
-/**
- * True for a type-member reference (`import("…").Type`,
- * `typeof import("…").member`) through an import this program could not
- * resolve. The reference lands on the shim's shorthand `resource:*` /
- * `chrome:*` wildcard (or a consumer's shorthand module of that name),
- * which has no members, so TypeScript reports TS2694 and types the
- * reference as `any`. The finding is dropped: the reference types as `any`
- * here, exactly as a whole-module `typeof import("…")` of the same module
- * does, and the whole-tree `fireforge typecheck` checks it against the
- * real module.
- *
- * @param code - Diagnostic code
- * @param message - Flattened diagnostic message
- * @param specifiers - The file's unresolved URL imports
- */
-export declare function isAnyTypedMemberReference(code: number, message: string, specifiers: ReadonlySet<string> | undefined): boolean;
-/**
- * The note an implicit-`any` finding carries when its file imports a
- * `resource://`/`chrome://` module this checkJs program could not resolve.
- * Such an import types as `any` (the shim's wildcard module), so a
- * callback over its values has implicitly-`any` parameters here while the
- * whole-tree `fireforge typecheck`, which sees the module, is clean.
- */
-export declare function anyTypedImportHint(code: number, specifiers: ReadonlySet<string> | undefined): string;
-/**
- * The host's `resolveModuleNameLiterals`: owned specifiers first, then a
- * reviewed `paths` mapping, recording every URL import that resolves to
- * neither.
- *
- * @param resolveOwned - Patch-owned specifier resolver
- * @param resolveViaPaths - Optional `paths` resolver
- * @param into - Map that collects the unresolved URL imports
- */
-export declare function createModuleLiteralResolver<Resolved>(resolveOwned: (specifier: string) => Resolved | undefined, resolveViaPaths: ((specifier: string) => Resolved | undefined) | undefined, into: AnyTypedImports): (moduleLiterals: readonly {
-    text: string;
-}[], containingFile: string) => Array<{
-    resolvedModule: Resolved | undefined;
-}>;