@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,91 +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. 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.
- */
-/** TypeScript's implicit-`any` diagnostic codes (noImplicitAny). */
-const IMPLICIT_ANY_CODES = new Set([
-    7005, 7006, 7008, 7010, 7011, 7019, 7031, 7034,
-]);
-/** TS2694, "Namespace '…' has no exported member '…'". */
-const NO_EXPORTED_MEMBER_CODE = 2694;
-const NO_EXPORTED_MEMBER = /^Namespace '"([^"]*)"' has no exported member /;
-/**
- * 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 function isAnyTypedMemberReference(code, message, specifiers) {
-    if (code !== NO_EXPORTED_MEMBER_CODE)
-        return false;
-    const namespace = NO_EXPORTED_MEMBER.exec(message)?.[1];
-    if (namespace === undefined)
-        return false;
-    return (namespace === 'resource:*' || namespace === 'chrome:*' || specifiers?.has(namespace) === true);
-}
-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),
-    ]);
-}

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

@@ -1,31 +0,0 @@
-/**
- * How a per-patch checkJs program resolves a URL import, as pure functions
- * shared by the compiler host in `patch-lint-checkjs.ts` and by
- * `typecheck --explain`, which reports the same resolution without
- * building a program.
- */
-/**
- * Builds the owned-module matcher: a specifier resolves to the owned file
- * whose basename uniquely equals the specifier's final segment. URL
- * specifiers (chrome://browser/content/Foo.sys.mjs,
- * resource:///modules/Foo.sys.mjs) are matched by basename, with a
- * `.mjs` → `.sys.mjs` fallback for deployed widget URLs. Ambiguous or
- * unknown basenames stay unresolved (loose wildcard typing beats guessing
- * the wrong module), and relative specifiers are left to fail resolution
- * (the relative-import lint rule bans them).
- *
- * @param owned - The program's resolvable files, in any path form
- * @returns The matching owned path, or undefined
- */
-export declare function createOwnedPathMatcher(owned: Iterable<string>): (specifier: string) => string | undefined;
-/**
- * The targets a reviewed `paths` mapping offers for `specifier`, in the
- * order they are tried: patterns in declaration order, each pattern's
- * targets in order. A pattern may contain a single `*`, and the captured
- * text replaces the one `*` of a target.
- *
- * @param paths - `checkJsCompilerOptions.paths`
- * @param specifier - The import specifier
- * @returns Engine-relative candidate paths; the first that exists wins
- */
-export declare function pathsTargetCandidates(paths: Record<string, string[]>, specifier: string): string[];

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

@@ -1,86 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * How a per-patch checkJs program resolves a URL import, as pure functions
- * shared by the compiler host in `patch-lint-checkjs.ts` and by
- * `typecheck --explain`, which reports the same resolution without
- * building a program.
- */
-import { basename } from 'node:path';
-/**
- * Builds the owned-module matcher: a specifier resolves to the owned file
- * whose basename uniquely equals the specifier's final segment. URL
- * specifiers (chrome://browser/content/Foo.sys.mjs,
- * resource:///modules/Foo.sys.mjs) are matched by basename, with a
- * `.mjs` → `.sys.mjs` fallback for deployed widget URLs. Ambiguous or
- * unknown basenames stay unresolved (loose wildcard typing beats guessing
- * the wrong module), and relative specifiers are left to fail resolution
- * (the relative-import lint rule bans them).
- *
- * @param owned - The program's resolvable files, in any path form
- * @returns The matching owned path, or undefined
- */
-export function createOwnedPathMatcher(owned) {
-    const ownedByBasename = new Map();
-    for (const file of owned) {
-        const base = basename(file);
-        const list = ownedByBasename.get(base) ?? [];
-        list.push(file);
-        ownedByBasename.set(base, list);
-    }
-    return (specifier) => {
-        if (specifier.startsWith('.'))
-            return undefined;
-        const cleaned = specifier.split(/[?#]/)[0] ?? specifier;
-        const segment = cleaned.slice(cleaned.lastIndexOf('/') + 1);
-        if (!segment)
-            return undefined;
-        const candidates = [...(ownedByBasename.get(segment) ?? [])];
-        if (segment.endsWith('.mjs') && !segment.endsWith('.sys.mjs')) {
-            candidates.push(...(ownedByBasename.get(segment.replace(/\.mjs$/, '.sys.mjs')) ?? []));
-        }
-        return candidates.length === 1 ? candidates[0] : undefined;
-    };
-}
-/**
- * The targets a reviewed `paths` mapping offers for `specifier`, in the
- * order they are tried: patterns in declaration order, each pattern's
- * targets in order. A pattern may contain a single `*`, and the captured
- * text replaces the one `*` of a target.
- *
- * @param paths - `checkJsCompilerOptions.paths`
- * @param specifier - The import specifier
- * @returns Engine-relative candidate paths; the first that exists wins
- */
-export function pathsTargetCandidates(paths, specifier) {
-    const candidates = [];
-    for (const [pattern, targets] of Object.entries(paths)) {
-        const star = pattern.indexOf('*');
-        let captured;
-        if (star === -1) {
-            if (specifier !== pattern)
-                continue;
-            captured = '';
-        }
-        else {
-            const prefix = pattern.slice(0, star);
-            const suffix = pattern.slice(star + 1);
-            if (specifier.length < prefix.length + suffix.length)
-                continue;
-            if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix))
-                continue;
-            captured = specifier.slice(prefix.length, specifier.length - suffix.length);
-        }
-        for (const target of targets) {
-            // A `paths` target carries at most one `*`, and TypeScript substitutes
-            // that one wildcard. It is spelled as index arithmetic (mirroring the
-            // prefix/suffix split on the pattern side above) rather than
-            // `replace('*', …)`, whose first-occurrence-only behaviour reads as an
-            // incomplete rewrite (CodeQL `js/incomplete-sanitization`).
-            const targetStar = target.indexOf('*');
-            candidates.push(targetStar === -1
-                ? target
-                : target.slice(0, targetStar) + captured + target.slice(targetStar + 1));
-        }
-    }
-    return candidates;
-}

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

@@ -1,182 +0,0 @@
-/**
- * Optional TypeScript `checkJs` pass for patch-owned `.sys.mjs` files.
- *
- * Loads the TypeScript compiler API via dynamic import so it is only
- * required when `patchLint.checkJs` is enabled in `fireforge.json`.
- * TypeScript remains a dev-dependency. If a user enables checkJs
- * without installing it, the pass emits a clear error explaining
- * how to fix it.
- *
- * Separated from `patch-lint.ts` to keep both files within the
- * project's per-file line budget. The shim itself and the suppressed
- * diagnostic code list live in `typecheck-shim.ts` and are shared
- * with the whole-project `fireforge typecheck` command, keeping a
- * single source of truth for the Firefox-globals coverage.
- * `patchLint.checkJsStrict` only tightens `strict` / `noImplicitAny`
- * and optional allowlisted `checkJsCompilerOptions`. It does not change
- * shim composition or suppressed diagnostic codes.
- *
- * Resolution scope vs reporting scope: the TS program is built over a
- * *resolution* set (every patch-owned `.sys.mjs` the run cares about, so
- * cross-patch `resource:///` imports resolve to their real sources), while
- * diagnostics are emitted only for files in the *report* scope. Splitting
- * the two lets per-patch lint build one queue-wide program and attribute
- * findings per patch, and lets export/re-export resolve cross-patch imports
- * while reporting only the patch under export.
- */
-import type { PatchLintIssue } from '../types/commands/index.js';
-import type { PatchLintCheckJsCompilerOptions, PatchLintConfig, PatchLintSeverityGate } from '../types/config.js';
-import { type CheckJsSourceFileCache } from './patch-lint-checkjs-cache.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`.
-     */
-    undefinedIdentifiers?: PatchLintSeverityGate;
-    /** Types Lit in the shim. See `patchLint.litTypes`. */
-    litTypes?: boolean;
-}
-/**
- * Result of {@link runCheckJsGrouped}: diagnostics attributed to the
- * patch-owned file they originate in (`byFile`, keyed by repo-relative
- * path), plus run-level errors that have no owning file (`global`, e.g.
- * TypeScript missing or an unreadable extra shim).
- */
-export interface GroupedCheckJsResult {
-    byFile: Map<string, PatchLintIssue[]>;
-    global: PatchLintIssue[];
-}
-/** Inputs for {@link runCheckJsGrouped}. */
-export interface RunCheckJsGroupedInput {
-    /** Absolute engine (repository) directory. */
-    repoDir: string;
-    /**
-     * Patch-owned `.sys.mjs` paths (relative to `repoDir`) the program should
-     * see and resolve against.
-     */
-    resolutionOwned: Set<string>;
-    /**
-     * Optional project-relative extra `.d.ts` appended to the built-in
-     * Firefox-globals shim (from `patchLint.checkJsExtraShim`).
-     */
-    extraShimPath?: string;
-    /** Absolute project root for resolving `extraShimPath`. */
-    projectRoot?: string;
-    /** Strictness preset plus allowlisted compiler-option overrides. */
-    mode?: CheckJsMode;
-    /** Optional shim text appended after the consumer shim. */
-    builtinShimSuffix?: string;
-    /**
-     * When set, only these repo-relative files become program roots.
-     * Resolution (and the host allowlist) still spans all of
-     * `resolutionOwned`, so a subset root's cross-patch imports type-check
-     * against the real owning sources while unrelated owned files are never
-     * parsed. `.mjs` files are module-scoped, so a root's diagnostics are
-     * identical whether other owned files are roots or mere resolution
-     * targets.
-     */
-    rootScope?: ReadonlySet<string>;
-    /**
-     * Parsed source files shared across several programs built with the same
-     * compiler options and shim in one run. See {@link runCheckJsTestFilesGrouped}.
-     */
-    sourceFileCache?: CheckJsSourceFileCache;
-    /** When set, diagnostics are collected only for these repo-relative files. */
-    reportOnly?: ReadonlySet<string>;
-}
-/**
- * Builds the checkJs program once over `resolutionOwned` and returns its
- * diagnostics grouped by originating file. Callers slice the result by their
- * own report scope: per-patch lint attributes each file to its owning patch,
- * export/re-export keeps only the patch under export. Resolution always spans
- * every file in `resolutionOwned`, so cross-patch `resource:///`/`chrome://`
- * imports resolve to real sources.
- *
- * @param input - Program inputs. See {@link RunCheckJsGroupedInput}
- * @returns Diagnostics grouped per owning file plus run-level errors
- */
-export declare function runCheckJsGrouped(input: RunCheckJsGroupedInput): Promise<GroupedCheckJsResult>;
-/**
- * Flattens a {@link runCheckJsGrouped} run into a single issue list. When
- * `reportScope` is supplied, only diagnostics from files in that set are
- * returned (resolution still spans every owned file). Omitting it reports
- * every owned file's diagnostics, the historical whole-set behaviour.
- *
- * @param repoDir - Absolute engine (repository) directory
- * @param patchOwnedFiles - Patch-owned `.sys.mjs` paths to resolve against
- * @param extraShimPath - Optional project-relative extra `.d.ts`
- * @param projectRoot - Absolute project root for resolving `extraShimPath`
- * @param mode - Strictness preset plus allowlisted compiler-option overrides
- * @param reportScope - When set, restrict reported diagnostics to these
- *   repo-relative files
- * @returns Array of lint issues from TS diagnostics
- */
-export declare function runCheckJs(repoDir: string, patchOwnedFiles: Set<string>, extraShimPath?: string, projectRoot?: string, mode?: CheckJsMode, reportScope?: ReadonlySet<string>): Promise<PatchLintIssue[]>;
-/**
- * Invokes {@link runCheckJs} for a `patchLint` block with `checkJs: true`.
- * `projectRoot` is the FireForge project root (`dirname(engine)`).
- *
- * @param repoDir - Absolute engine (repository) directory
- * @param patchOwnedFiles - Patch-owned `.sys.mjs` paths to resolve against
- * @param patchLint - The resolved `patchLint` config block
- * @param projectRoot - FireForge project root for shim resolution
- * @param reportScope - Optional repo-relative files to report on (export /
- *   re-export passes the patch under export so cross-patch resolution does
- *   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 (
- * `patchLint.checkJsTestFiles`). Each test file gets its own small
- * program, 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`.
- * 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. 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.
- *
- * With `resolvableModules`, a test's `resource:///` and `chrome://`
- * imports also resolve to the modules it returns for that test (the
- * modules the queue creates up to the test's own patch), so a test that
- * imports an earlier patch's module is typed against its real source
- * instead of the shim's `any` wildcard. Those modules are resolution
- * targets only: never roots, and never reported on.
- *
- * @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, rootScope?: ReadonlySet<string>, resolvableModules?: (testFile: string) => ReadonlySet<string>): Promise<GroupedCheckJsResult>;
-/**
- * Grouped variant of {@link invokePatchLintCheckJs}: builds one queue-wide
- * checkJs program over `patchOwnedFiles` and returns its findings grouped by
- * owning file. The per-patch lint orchestrator calls this once per run
- * and attributes each file's findings to its owning patch, instead of
- * rebuilding the same program for every patch in the queue.
- *
- * @param repoDir - Absolute engine (repository) directory
- * @param patchOwnedFiles - Every patch-owned `.sys.mjs` in the queue
- * @param patchLint - The resolved `patchLint` config block
- * @param projectRoot - FireForge project root for shim resolution
- * @param rootScope - Optional subset of files to use as program roots
- * (`--patches`). Resolution still spans the whole queue
- */
-export declare function invokePatchLintCheckJsGrouped(repoDir: string, patchOwnedFiles: Set<string>, patchLint: PatchLintConfig, projectRoot: string, rootScope?: ReadonlySet<string>): Promise<GroupedCheckJsResult>;
-/**
- * Cheap probe reproducing the only run-level ("global") checkJs findings the
- * build path can produce: a missing `typescript` package and an unreadable
- * consumer shim (`checkJsExtraShim`, and `checkJsTestShim` when
- * `checkJsTestFiles` is on). The built program itself never contributes
- * globals (see {@link runCheckJsGrouped}), so a warm all-cache-hit run can
- * satisfy the "warm never reports less than cold" invariant with this probe
- * instead of building the whole TypeScript program. Issue objects are
- * byte-identical to the build path's, deduplicated by message like
- * {@link runCheckJsTestFilesGrouped}.
- */
-export declare function probeCheckJsGlobalIssues(patchLint: PatchLintConfig, projectRoot: string): Promise<PatchLintIssue[]>;