@valbuild/shared 0.148.6 → 0.149.7

package/dist/declarations/src/typecheck/acquireTypes.d.ts

@@ -0,0 +1,109 @@
+import { LinkedFileSystem } from "./linkedFileSystem.js";
+import type { LayoutPackage, PnpmLayout } from "./pnpmLayout.js";
+import type { CompilerBundle, TypeScript } from "./typescriptCompiler.js";
+/**
+ * adept's `/types/<partition>/<name>@<version>`: a package version's
+ * declaration files and every `package.json`, by path relative to the
+ * package's root, and the names of its JavaScript files.
+ */
+export type TypesBundle = {
+    files: Record<string, string>;
+    stubs: string[];
+};
+export type PackageRef = {
+    name: string;
+    version: string;
+    integrity: string | null;
+};
+/**
+ * Where bundles and compilers come from. In the Studio that is adept,
+ * through the Studio's server (`adeptSources.ts`); tests and Node scripts
+ * give their own.
+ */
+export type TypecheckSources = {
+    types(pkg: PackageRef): Promise<TypesBundle>;
+    compiler(version: string): Promise<CompilerBundle>;
+};
+/**
+ * A failed request for a bundle or a compiler, by what can be done about it.
+ * `status` 401 means signed out, and stops the whole check: every other
+ * request would fail the same way.
+ */
+export declare class SourceError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    readonly status: number | null;
+    constructor(message: string, code: string, retryable: boolean, status?: number | null);
+}
+/** A package whose types could not be had, so the check that follows is incomplete. */
+export type MissingTypes = PackageRef & {
+    code: string;
+    message: string;
+    retryable: boolean;
+};
+export type AcquisitionStats = {
+    /** Bundles fetched because an import or a type reference named them. */
+    scanned: number;
+    /** Bundles fetched because TypeScript went looking in them while resolving. */
+    resolved: number;
+    files: number;
+    stubs: number;
+    /** Characters of declaration text, about the bytes once unpacked. */
+    bytes: number;
+};
+/**
+ * The package a bare specifier names: `react` of `react/jsx-runtime`,
+ * `@tanstack/react-router` of itself. `null` for anything that is not looked
+ * up in `node_modules`: relative and absolute paths, `#subpath` imports and
+ * `node:` and other schemes.
+ */
+export declare function packageNameOf(specifier: string): string | null;
+/** `@types/node` for `node`, `@types/scope__name` for `@scope/name`. */
+export declare function typesPackageOf(name: string): string;
+/** The package directory a real path is in: up to the name after its last `node_modules`. */
+export declare function packageDirOf(realPath: string): string | null;
+/**
+ * Fetches the types a project's imports reach, and only those, and writes
+ * each bundle at its snapshot's directory in the virtual store, so that the
+ * layout's links make it visible wherever pnpm would.
+ *
+ * {@link wantImportsOf} scans a file's imports and type references; each
+ * bare one is looked for as Node looks for it, from the file's directory up
+ * through each `node_modules` (and its `@types` twin), and the nearest level
+ * that has it is fetched. A fetched bundle's declaration files are scanned in
+ * turn, so type dependencies are followed transitively. {@link wantPackage}
+ * fetches a package by directory, for when TypeScript itself went looking in
+ * one.
+ */
+export declare class TypeAcquisition {
+    private readonly ts;
+    private readonly fs;
+    private readonly layout;
+    private readonly sources;
+    private readonly concurrency;
+    private readonly started;
+    private readonly running;
+    private readonly queue;
+    private fatal;
+    readonly missing: MissingTypes[];
+    readonly stats: AcquisitionStats;
+    constructor(ts: TypeScript, fs: LinkedFileSystem, layout: PnpmLayout, sources: TypecheckSources, concurrency?: number);
+    /** Whether `dir` is a package this has fetched, or tried to. */
+    has(dir: string): boolean;
+    /** The installed package at a real directory, if it is one. */
+    packageAt(dir: string): LayoutPackage | undefined;
+    /**
+     * The packages a bare name reaches from `fromDir`: at the nearest
+     * `node_modules` that has the package or its `@types`, both.
+     */
+    findPackages(fromDir: string, name: string): string[];
+    /** Wants what a bare specifier names, from a file in `fromDir`. */
+    wantSpecifier(fromDir: string, specifier: string): void;
+    /** Wants every package a file's imports and type references reach. */
+    wantImportsOf(realPath: string, text: string): void;
+    wantPackage(dir: string, via: "scanned" | "resolved"): void;
+    private pump;
+    /** Resolves when everything wanted so far, and everything that wanted, is fetched. */
+    settle(): Promise<void>;
+    private fetch;
+}

package/dist/declarations/src/typecheck/adeptSources.d.ts

@@ -0,0 +1,9 @@
+import { type TypecheckSources } from "./acquireTypes.js";
+export declare function adeptSources(options: {
+    base: string;
+    fetch?: typeof fetch;
+    /** A credential to send, where the caller has one to (`Authorization`). */
+    headers?: Record<string, string>;
+    /** Whether cookies go too: `same-origin` (the default) for the Studio's own server. */
+    credentials?: RequestInit["credentials"];
+}): TypecheckSources;

package/dist/declarations/src/typecheck/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The type errors a project would have after `pnpm install`, computed in
+ * memory: the layout from the lockfile, the types its imports reach from
+ * adept, and the project's own TypeScript over both (valbuild/home
+ * `docs/adept.md`, step 4).
+ *
+ * Here rather than in the Studio because two callers run it: the Studio, for
+ * a proposal that changes dependencies, and home's upgrade page, which pins
+ * this package at an exact version so that a site's own Val never reaches
+ * its upgrade (valbuild/home `docs/plans/upgrades-v2.md`, piece E). It runs
+ * anywhere a module runs; each caller puts it in a worker of its own.
+ */
+export { typecheckProject, newErrors, layoutOf, PROJECT_ROOT, type TypecheckInput, type TypecheckProgress, type TypecheckResult, type TypeErrorEntry, type ProgramSummary, } from "./typecheckProject.js";
+export { SourceError, packageNameOf, typesPackageOf, type PackageRef, type TypesBundle, type TypecheckSources, type MissingTypes, type AcquisitionStats, } from "./acquireTypes.js";
+export { adeptSources } from "./adeptSources.js";
+export { lockedPackages, typescriptVersion, type Locked, } from "./lockedVersions.js";
+export { LockfileError } from "./pnpmLockfile.js";
+export { UnsupportedLayoutError } from "./pnpmLayout.js";
+export { BUNDLED_TYPESCRIPT, CompilerError, chooseCompiler, type CompilerBundle, type CompilerChoice, } from "./typescriptCompiler.js";
+export { MAX_REPORTED_ERRORS, errorsByFile, reportedError, runProposalTypecheck, type ProposalTypeError, type ProposalTypecheckClient, type ProposalTypecheckDeps, type ProposalTypecheckOutcome, type ProposalTypecheckStep, } from "./proposalTypecheck.js";

package/dist/declarations/src/typecheck/linkedFileSystem.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Files in memory, with directory symlinks: enough of a disk for
+ * TypeScript's module resolution to see `node_modules` as pnpm leaves it.
+ *
+ * Files are written at their real paths. A link maps a path to the directory
+ * it points at, and every read goes through `realpath` first, so
+ * `/project/node_modules/react/index.d.ts` reads the file written at
+ * `/project/node_modules/.pnpm/react@19.3.0/node_modules/react/index.d.ts`.
+ *
+ * The directory index is what makes resolution work, and it needs two things
+ * a list of files does not give: every directory a file is in (TypeScript
+ * asks `directoryExists` before it looks inside), and every linked directory
+ * -- a link's own name is listed in its parent, and the directory it points
+ * at exists even before anything has been written into it. Without the
+ * first, packages are reported missing; without the second, so are packages
+ * whose files have not been fetched, and `node_modules/@types` cannot be
+ * listed.
+ *
+ * Every lookup of a path is also reported to `onLookup`, with the real path
+ * it resolved to, so that a caller can tell which packages TypeScript went
+ * looking in.
+ */
+export declare class LinkedFileSystem {
+    private readonly files;
+    /** Real directory → the names of its entries, files and directories (links included). */
+    private readonly directories;
+    private readonly links;
+    /** The links never change, so neither does a path's real path. */
+    private readonly realpaths;
+    onLookup: ((realPath: string) => void) | null;
+    constructor(links: Map<string, string>);
+    private entriesOf;
+    /** `dir` and every directory above it. */
+    private addDirectory;
+    /** Lists `path` in its parent; the parent's real path, as `path` may sit under a link. */
+    private addEntry;
+    /** Resolves every link along `path`, as `fs.realpathSync` does. */
+    realpath(path: string): string;
+    private resolveLinks;
+    writeFile(realPath: string, text: string): void;
+    private lookup;
+    readFile(path: string): string | undefined;
+    fileExists(path: string): boolean;
+    directoryExists(path: string): boolean;
+    /** The directories in `path`, links to directories included. */
+    getDirectories(path: string): string[];
+    /** The files in `path`. */
+    getFiles(path: string): string[];
+    /** Every file written, by real path. */
+    allFiles(): IterableIterator<string>;
+}
+export declare function parentOf(path: string): string;
+export declare function baseName(path: string): string;

package/dist/declarations/src/typecheck/lockedVersions.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Read straight from a pnpm lockfile's text, with no YAML parser: what
+ * `/val/adept` lists, and which TypeScript the typecheck loads.
+ * `pnpmLockfile.ts` is the full reader.
+ */
+export type Locked = {
+    name: string;
+    version: string;
+    integrity?: string;
+};
+/** The registry packages a pnpm 9 lockfile's `packages:` section names. */
+export declare function lockedPackages(lockfile: string): Locked[];
+/** The version the root importer's lockfile entry gives `typescript`. */
+export declare function typescriptVersion(lockfile: string): string | null;

package/dist/declarations/src/typecheck/pnpmLayout.d.ts

@@ -0,0 +1,95 @@
+import { type PnpmLockfile } from "./pnpmLockfile.js";
+/**
+ * What `pnpm install --frozen-lockfile` puts in `node_modules`, computed from
+ * the lockfile alone, as a table of symlinks.
+ *
+ * Ported from pnpm's own crates (valbuild/pnpm, pacquet 12.13.0):
+ * `deps-path/src/dep_path_to_filename.rs` names each snapshot's directory in
+ * the virtual store, and `deps-restorer/src/hoist.rs` decides which
+ * transitive dependencies are also linked into the private hoist
+ * (`node_modules/.pnpm/node_modules`). The defaults are pnpm 12's: hoist
+ * `["*"]` privately, nothing publicly, virtual store names at most 120 bytes,
+ * no global virtual store. `pnpmLayout.test.ts` compares the result with
+ * what a real install left on disk.
+ *
+ * Every path is absolute, under `root` (default `/project`), with `/`
+ * separators.
+ */
+export type PnpmLayout = {
+    root: string;
+    /** `<root>/node_modules/.pnpm` */
+    virtualStore: string;
+    /** Every symlink: its own path, to the absolute directory it points at. */
+    links: Map<string, string>;
+    /** Every installed snapshot, by the directory its package's files are in. */
+    packages: Map<string, LayoutPackage>;
+    /** Each importer's directory, by its id (`.` is the root project). */
+    importers: Map<string, string>;
+    /** Snapshots `pnpm install` would skip: optional, and not for this platform. */
+    skipped: Set<string>;
+};
+export type LayoutPackage = {
+    /** The snapshot key: `name@version(peers)`. */
+    snapshot: string;
+    name: string;
+    version: string;
+    /** `null` for a package the lockfile does not give an integrity for (a tarball URL, git). */
+    integrity: string | null;
+    /** Whether it comes from a registry by name and version, so its types can be asked for. */
+    fromRegistry: boolean;
+};
+/** What `pnpm install` checks optional packages' `os`, `cpu` and `libc` against. */
+export type Platform = {
+    os: string;
+    cpu: string;
+    libc: string | null;
+};
+export type LayoutOptions = {
+    root?: string;
+    /** `null` installs every optional package, whatever it is built for. */
+    platform?: Platform | null;
+    hoistPattern?: string[];
+    publicHoistPattern?: string[];
+    virtualStoreDirMaxLength?: number;
+    /**
+     * Each workspace project's `name`, by importer id, from its package.json.
+     * The lockfile does not carry them, and pnpm links every named project
+     * into the hoist as well (`hoist-workspace-packages`).
+     */
+    workspaceNames?: Record<string, string>;
+    /** `hoistWorkspacePackages`, on unless the workspace turns it off. */
+    hoistWorkspacePackages?: boolean;
+};
+/**
+ * Linux on x64 with glibc: what a CI runner and the build are, and so the
+ * install the typecheck is compared with. It only decides which optional,
+ * platform-specific packages exist, which hardly ever carry types.
+ */
+export declare const DEFAULT_PLATFORM: Platform;
+/**
+ * The directory name of a snapshot in the virtual store: pnpm's
+ * `dep_path_to_filename`. `@scope/foo@1.0.0(bar@2.0.0)` is
+ * `@scope+foo@1.0.0_bar@2.0.0`; a name longer than `maxLength` bytes, or with
+ * upper case letters, is cut and given a hash of the whole.
+ */
+export declare function depPathToFilename(depPath: string, maxLength?: number): string;
+/**
+ * pnpm's `WildcardMatcher` lists: `*` is any run of characters, `?` one, a
+ * leading `!` excludes, and a later exclude cancels an earlier include.
+ */
+export declare function createMatcher(patterns: string[]): (input: string) => boolean;
+/** `a/b/../c` → `a/c`, for absolute `/`-separated paths. */
+export declare function normalizePath(path: string): string;
+/** A setting in `pnpm-workspace.yaml` the layout cannot follow. */
+export declare class UnsupportedLayoutError extends Error {
+}
+/**
+ * The settings in `pnpm-workspace.yaml` that change the layout: `hoist`,
+ * `hoistPattern`, `publicHoistPattern`, `shamefullyHoist` and
+ * `virtualStoreDirMaxLength`. pnpm 11 and later read these from there and not
+ * from `.npmrc`. `nodeLinker` other than `isolated` is a different layout
+ * altogether, and refused.
+ */
+export declare function layoutOptionsOfWorkspace(workspace: Record<string, unknown>): LayoutOptions;
+/** What `pnpm install` would put in `node_modules` for this lockfile. */
+export declare function computePnpmLayout(lockfile: PnpmLockfile, options?: LayoutOptions): PnpmLayout;

package/dist/declarations/src/typecheck/pnpmLockfile.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The parts of a `pnpm-lock.yaml` (lockfile version 9) that decide what
+ * `pnpm install` puts in `node_modules`.
+ *
+ * Only what the layout needs is kept: each importer's direct dependencies,
+ * each package's integrity and platform constraints, and each snapshot's own
+ * dependencies. Everything is a plain string as pnpm wrote it -- a reference
+ * such as `19.3.0(react@19.3.0)` is turned into a snapshot key by
+ * {@link snapshotKeyOf}, as pnpm's lockfile crate does.
+ */
+export type PnpmLockfile = {
+    importers: Record<string, ImporterSnapshot>;
+    /** Keyed `<name>@<version>`, without peers. */
+    packages: Record<string, PackageInfo>;
+    /** Keyed `<name>@<version>(<peer>)…`: one per installed copy. */
+    snapshots: Record<string, SnapshotInfo>;
+};
+/** An importer's dependencies, alias to the reference pnpm locked it at. */
+export type ImporterSnapshot = {
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    optionalDependencies: Record<string, string>;
+};
+export type PackageInfo = {
+    integrity: string | null;
+    /** `resolution.tarball`, for a package that is not at its registry's standard place. */
+    tarball: string | null;
+    os: string[] | null;
+    cpu: string[] | null;
+    libc: string[] | null;
+    hasBin: boolean;
+};
+export type SnapshotInfo = {
+    dependencies: Record<string, string>;
+    optionalDependencies: Record<string, string>;
+    optional: boolean;
+};
+/** A lockfile this cannot read: not YAML, or not pnpm's version 9 shape. */
+export declare class LockfileError extends Error {
+}
+/**
+ * Reads a pnpm 9 lockfile. pnpm 11 and later may put a document of their own
+ * (the package manager's dependencies) before the project's, so the document
+ * read is the one that has `importers`.
+ */
+export declare function parsePnpmLockfile(text: string): PnpmLockfile;
+/** `@scope/name` of `@scope/name@1.0.0(peer@2.0.0)`. */
+export declare function nameOfKey(key: string): string;
+/** `1.0.0` of `@scope/name@1.0.0(peer@2.0.0)`: the version, without peers. */
+export declare function versionOfKey(key: string): string;
+/** The `packages:` key a snapshot key's metadata is under: the key without its peers. */
+export declare function packageKeyOf(snapshotKey: string): string;
+/**
+ * The snapshot a dependency reference points at, or `null` for a `link:` to
+ * a directory (a workspace sibling), which is not in the virtual store.
+ */
+export declare function snapshotKeyOf(alias: string, reference: string): string | null;

package/dist/declarations/src/typecheck/proposalTypecheck.d.ts

@@ -0,0 +1,76 @@
+import type { TypecheckProgress, TypecheckResult } from "./typecheckProject.js";
+import { type TypeErrorEntry } from "./typecheckProject.js";
+/** At most this many of the new errors are sent; the count says how many. */
+export declare const MAX_REPORTED_ERRORS = 200;
+/** What the typecheck is doing, as it says so. */
+export type ProposalTypecheckStep = {
+    step: "reading";
+} | {
+    step: "lockfile";
+} | {
+    step: "checking";
+    which: "site" | "proposal";
+    detail: string;
+};
+/** A new type error as content keeps it: a file always, a position always. */
+export type ProposalTypeError = {
+    file: string;
+    line: number;
+    column: number;
+    code: number;
+    message: string;
+};
+/**
+ * The calls a proposal's typecheck makes: the Studio's through its origin,
+ * home's upgrade page to content directly. `T` is the report as content
+ * answers it.
+ */
+export type ProposalTypecheckClient<T> = {
+    files(name: string): Promise<{
+        files: Record<string, string | null>;
+        staged: {
+            inputs: string | null;
+        };
+    }>;
+    reportTypecheck(name: string, report: {
+        inputs: string;
+        newErrors: ProposalTypeError[];
+        count?: number;
+    }): Promise<T>;
+};
+export type ProposalTypecheckDeps<T> = {
+    name: string;
+    client: ProposalTypecheckClient<T>;
+    /** The site's code, as its live build has it; `null` when nothing is live. */
+    siteSource: () => Promise<Record<string, string> | null>;
+    /** The site's recorded `pnpm-lock.yaml` and `pnpm-workspace.yaml`. */
+    siteDependencyFiles: () => Promise<Record<string, string>>;
+    /** A lockfile for `packageJson`, for a site that has none on record. */
+    computeLockfile: (packageJson: string, signal: AbortSignal) => Promise<string>;
+    check: (input: {
+        files: Record<string, string>;
+        lockfile: string;
+        workspace: string | null;
+    }, options: {
+        onProgress: (progress: TypecheckProgress) => void;
+        signal: AbortSignal;
+    }) => Promise<TypecheckResult>;
+    onStep?: (step: ProposalTypecheckStep) => void;
+    signal: AbortSignal;
+};
+export type ProposalTypecheckOutcome<T> = 
+/** Nothing staged: there is nothing of the proposal's to check. */
+{
+    status: "nothing-staged";
+} | {
+    status: "checked";
+    inputs: string;
+    /** Every new error, not only the ones sent. */
+    errors: ProposalTypeError[];
+    typecheck: T;
+};
+/** A type error as content keeps it: a file always, a position always. */
+export declare function reportedError(error: TypeErrorEntry): ProposalTypeError;
+export declare function runProposalTypecheck<T>(deps: ProposalTypecheckDeps<T>): Promise<ProposalTypecheckOutcome<T>>;
+/** New errors by file, each file's in order: how the dialog lists them. */
+export declare function errorsByFile(errors: ProposalTypeError[]): [string, ProposalTypeError[]][];

package/dist/declarations/src/typecheck/testing/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * For tests and scripts, in Node: type bundles cut from an installed
+ * project's own `node_modules`, as adept cuts them from tarballs. Not for a
+ * browser -- it reads the disk.
+ */
+export { nodeModulesSources } from "./nodeModulesSources.js";

package/dist/declarations/src/typecheck/testing/nodeModulesSources.d.ts

@@ -0,0 +1,5 @@
+import { type TypecheckSources } from "../acquireTypes.js";
+export declare function nodeModulesSources(root: string, options?: {
+    anyVersion?: boolean;
+    fallbackRoots?: string[];
+}): TypecheckSources;

package/dist/declarations/src/typecheck/typecheckProject.d.ts

@@ -0,0 +1,89 @@
+import { type AcquisitionStats, type MissingTypes, type TypecheckSources } from "./acquireTypes.js";
+import { type PnpmLayout } from "./pnpmLayout.js";
+import { type PnpmLockfile } from "./pnpmLockfile.js";
+import { type CompilerChoice } from "./typescriptCompiler.js";
+/**
+ * The type errors a project would have after `pnpm install`, computed in
+ * memory: the layout from the lockfile, the types its imports reach from
+ * adept, and the project's own TypeScript over both. See `docs` in
+ * valbuild/home's `adept.md`, step 4.
+ */
+export type TypecheckInput = {
+    /** The project's files, by `/`-separated path relative to its root. */
+    files: Record<string, string>;
+    lockfile: string;
+    /** `pnpm-workspace.yaml`, when the project has one: it can change the layout. */
+    workspace?: string | null;
+    sources: TypecheckSources;
+    onProgress?: (progress: TypecheckProgress) => void;
+    /** Also return every file in each program, as `tsc --listFiles` prints them. */
+    listFiles?: boolean;
+};
+export type TypecheckProgress = {
+    step: "layout";
+} | {
+    step: "compiler";
+    version: string;
+} | {
+    step: "types";
+    fetched: number;
+} | {
+    step: "check";
+    tsconfig: string;
+};
+export type TypeErrorEntry = {
+    /** Relative to the project's root; `null` for an error of no file (an option, a missing lib). */
+    file: string | null;
+    /** 1-based. */
+    line: number | null;
+    column: number | null;
+    code: number;
+    message: string;
+    /** The tsconfig whose program reported it. */
+    tsconfig: string;
+};
+export type ProgramSummary = {
+    tsconfig: string;
+    /** Files in the program, the project's and the declarations it reached. */
+    files: number;
+    errors: number;
+    /** With `listFiles`: each file's path, relative to the project's root when it is under it. */
+    fileNames?: string[];
+};
+export type TypecheckResult = {
+    errors: TypeErrorEntry[];
+    programs: ProgramSummary[];
+    typescript: CompilerChoice;
+    bundles: AcquisitionStats & {
+        count: number;
+        rounds: number;
+    };
+    /** Packages whose types could not be fetched: errors about them may be wrong. */
+    missing: MissingTypes[];
+    timings: {
+        layoutMs: number;
+        compilerMs: number;
+        typesMs: number;
+        checkMs: number;
+        totalMs: number;
+    };
+};
+/** The project's root in the file system the checker builds. */
+export declare const PROJECT_ROOT = "/project";
+export declare function layoutOf(input: {
+    lockfile: string;
+    workspace?: string | null;
+    files: Record<string, string>;
+}): {
+    lockfile: PnpmLockfile;
+    layout: PnpmLayout;
+};
+/** Typechecks a project as it would be after `pnpm install`. */
+export declare function typecheckProject(input: TypecheckInput): Promise<TypecheckResult>;
+/**
+ * The errors of `next` that `base` does not have (decision 20): an upgrade
+ * is judged only by the errors it adds. Errors are matched by file, code and
+ * message, not by position, so that an error which only moved is not new;
+ * and counted, so that a second copy of an error the base has once is.
+ */
+export declare function newErrors(base: TypeErrorEntry[], next: TypeErrorEntry[]): TypeErrorEntry[];

package/dist/declarations/src/typecheck/typescriptCompiler.d.ts

@@ -0,0 +1,52 @@
+import type * as TS from "typescript";
+/** The TypeScript API, from whichever `typescript.js` was loaded. */
+export type TypeScript = typeof TS;
+/** adept's `/compiler/<version>`: `lib/typescript.js` and every `lib/lib.*.d.ts`. */
+export type CompilerBundle = {
+    version: string;
+    files: Record<string, string>;
+};
+/**
+ * The TypeScript a project gets when its own cannot run here.
+ *
+ * TypeScript 7 and later are a native compiler with no JavaScript one
+ * (`lib/typescript.js`), so they cannot run in a browser; a project with no
+ * `typescript` at all has none to choose. Both are checked with this 6.x,
+ * the one the Studio itself is built and tested with
+ * (`typescriptCompiler.test.ts` keeps the two the same). It is fetched from
+ * adept like any other, rather than shipped in the Studio's bundle, which is
+ * embedded in every Val server.
+ */
+export declare const BUNDLED_TYPESCRIPT = "6.0.3";
+/** Which TypeScript checks a project, and why that one. */
+export type CompilerChoice = {
+    version: string;
+    /** What the root importer's lockfile entry gives, if anything. */
+    wanted: string | null;
+    reason: "project" | "no-typescript" | "no-js-compiler";
+};
+export declare function chooseCompiler(wanted: string | null): CompilerChoice;
+/** A TypeScript that does not have what a typecheck needs. */
+export declare class CompilerError extends Error {
+}
+/**
+ * Evaluates `lib/typescript.js` and returns its API.
+ *
+ * It is a CommonJS module that also runs as a plain script, so it is given a
+ * `module` to assign to. `require` and `process` are given as `undefined`,
+ * as they are in a worker, so that it does not build a Node `ts.sys` when it
+ * runs under Node: everything it reads goes through the host this
+ * typechecker gives it.
+ */
+export declare function evaluateTypeScript(source: string): TypeScript;
+/**
+ * `ts.matchFiles`, which is how `tsc` expands a tsconfig's `include` and
+ * `exclude`. It is internal, but every `typescript.js` since 2.x has it on
+ * its API object, and using it is the only way to agree with `tsc` on hidden
+ * files, `node_modules` and implicit directory globs.
+ */
+export type MatchFiles = (path: string, extensions: readonly string[] | undefined, excludes: readonly string[] | undefined, includes: readonly string[] | undefined, useCaseSensitiveFileNames: boolean, currentDirectory: string, depth: number | undefined, getFileSystemEntries: (path: string) => {
+    files: readonly string[];
+    directories: readonly string[];
+}, realpath: (path: string) => string) => string[];
+export declare function matchFilesOf(ts: TypeScript): MatchFiles;