@hominis/fireforge 0.54.0 → 0.60.0

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

@@ -1,78 +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 = 4;
-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.
- */
-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,233 +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';
-// 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.
-export const LINT_CACHE_SCHEMA_VERSION = 4;
-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.
- */
-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),
-    ]);
-    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),
-    });
-}
-/** 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,39 +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. 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>>;
-/**
- * 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;
-}>;

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

@@ -1,63 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * 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. Split out of patch-lint-checkjs.ts for the line budget.
- */
-/** TypeScript's implicit-`any` diagnostic codes (noImplicitAny). */
-const IMPLICIT_ANY_CODES = new Set([
-    7005, 7006, 7008, 7010, 7011, 7019, 7031, 7034,
-]);
-function recordAnyTypedImport(into, containingFile, specifier) {
-    if (!/^(?:resource|chrome):/.test(specifier))
-        return;
-    const list = into.get(containingFile) ?? new Set();
-    list.add(specifier);
-    into.set(containingFile, list);
-}
-/**
- * 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 function anyTypedImportHint(code, specifiers) {
-    if (!IMPLICIT_ANY_CODES.has(code) || specifiers === undefined || specifiers.size === 0)
-        return '';
-    const list = [...specifiers].sort().join(', ');
-    return (` (This file imports ${list}, which this per-patch checkJs program cannot resolve — ` +
-        'no patch up to this one creates the module under that name: a later patch creates it, ' +
-        'it is upstream, or two patches create the same basename — so the import is typed `any`. ' +
-        'Annotate the parameter explicitly; the whole-tree "fireforge typecheck" resolves the real type.)');
-}
-/**
- * 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 function createModuleLiteralResolver(resolveOwned, resolveViaPaths, into) {
-    return (moduleLiterals, containingFile) => moduleLiterals.map((literal) => {
-        const owned = resolveOwned(literal.text);
-        if (owned)
-            return { resolvedModule: owned };
-        const viaPaths = resolveViaPaths?.(literal.text);
-        if (viaPaths === undefined)
-            recordAnyTypedImport(into, containingFile, literal.text);
-        return { resolvedModule: viaPaths };
-    });
-}

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

@@ -1,18 +0,0 @@
-/**
- * Parsed `SourceFile`s reused across programs, keyed by file name and the
- * parse options TypeScript asked for. The language service shares files
- * across programs the same way (its document registry): a `SourceFile` is
- * parsed and bound once, and every program that includes it reuses both.
- * Only valid while the files cannot change and every program uses the same
- * compiler options, which holds within one lint run.
- */
-export type CheckJsSourceFileCache = Map<string, import('typescript').SourceFile>;
-/**
- * Returns `host` with a shared-parse `getSourceFile` when a cache is given,
- * or `host` itself when not.
- * @param host - The program's compiler host
- * @param cache - Shared parse cache, or undefined for an unshared program
- * @param shimPath - Path the host serves the composed shim at
- * @param shimSource - The composed shim text
- */
-export declare function withSharedSourceFiles(host: import('typescript').CompilerHost, cache: CheckJsSourceFileCache | undefined, shimPath: string, shimSource: string): import('typescript').CompilerHost;

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

@@ -1,45 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Parsed-source sharing across checkJs programs.
- *
- * Its own module rather than part of `patch-lint-checkjs.ts` only because
- * that file sits on a 500-line budget.
- */
-import { sha256Hex } from '../utils/hash.js';
-/**
- * Wraps a host's `getSourceFile` so each file is parsed at most once per
- * cache. The shim is keyed by its content as well, since the shim text is
- * composed per call rather than read from disk.
- */
-function cachingGetSourceFile(cache, shimPath, shimSource, getSourceFile) {
-    const shimDigest = sha256Hex(shimSource);
-    return (fileName, languageVersionOrOptions, onError, shouldCreate) => {
-        const parse = typeof languageVersionOrOptions === 'object'
-            ? `${languageVersionOrOptions.languageVersion}|${String(languageVersionOrOptions.impliedNodeFormat)}`
-            : String(languageVersionOrOptions);
-        const key = fileName === shimPath ? `${fileName}\0${parse}\0${shimDigest}` : `${fileName}\0${parse}`;
-        const cached = cache.get(key);
-        if (cached !== undefined)
-            return cached;
-        const created = getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreate);
-        if (created !== undefined)
-            cache.set(key, created);
-        return created;
-    };
-}
-/**
- * Returns `host` with a shared-parse `getSourceFile` when a cache is given,
- * or `host` itself when not.
- * @param host - The program's compiler host
- * @param cache - Shared parse cache, or undefined for an unshared program
- * @param shimPath - Path the host serves the composed shim at
- * @param shimSource - The composed shim text
- */
-export function withSharedSourceFiles(host, cache, shimPath, shimSource) {
-    if (cache === undefined)
-        return host;
-    return {
-        ...host,
-        getSourceFile: cachingGetSourceFile(cache, shimPath, shimSource, host.getSourceFile.bind(host)),
-    };
-}

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

@@ -1,17 +0,0 @@
-/**
- * Collects a checkJs program's diagnostics, for every file or for a report
- * scope only. A per-test program resolves the modules its imports reach
- * (see `runCheckJsTestFilesGrouped`), and asking for the whole program's
- * diagnostics would type-check each of those modules once per test, so a
- * scoped run asks only for the files it reports. Split out of
- * patch-lint-checkjs.ts for the line budget.
- */
-/**
- * The program's semantic and syntactic diagnostics, limited to the files
- * `reportOnly` names when it is set.
- *
- * @param program - The built program
- * @param relByAbsolute - Owned files: TS path → repo-relative path
- * @param reportOnly - Repo-relative files to collect for, or all when unset
- */
-export declare function collectCheckJsDiagnostics(program: import('typescript').Program, relByAbsolute: ReadonlyMap<string, string>, reportOnly: ReadonlySet<string> | undefined): import('typescript').Diagnostic[];

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

@@ -1,32 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Collects a checkJs program's diagnostics, for every file or for a report
- * scope only. A per-test program resolves the modules its imports reach
- * (see `runCheckJsTestFilesGrouped`), and asking for the whole program's
- * diagnostics would type-check each of those modules once per test, so a
- * scoped run asks only for the files it reports. Split out of
- * patch-lint-checkjs.ts for the line budget.
- */
-/**
- * The program's semantic and syntactic diagnostics, limited to the files
- * `reportOnly` names when it is set.
- *
- * @param program - The built program
- * @param relByAbsolute - Owned files: TS path → repo-relative path
- * @param reportOnly - Repo-relative files to collect for, or all when unset
- */
-export function collectCheckJsDiagnostics(program, relByAbsolute, reportOnly) {
-    if (reportOnly === undefined) {
-        return [...program.getSemanticDiagnostics(), ...program.getSyntacticDiagnostics()];
-    }
-    return program
-        .getSourceFiles()
-        .filter((sourceFile) => {
-        const rel = relByAbsolute.get(sourceFile.fileName);
-        return rel !== undefined && reportOnly.has(rel);
-    })
-        .flatMap((sourceFile) => [
-        ...program.getSemanticDiagnostics(sourceFile),
-        ...program.getSyntacticDiagnostics(sourceFile),
-    ]);
-}