@scriptc/compiler 0.0.0 → 0.0.2

package/dist/frontend/ts7/program.d.ts

@@ -0,0 +1,99 @@
+import type { CompilerOptions, Diagnostic, Project, Snapshot } from "typescript/unstable/sync";
+import type { SourceFile } from "typescript/unstable/ast";
+import { CheckerFacade } from "./checker.js";
+/** The compiler options our createProgram accepts: TS7's CompilerOptions
+ * shape (numeric enums for target/module/moduleResolution — the enums module
+ * re-exports them symbolically) with the 5.9.3 "lib.es2025.d.ts" lib
+ * spelling also accepted. */
+export type Ts7CompilerOptions = CompilerOptions;
+/** One spawned tsgo server plus the virtual-FS overlay serving synthesized
+ * tsconfigs. Share a host across programs to pay the spawn once; the overlay
+ * is a live map, so each createProgram call adds its config before taking
+ * the snapshot. */
+export declare class Ts7Host {
+    private readonly virtualFiles;
+    private readonly api;
+    private closed;
+    constructor(options?: {
+        cwd?: string;
+        collectTiming?: boolean;
+        /** Optional real-path shadow (the --npm-static resolution lever):
+         * `readFile` may answer REPLACEMENT content for a real file (a
+         * types-stripped package.json) and `hideFile` may shadow a real file
+         * out of existence (an opted-in package's shipped .d.ts). Virtual
+         * files always win; unshadowed paths fall through to the real FS. */
+        fsShadow?: {
+            readFile: (path: string) => string | undefined;
+            hideFile: (path: string) => boolean;
+        } | null;
+    });
+    /** Registers an in-memory file served to tsgo by the virtual-FS hooks. */
+    addVirtualFile(path: string, content: string): void;
+    /** tsgo's own tsconfig parser (extends chains resolved server-side) — the
+     * 7-world replacement for ts.readConfigFile + ts.parseJsonConfigFileContent.
+     * Returns raw option values (strings for enum-ish knobs) and the resolved
+     * file list. */
+    parseConfigFile(configPath: string): {
+        options: Record<string, unknown>;
+        fileNames: string[];
+    };
+    createProgram(rootNames: readonly string[], options: Ts7CompilerOptions, 
+    /** Internal: true when the program owns this host and dispose() closes it. */
+    programOwnsHost?: boolean): Ts7Program;
+    getTimingInfo(): unknown;
+    close(): void;
+}
+/** ts.Program-shaped facade over a TS7 Project: same-name query surface plus
+ * getTypeChecker() returning the memoizing/batching CheckerFacade. dispose()
+ * releases the snapshot (and the host, when this program spawned it). */
+export declare class Ts7Program {
+    /** The underlying TS7 project (program + checker + emitter). */
+    readonly project: Project;
+    private readonly snapshot;
+    private readonly host;
+    private readonly sharedHost;
+    private sourceFilesCache;
+    private checkerFacade;
+    constructor(
+    /** The underlying TS7 project (program + checker + emitter). */
+    project: Project, snapshot: Snapshot, host: Ts7Host, sharedHost: boolean);
+    getCompilerOptions(): CompilerOptions;
+    getSourceFile(fileName: string): SourceFile | undefined;
+    getSourceFileNames(): readonly string[];
+    /** Materializes every file of the program (5.9.3's getSourceFiles shape).
+     * 7.0.2 serves files one by one; the result is cached, so the full-program
+     * sweeps (preflight's user-file scan) pay the transfer once. */
+    getSourceFiles(): readonly SourceFile[];
+    getTypeChecker(): CheckerFacade;
+    getSyntacticDiagnostics(sourceFile?: SourceFile): readonly Diagnostic[];
+    getSemanticDiagnostics(sourceFile?: SourceFile): readonly Diagnostic[];
+    getGlobalDiagnostics(): readonly Diagnostic[];
+    getProgramDiagnostics(): readonly Diagnostic[];
+    getConfigFileParsingDiagnostics(): readonly Diagnostic[];
+    isSourceFileDefaultLibrary(file: SourceFile): boolean;
+    isSourceFileFromExternalLibrary(file: SourceFile): boolean;
+    dispose(): void;
+}
+/** The ts.createProgram-shaped entry: roots + options, tsconfig synthesized
+ * behind the scenes. Without a shared host each call spawns (and owns) its
+ * own tsgo server — pass one Ts7Host when building several programs (the
+ * lowering world and preflight's project world). */
+export declare function createProgram(rootNames: readonly string[], options: Ts7CompilerOptions, host?: Ts7Host): Ts7Program;
+/** 5.9.3's getPreEmitDiagnostics, composed from 7.0.2's split surface (the
+ * package dropped the aggregate). Order mirrors 5.9.3: config, options/
+ * program, global, syntactic, semantic. */
+export declare function getPreEmitDiagnostics(program: Ts7Program): readonly Diagnostic[];
+/** ts.findConfigFile: nearest configName walking up from searchPath. */
+export declare function findConfigFile(searchPath: string, fileExists?: (fileName: string) => boolean, configName?: string): string | undefined;
+/** The ts.sys subset the census uses (program.ts, npm.ts — 8 call sites),
+ * over node:fs. 7.0.2 ships no ts.sys; the compiler runs on Node, so these
+ * are the direct implementations. */
+export declare const sys: {
+    fileExists(path: string): boolean;
+    readFile(path: string): string | undefined;
+    writeFile(path: string, data: string): void;
+    directoryExists(path: string): boolean;
+    getCurrentDirectory(): string;
+    useCaseSensitiveFileNames: boolean;
+    newLine: string;
+};

package/dist/frontend/ts7/program.js

@@ -0,0 +1,278 @@
+/* Program lifecycle over typescript@7.0.2's unstable sync API — the
+ * ts.createProgram-shaped entry the survey's probe7b proved out.
+ *
+ * 7.0.2 has no createProgram(roots, options): the model is
+ * new API({cwd, fs}) -> updateSnapshot({openProjects: [tsconfig]}) ->
+ * snapshot.getProject(...), strictly tsconfig-driven. scriptc's no-tsconfig /
+ * extra-roots story (entry + ambient dts + fallback/overrides dts, forced
+ * options) maps onto that through a SYNTHESIZED IN-MEMORY tsconfig: the
+ * virtual-FS hooks serve one nonexistent tsconfig path whose "files" lists
+ * exactly our roots (absolute paths) and whose compilerOptions serialize our
+ * options; every other path falls through to the real filesystem, so real
+ * entries, ambient .d.ts files, and node_modules resolve exactly as on disk.
+ *
+ * One Ts7Host owns one spawned tsgo server (54 ms warm spawn per the survey;
+ * 387 cold). createProgram() takes an optional shared host — the default
+ * spawns a private one that dispose() closes. */
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { API } from "typescript/unstable/sync";
+import { CheckerFacade } from "./checker.js";
+import { enumKeyOf, ModuleKind, ModuleResolutionKind, ScriptTarget } from "./enums.js";
+/* tsconfig JSON wants enum NAMES; the options object carries TS7's numeric
+ * enum values. The names come from the enum objects' own reverse mappings —
+ * nothing here knows a number. */
+function serializeOptions(options) {
+    const out = {};
+    for (const [key, value] of Object.entries(options)) {
+        if (value === undefined)
+            continue;
+        switch (key) {
+            // tsgo's tsconfig parser is case-sensitive about enum-option spellings
+            // (5.9.3's was not): the enum KEY names lowercase to the accepted forms
+            // ("ESNext" -> "esnext", "Bundler" -> "bundler", "NodeNext" ->
+            // "nodenext").
+            case "target":
+                // ScriptTarget.ESNext and .Latest share a value; the reverse map
+                // answers "Latest", which the option parser does not accept.
+                out[key] =
+                    value === ScriptTarget.ESNext
+                        ? "esnext"
+                        : (enumKeyOf(ScriptTarget, value)?.toLowerCase() ?? value);
+                break;
+            case "module":
+                out[key] = enumKeyOf(ModuleKind, value)?.toLowerCase() ?? value;
+                break;
+            case "moduleResolution":
+                out[key] = enumKeyOf(ModuleResolutionKind, value)?.toLowerCase() ?? value;
+                break;
+            case "lib":
+                // 5.9.3 spells lib entries "lib.es2025.d.ts"; tsconfig wants "es2025".
+                out[key] = value.map((lib) => lib.startsWith("lib.") && lib.endsWith(".d.ts") ? lib.slice(4, -5) : lib);
+                break;
+            default: {
+                if (typeof value === "number" && key !== "maxNodeModuleJsDepth") {
+                    throw new Error(`ts7 createProgram: unhandled enum-valued compiler option '${key}'`);
+                }
+                out[key] = value;
+            }
+        }
+    }
+    return out;
+}
+let nextConfigId = 0;
+/** One spawned tsgo server plus the virtual-FS overlay serving synthesized
+ * tsconfigs. Share a host across programs to pay the spawn once; the overlay
+ * is a live map, so each createProgram call adds its config before taking
+ * the snapshot. */
+export class Ts7Host {
+    virtualFiles = new Map();
+    api;
+    closed = false;
+    constructor(options) {
+        const virtualFiles = this.virtualFiles;
+        const shadow = options?.fsShadow ?? null;
+        this.api = new API({
+            cwd: options?.cwd ?? process.cwd(),
+            ...(options?.collectTiming !== undefined ? { collectTiming: options.collectTiming } : {}),
+            fs: {
+                // string => virtual (or shadowed) hit; null => shadowed out of
+                // existence; undefined => real-FS fallthrough.
+                readFile: (fileName) => {
+                    const virtual = virtualFiles.get(fileName);
+                    if (virtual !== undefined)
+                        return virtual;
+                    if (shadow === null)
+                        return undefined;
+                    if (shadow.hideFile(fileName))
+                        return null;
+                    return shadow.readFile(fileName);
+                },
+                fileExists: (fileName) => {
+                    if (virtualFiles.has(fileName))
+                        return true;
+                    if (shadow !== null && shadow.hideFile(fileName))
+                        return false;
+                    return undefined;
+                },
+                directoryExists: () => undefined,
+                realpath: (path) => (virtualFiles.has(path) ? path : undefined),
+                getAccessibleEntries: () => undefined,
+            },
+        });
+    }
+    /** Registers an in-memory file served to tsgo by the virtual-FS hooks. */
+    addVirtualFile(path, content) {
+        this.virtualFiles.set(path, content);
+    }
+    /** tsgo's own tsconfig parser (extends chains resolved server-side) — the
+     * 7-world replacement for ts.readConfigFile + ts.parseJsonConfigFileContent.
+     * Returns raw option values (strings for enum-ish knobs) and the resolved
+     * file list. */
+    parseConfigFile(configPath) {
+        return this.api.parseConfigFile(resolve(configPath));
+    }
+    createProgram(rootNames, options, 
+    /** Internal: true when the program owns this host and dispose() closes it. */
+    programOwnsHost = false) {
+        if (this.closed)
+            throw new Error("Ts7Host is closed");
+        const roots = rootNames.map((r) => resolve(r));
+        const first = roots[0];
+        if (first === undefined)
+            throw new Error("ts7 createProgram: no root files");
+        const configPath = join(dirname(first), `__scriptc-ts7-${nextConfigId++}.tsconfig.json`);
+        this.addVirtualFile(configPath, JSON.stringify({ compilerOptions: serializeOptions(options), files: roots, include: [] }));
+        const snapshot = this.api.updateSnapshot({ openProjects: [configPath] });
+        const project = snapshot.getProject(configPath);
+        if (!project) {
+            snapshot.dispose();
+            throw new Error(`ts7 createProgram: project failed to open for ${first}`);
+        }
+        return new Ts7Program(project, snapshot, this, !programOwnsHost);
+    }
+    getTimingInfo() {
+        return this.api.getTimingInfo();
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.api.close();
+    }
+}
+/** ts.Program-shaped facade over a TS7 Project: same-name query surface plus
+ * getTypeChecker() returning the memoizing/batching CheckerFacade. dispose()
+ * releases the snapshot (and the host, when this program spawned it). */
+export class Ts7Program {
+    project;
+    snapshot;
+    host;
+    sharedHost;
+    sourceFilesCache = null;
+    checkerFacade = null;
+    constructor(
+    /** The underlying TS7 project (program + checker + emitter). */
+    project, snapshot, host, sharedHost) {
+        this.project = project;
+        this.snapshot = snapshot;
+        this.host = host;
+        this.sharedHost = sharedHost;
+    }
+    getCompilerOptions() {
+        return this.project.program.getCompilerOptions();
+    }
+    getSourceFile(fileName) {
+        return this.project.program.getSourceFile(resolve(fileName));
+    }
+    getSourceFileNames() {
+        return this.project.program.getSourceFileNames();
+    }
+    /** Materializes every file of the program (5.9.3's getSourceFiles shape).
+     * 7.0.2 serves files one by one; the result is cached, so the full-program
+     * sweeps (preflight's user-file scan) pay the transfer once. */
+    getSourceFiles() {
+        if (this.sourceFilesCache === null) {
+            const program = this.project.program;
+            this.sourceFilesCache = program
+                .getSourceFileNames()
+                .map((name) => program.getSourceFile(name))
+                .filter((sf) => sf !== undefined);
+        }
+        return this.sourceFilesCache;
+    }
+    getTypeChecker() {
+        this.checkerFacade ??= new CheckerFacade(this.project.checker, { project: this.project });
+        return this.checkerFacade;
+    }
+    getSyntacticDiagnostics(sourceFile) {
+        return this.project.program.getSyntacticDiagnostics(sourceFile?.fileName);
+    }
+    getSemanticDiagnostics(sourceFile) {
+        return this.project.program.getSemanticDiagnostics(sourceFile?.fileName);
+    }
+    getGlobalDiagnostics() {
+        return this.project.program.getGlobalDiagnostics();
+    }
+    getProgramDiagnostics() {
+        return this.project.program.getProgramDiagnostics();
+    }
+    getConfigFileParsingDiagnostics() {
+        return this.project.program.getConfigFileParsingDiagnostics();
+    }
+    isSourceFileDefaultLibrary(file) {
+        return this.project.program.isSourceFileDefaultLibrary(file);
+    }
+    isSourceFileFromExternalLibrary(file) {
+        return this.project.program.isSourceFileFromExternalLibrary(file);
+    }
+    dispose() {
+        this.snapshot.dispose();
+        if (!this.sharedHost)
+            this.host.close();
+    }
+}
+/** The ts.createProgram-shaped entry: roots + options, tsconfig synthesized
+ * behind the scenes. Without a shared host each call spawns (and owns) its
+ * own tsgo server — pass one Ts7Host when building several programs (the
+ * lowering world and preflight's project world). */
+export function createProgram(rootNames, options, host) {
+    if (host)
+        return host.createProgram(rootNames, options);
+    const first = rootNames[0];
+    const owned = new Ts7Host({ cwd: first !== undefined ? dirname(resolve(first)) : process.cwd() });
+    return owned.createProgram(rootNames, options, /* programOwnsHost */ true);
+}
+/** 5.9.3's getPreEmitDiagnostics, composed from 7.0.2's split surface (the
+ * package dropped the aggregate). Order mirrors 5.9.3: config, options/
+ * program, global, syntactic, semantic. */
+export function getPreEmitDiagnostics(program) {
+    return [
+        ...program.getConfigFileParsingDiagnostics(),
+        ...program.getProgramDiagnostics(),
+        ...program.getGlobalDiagnostics(),
+        ...program.getSyntacticDiagnostics(),
+        ...program.getSemanticDiagnostics(),
+    ];
+}
+/** ts.findConfigFile: nearest configName walking up from searchPath. */
+export function findConfigFile(searchPath, fileExists = sys.fileExists, configName = "tsconfig.json") {
+    let dir = resolve(searchPath);
+    for (;;) {
+        const candidate = join(dir, configName);
+        if (fileExists(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+/** The ts.sys subset the census uses (program.ts, npm.ts — 8 call sites),
+ * over node:fs. 7.0.2 ships no ts.sys; the compiler runs on Node, so these
+ * are the direct implementations. */
+export const sys = {
+    fileExists(path) {
+        return existsSync(path) && statSync(path).isFile();
+    },
+    readFile(path) {
+        try {
+            return readFileSync(path, "utf8");
+        }
+        catch {
+            return undefined;
+        }
+    },
+    writeFile(path, data) {
+        writeFileSync(path, data);
+    },
+    directoryExists(path) {
+        return existsSync(path) && statSync(path).isDirectory();
+    },
+    getCurrentDirectory() {
+        return process.cwd();
+    },
+    useCaseSensitiveFileNames: true,
+    newLine: "\n",
+};
+//# sourceMappingURL=program.js.map

package/dist/frontend/ts7/program.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"program.js","sourceRoot":"","sources":["../../../src/frontend/ts7/program.ts"],"names":[],"mappings":"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"}

package/dist/frontend/ts7/world-check.d.ts

@@ -0,0 +1,3 @@
+import type ts5 from "typescript5";
+import type * as ts7 from "./adapter.js";
+export declare function assertWorldsAreDisjoint(node5: ts5.Node, node7: ts7.Node, file5: ts5.SourceFile, file7: ts7.SourceFile, kind5: ts5.SyntaxKind, kind7: ts7.SyntaxKind): void;

package/dist/frontend/ts7/world-check.js

@@ -0,0 +1,34 @@
+/* Two-world separation, enforced at build time. The 5.9.3 world (the
+ * "typescript5" aliased import — parser/transpile islands only) and the
+ * 7.0.2 world (this adapter, over the real "typescript" dependency) must
+ * never exchange AST or checker objects: the enums
+ * renumbered between worlds, so a node that crosses carries kinds and flags
+ * that MEAN something else on the other side, silently.
+ *
+ * The fence is nominal enum typing: every node interface carries a
+ * `kind`/`flags` member typed by its own package's enum declaration, and
+ * TypeScript never treats two distinct enum declarations as assignable. The
+ * assertions below pin that this actually holds in both directions for the
+ * shapes that travel (nodes, source files, enum values) — if a future
+ * package update ever made the worlds structurally compatible, pnpm build
+ * fails HERE instead of letting objects drift across.
+ *
+ * Type-level only: the "typescript5" import is type-position, so no 5.9.3
+ * runtime joins the adapter's module graph, and the assertion function is
+ * never called. */
+export function assertWorldsAreDisjoint(node5, node7, file5, file7, kind5, kind7) {
+    // @ts-expect-error a 5.9.3 node must not flow into the 7 world
+    const _a = node5;
+    // @ts-expect-error a 7 node must not flow into the 5.9.3 world
+    const _b = node7;
+    // @ts-expect-error a 5.9.3 source file must not flow into the 7 world
+    const _c = file5;
+    // @ts-expect-error a 7 source file must not flow into the 5.9.3 world
+    const _d = file7;
+    // @ts-expect-error 5.9.3 SyntaxKind values are not 7 SyntaxKind values (renumbered)
+    const _e = kind5;
+    // @ts-expect-error 7 SyntaxKind values are not 5.9.3 SyntaxKind values (renumbered)
+    const _f = kind7;
+    void [_a, _b, _c, _d, _e, _f];
+}
+//# sourceMappingURL=world-check.js.map

package/dist/frontend/ts7/world-check.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-check.js","sourceRoot":"","sources":["../../../src/frontend/ts7/world-check.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;mBAiBmB;AAKnB,MAAM,UAAU,uBAAuB,CACrC,KAAe,EACf,KAAe,EACf,KAAqB,EACrB,KAAqB,EACrB,KAAqB,EACrB,KAAqB;IAErB,+DAA+D;IAC/D,MAAM,EAAE,GAAa,KAAK,CAAC;IAC3B,+DAA+D;IAC/D,MAAM,EAAE,GAAa,KAAK,CAAC;IAC3B,sEAAsE;IACtE,MAAM,EAAE,GAAmB,KAAK,CAAC;IACjC,sEAAsE;IACtE,MAAM,EAAE,GAAmB,KAAK,CAAC;IACjC,oFAAoF;IACpF,MAAM,EAAE,GAAmB,KAAK,CAAC;IACjC,oFAAoF;IACpF,MAAM,EAAE,GAAmB,KAAK,CAAC;IACjC,KAAK,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;AAChC,CAAC"}

package/dist/frontend/types.d.ts

@@ -0,0 +1,205 @@
+import * as ts from "./ts7/adapter.js";
+import type { IrRecordShape, IrType, IrUnionDef } from "../ir/nodes.js";
+import { typeKey } from "../ir/nodes.js";
+export { typeKey };
+/** The island-backed ambient TYPE names of the fetch slice: standard-
+ * library interfaces whose VALUES live in the embedded engine (the
+ * engine's fetch mints the Response; AbortSignal.timeout mints the
+ * signal), so under --dynamic they map to island handles (jsval) exactly
+ * like npm-declared types. Checked with declaration provenance in mapType;
+ * consumed by the lowerer's badType for the static-build wording. */
+export declare const ISLAND_AMBIENT_TYPES: readonly ["Response", "RequestInit", "AbortSignal"];
+/** The frontend's record-shape interner. Records are monomorphic structural
+ * shapes: fields sorted by name form the canonical identity, and two types
+ * with the same canonical field list share one shapeId (and later one C
+ * struct). Owned by the Lowerer; `mapType` needs it to intern the object
+ * types it encounters, which is why it is threaded through as a parameter. */
+export declare class ShapeRegistry {
+    private readonly byKey;
+    private readonly byId;
+    /** All interned shapes in first-seen (`r0`, `r1`, ...) order. */
+    readonly shapes: IrRecordShape[];
+    /** ts.Types currently being mapped — breaks recursive shape types
+     * (`type T = { next: T }`), which mapType rejects by returning null. */
+    readonly inProgress: Set<ts.Type>;
+    /** Interns a canonical (name-sorted) field list, returning its shapeId.
+     * `tuple` shapes (fields "0".."n-1" from a tuple type) intern SEPARATELY
+     * from structurally identical numeric-keyed object records: the flag is
+     * part of the identity because the two serialize differently (a tuple is
+     * a JSON array, an object a JSON object). A string index signature's
+     * value type (`indexValue`) is part of the identity too: the same
+     * declared fields with and without an overflow portion — or with
+     * differently-typed ones — are different structs. */
+    intern(fields: {
+        name: string;
+        type: IrType;
+    }[], tuple?: boolean, indexValue?: IrType, declaredOrder?: string[]): string;
+    get(shapeId: string): IrRecordShape | undefined;
+}
+/** The frontend's union interner — mirrors ShapeRegistry. A union's
+ * canonical identity is its typeKey-sorted arm list; two ts unions whose
+ * arms map to the same IR types share one unionId (and later one runtime
+ * tag numbering: an arm's index in the canonical list IS its tag). Owned by
+ * the Lowerer; threaded through mapType exactly like ShapeRegistry. */
+export declare class UnionRegistry {
+    private readonly byKey;
+    private readonly byId;
+    /** All interned unions in first-seen (`u0`, `u1`, ...) order. */
+    readonly unions: IrUnionDef[];
+    /** ts.Types currently being mapped — breaks recursive union types
+     * (`type T = A | { next: T }`), which mapType rejects by returning null. */
+    readonly inProgress: Set<ts.Type>;
+    /** Interns a canonical (typeKey-sorted, deduplicated) arm list, returning
+     * its unionId. */
+    intern(arms: IrType[]): string;
+    get(unionId: string): IrUnionDef | undefined;
+}
+/** Human-readable rendering of an IrType for diagnostics (records expand to
+ * their canonical field list, unions to their arms; `checker.typeToString`
+ * can't — it never sees IR types). */
+export declare function formatIrType(t: IrType, shapes: ShapeRegistry, unions: UnionRegistry): string;
+/** True when the declaration sits inside `declare module "<name>"` (or
+ * its node:-prefixed twin) — the disambiguator for builtin-module type
+ * names that repeat across modules (net.Server vs http.Server). Both
+ * @types/node and the shipped fallback declare builtins this way. */
+/** ES OrdinaryOwnPropertyKeys order over string keys: canonical array
+ * indices (the exact string spelling of an integer in [0, 2^32-1)) come
+ * first in ascending numeric order, everything else follows in the given
+ * (insertion/declaration) order. This is JS's enumeration order for the
+ * objects records model — Object.keys, JSON.stringify, spread, inspect. */
+export declare function esOwnKeyOrder(names: string[]): string[];
+/** True when a type contains a record anywhere (the trigger for the
+ * shape-mismatch diagnostic SC2002 — non-record mismatches are tsc's or
+ * the validator's business). */
+export declare function containsRecord(t: IrType): boolean;
+/** True when a type contains a union anywhere reachable without a registry
+ * (the trigger for the union-mismatch diagnostic SC2003 — e.g. a value
+ * narrowed to a SUB-union flowing into the full union's slot, which would
+ * need a runtime re-tag). */
+export declare function containsUnion(t: IrType): boolean;
+/** ts.Type → IrType. Returns null for anything outside the supported
+ * surface; the caller turns that into a SC2001 diagnostic with
+ * checker.typeToString.
+ *
+ * Literal types are widened FIRST (`const x = 1` has type `1`, `true` has
+ * type `true`; internally `boolean` is the union `true | false`) — mapping
+ * without widening is the classic bug this function exists to centralize.
+ *
+ * `ctx.shapes` is the Lowerer's shape registry: object types over data
+ * properties intern their canonical shape there and map to
+ * `{ kind: "record", shapeId }`.
+ */
+/** Computes the program-wide IR name for a class declaration. Injected by
+ * the Lowerer so type mapping and lowering agree on qualified names in
+ * multi-file programs (two files may each declare `class Point`). */
+export type ClassNamer = (decl: ts.ClassLikeDeclaration) => string;
+/** Resolves a type-parameter ts.Type to a concrete IR type, or null when it
+ * isn't one / isn't bound. Injected by the Lowerer while it instantiates a
+ * generic function body (monomorphization): inside the body the checker
+ * reports the UNSUBSTITUTED types (`T`, `T[]`, `{ v: T }`), so the
+ * substitution has to happen inside mapType's recursion — carried by the
+ * TypeMapperCtx exactly like ClassNamer. */
+export type TypeParamResolver = (t: ts.Type) => IrType | null;
+/** Everything mapType needs besides the type itself: the checker, the two
+ * interners (owned by the Lowerer), and the Lowerer-injected hooks. Built
+ * once per Lowerer and threaded through the recursion — adding a hook means
+ * one new field here, not a new parameter at every call site. */
+export interface TypeMapperCtx {
+    checker: ts.TypeChecker;
+    shapes: ShapeRegistry;
+    unions: UnionRegistry;
+    classNamer: ClassNamer;
+    resolveTypeParam?: TypeParamResolver;
+    /** GENERIC program classes (monomorphization by flow): the mapping of a
+     * concrete instantiation reference (`Box<number>`) — the Lowerer
+     * registers/reuses the instantiation (`Box%0`) and answers its object
+     * type; null when a type argument doesn't map, the cap tripped, or the
+     * family never collected. Absent in checkers with no lowering attached
+     * (generic instance types stay unmapped there). */
+    genericClassInstance?: (decl: ts.ClassLikeDeclaration, typeRef: ts.Type) => IrType | null;
+    /** MIXIN class nodes (the class inside a mixin function): one shared
+     * AST node, one instantiation per call site — the node's instance type
+     * resolves to the instantiation CURRENTLY collecting/lowering (`this`
+     * inside members, self-referential member types), null outside any
+     * mixin context (the type alone cannot name a call site). */
+    mixinClassInstance?: (decl: ts.ClassLikeDeclaration) => IrType | null;
+    /** MIXIN instance INTERSECTIONS (`Tagged.C & Derived` — values built
+     * through a mixin result): resolved by chain structure to the unique
+     * pinned instantiation they describe; null when ambiguous or when no
+     * part names a mixin class node (lower-mixins.ts). */
+    mixinIntersectionInstance?: (widened: ts.Type) => IrType | null;
+    /** True for the STANDARD LIBRARY's files — the shipped ambient .d.ts or a
+     * lib.*.d.ts bundled with typescript (program.isSourceFileDefaultLibrary).
+     * Map/RegExp/Promise recognition needs declaration provenance: the name
+     * alone proves nothing (a user's own `interface Map` maps as a record). */
+    isStdlibFile: (sf: ts.SourceFile) => boolean;
+    /** True for an npm package's shipped .d.ts — a declaration file under
+     * node_modules that is NOT the standard library (typescript's own lib
+     * files live under node_modules too). Types declared there map to jsval
+     * under --dynamic: the package's implementation runs in the embedded
+     * engine, so its values are island handles. */
+    isNpmFile: (sf: ts.SourceFile) => boolean;
+    /** --dynamic: `any` maps to the island handle type (jsval). Off, `any`
+     * stays unmapped and the requires-dynamic diagnostic fires per site. */
+    dynamic: boolean;
+    /** True for files the Lowerer actually compiles (its module order). A
+     * class type can reach the entry through the TYPE world alone — a jsdoc
+     * `typeof import('./mod')` over a module never imported at value level
+     * pulls the file into the ts.Program without ever entering the lowered
+     * program, so its classes never register and an object type naming one
+     * would ICE the validator. Such instance types stay unmapped (null):
+     * callers fence them like any other unsupported type. */
+    isProgramFile: (sf: ts.SourceFile) => boolean;
+}
+export declare function mapType(type: ts.Type, ctx: TypeMapperCtx): IrType | null;
+/** The UNIT-ONLY slot type: the interned `null | undefined` union, the one
+ * representation the IR already has for values that are nothing but units.
+ * Bindings and fields whose CHECKER type is a bare unit (`null`,
+ * `undefined`, `void` in value position, or unions of only those) ride it:
+ * the runtime value is always one of the two interned unit instances, the
+ * tag is the narrowing test (`x === null`, `typeof x === "undefined"`),
+ * and JSON keeps Node's split (null serializes, undefined omits). The type
+ * admits an arm the checker may not spell (a `null`-typed slot gets an
+ * undefined arm too) — the representation is coarser than the TS type,
+ * exactly like literal widening, and tsc has already rejected every write
+ * that could inhabit the extra arm. */
+export declare function unitOnlyUnion(unions: UnionRegistry): IrType;
+/** The IteratorResult record of a generator's value channels: `{ done:
+ * boolean, value: V }` where V is dyn (an any/unknown channel) or the
+ * canonical union of the yield arms, the return arms (when the return
+ * channel carries a value), and `undefined` (an exhausted `.next()`
+ * answers undefined). ONE shape per channel pair — `g.next()`'s lowering,
+ * `.return()`, `.throw()`, the for-of desugar, and mapType's
+ * IteratorResult alias mapping all intern through here, so reads agree.
+ * Null when the combined union would be illegal (a func/set arm beside
+ * data arms, a map/regex arm — kinds with no narrowing test): such
+ * generators stay unmapped. */
+export declare function genResultRecord(yieldT: IrType, retT: IrType, shapes: ShapeRegistry, unions: UnionRegistry): (IrType & {
+    kind: "record";
+}) | null;
+/** True when a checker type is inhabited ONLY by the unit values —
+ * undefined (or `void`, whose runtime inhabitant is undefined) and null,
+ * or a union of just those. The positions that today fence VOID (record
+ * fields, tuple/array elements, variable slots) substitute unitOnlyUnion
+ * for these; RETURN positions keep the VOID mapping (a void return is not
+ * a value). */
+export declare function isUnitOnlyTsType(t: ts.Type): boolean;
+/** IR-level `t | undefined`, canonicalized and fenced exactly like the
+ * ts-union branch of mapType (typeKey-sorted arms, deduplicated; map/
+ * regex/dyn/void arms unrepresentable; a func arm IS representable — the
+ * result is exactly the nullable-callback shape mapType's union branch
+ * admits, `(() => void) | undefined`) so the interned union is IDENTICAL
+ * to what mapping the checker's own `T | undefined` produces. */
+export declare function withUndefinedArm(t: IrType, unions: UnionRegistry): IrType | null;
+/** A GENERIC-callable member type (`m<T>(x: T): T` / `f: <T>(x: T) => T` in
+ * an object type): pure function-shaped — call signatures only, every one
+ * carrying its own type parameters — with no data properties, no construct
+ * signatures, no index signatures. Such members are EXCLUDED from record
+ * shapes instead of failing them: no single closure slot can hold a generic
+ * function, so the shape keeps its data fields and calls of the member
+ * monomorphize per call site against the defining declaration (see
+ * lower-calls.ts, lowerObjLitGenericMethodCall). Node's JSON.stringify drops
+ * function-valued properties, so serialization of the shape stays exact;
+ * Object.keys over such a shape omits the member (a pin — every excluded
+ * member is a function the key walk would name). */
+export declare function isGenericCallableMemberType(t: ts.Type, checker: ts.TypeChecker): boolean;