@scriptc/compiler 0.1.6 → 0.2.0

package/dist/frontend/program.d.ts

@@ -1,5 +1,6 @@
 import * as ts from "./ts7/adapter.js";
 import type { ScrDiagnostic } from "../diagnostics/diagnostic.js";
+import type { FrontendServices } from "./services.js";
 export interface LoadResult {
     program: ts.Program;
     entry: ts.SourceFile;
@@ -51,26 +52,28 @@ export interface StartupCrash {
  * gives `paths` keys containing `*` pattern semantics, so accepting one here
  * would silently broaden the mapping beyond the specifier the caller named. */
 export declare function isExactExternalTypeSpecifier(specifier: string): boolean;
+/** Classify the explicitly selected installed package's own sources. */
+export declare function entryPackageFilePredicate(entryPath: string): (file: string) => boolean;
 /** The pipeline surface: ONE tsgo program serves preflight AND the
  * lowering. The caller runs checkPreflight, hands program/entry/
  * moduleOrder straight to lowerToIr, and MUST dispose() when done — the
  * spawned tsgo server must not outlive the compile. */
-export declare function loadProgram(entryPath: string, opts?: {
-    /** --npm-static: package names whose shipped JS compiles as program
-     * modules this load (npm-static.ts owns the doctrine). Every load
-     * RESETS the module state, so flagless loads always start clean. */
-    npmStatic?: Iterable<string>;
-    /** Coverage-only type surfaces for modules supplied by an embedder.
-     * Exact bare specifiers only; values never become runtime edges. */
-    externalTypes?: ReadonlyMap<string, string> | Readonly<Record<string, string>> | undefined;
-}): LoadResult & {
+export interface ProgramLoadOptions {
+    /** Package names whose shipped JavaScript is compiled as program code. */
+    npmStatic?: readonly string[];
+    /** Exact host module specifiers paired with their declaration paths. */
+    externalTypes?: readonly (readonly [string, string])[];
+}
+export declare function loadProgram(entryPath: string, services: FrontendServices, opts?: ProgramLoadOptions): LoadResult & {
+    services: FrontendServices;
     dispose: () => void;
 };
 /** tsc diagnostics (syntax + types), the supported-import fence, and the
  * module evaluation order: fills load.moduleOrder (the SourceFiles
  * themselves — the lowering consumes them directly) and returns the
- * preflight diagnostics. The lowerer runs only on programs that pass. */
-export declare function checkPreflight(load: LoadResult): ScrDiagnostic[];
+ * preflight diagnostics. Preserve the caller's complete load shape when
+ * mutating it, including its owned services and disposal callback. */
+export declare function checkPreflight<T extends LoadResult>(load: T): ScrDiagnostic[];
 /** The specifier of a `require("...")` call: the callee is the bare
  * identifier `require` and the single argument a string literal. The one
  * recognizer preflight edges, global collection, and statement lowering
@@ -90,16 +93,38 @@ declare function requiresOf7(stmt: ts.Statement): {
     node: ts.Node;
     decl: ts.VariableDeclaration | null;
 }[];
+/** The exact `Object.defineProperty(exports|module.exports, "__esModule",
+ * { value: true })` interop stamp (shared by preflight and the no-op lowering). */
+export declare function isEsModuleStamp(expr: ts.Expression): boolean;
+/** Can code that runs BEFORE the declaration at index `k` reach one of
+ * its bindings? Static require aliases and symbol field keys bypass
+ * storage reads, so an early use could erase a TDZ error or a var's
+ * initial undefined value. Conservative reachability: earlier
+ * statements' whole subtrees (arrows and function expressions included)
+ * read the binding directly, or reference a hoisted function/class whose
+ * body (transitively through other hoisted declarations) reads it — a
+ * referenced function value may be invoked immediately by whatever takes
+ * it. Asynchronously-scheduled callbacks run after the whole module body,
+ * hence after the require: never an early read. Returns the first
+ * reachable binding's name, or null when position is provably free.
+ * (The CheckerFacade memoizes symbol queries, and 7's client dedupes
+ * symbol identity by server handle, so the Map-keyed-by-Symbol discipline
+ * carries over from the 5.9.3 original unchanged.) */
+export declare function bindingEarlyUse7(program: ts.Program, sf: ts.SourceFile, k: number, decl: ts.VariableDeclaration, precedingDecls: readonly ts.VariableDeclaration[]): string | null;
+/** True only for createRequire bindings the lowering can erase. Mutable
+ * declaration syntax needs a whole-file proof: no writes or escapes, and
+ * no code before initialization can reach the binding. */
+export declare function isCreateRequireBinding7(program: ts.Program, callee: ts.Identifier): boolean;
 /** True when Node would treat this file as an ES MODULE (never defining
  * require/__dirname there): fixed extensions first, then an explicit
  * nearest-package type, then Node's syntax markers for ambiguous .js/.ts
  * files. TypeScript's external-module bit is forced for checker scoping and
  * therefore intentionally plays no part in this runtime decision. */
-declare function isNodeEsmFile7(sf: ts.SourceFile): boolean;
+declare function isNodeEsmFile7(sf: ts.SourceFile, program?: ts.Program): boolean;
 /** The exported spelling of isCjsJsFile7 (the lowering's gate for
  * module.exports surfaces — `ts.isExternalModule` is NOT the CJS test:
  * tsgo marks CJS files with export assignments as external modules). */
-export declare function isCjsJsFile(sf: ts.SourceFile): boolean;
+export declare function isCjsJsFile(sf: ts.SourceFile, program?: ts.Program): boolean;
 /** A module edge, carrying what cycle admission needs when it turns out
  * to close one. `stmt` is the importing/re-exporting statement; absent
  * for require() edges, which are never admitted (their CJS home fails the
@@ -135,7 +160,7 @@ declare function resolveImport7(program: ts.Program, from: ts.SourceFile, specif
  * island under --dynamic. Resolution rides the own resolver (resolve.ts).
  * Null for relative and node: specifiers, and for anything that doesn't
  * resolve into node_modules. */
-declare function resolveNpmImport7(fromFileName: string, specifier: string): {
+declare function resolveNpmImport7(fromFileName: string, specifier: string, resolutionKind?: "import" | "require"): {
     packageName: string;
     version?: string;
     typesFile: string;
@@ -146,10 +171,9 @@ declare function locOf7(node: ts.Node): {
     end: number;
 };
 /** The whole TS7-lane lifecycle for one entry: spawn (or share) a tsgo
- * host, build the lowering-world program, run the ported preflight, and
- * dispose EVERYTHING before returning — the CLI process must exit promptly,
- * so no snapshot or tsgo child outlives the call. */
-export declare function checkPreflightTs7(entryPath: string, sharedHost?: ts.Ts7Host): {
+ * host, build the lowering-world program, run preflight, and release its
+ * snapshot. The caller owns the supplied host and can reuse or close it. */
+export declare function checkPreflightTs7(entryPath: string, host: ts.Ts7Host): {
     diags: ScrDiagnostic[];
     moduleOrder: string[];
 };
@@ -181,7 +205,7 @@ export declare function orderedImportsOf(program: ts.Program, sf: ts.SourceFile)
  * as a module edge), else null. No offender reporting here — preflight
  * already classified the import; this is the lookup the module-order and
  * lowering paths share. */
-export declare function npmStaticDepSf7(program: ts.Program, sf: ts.SourceFile, spec: string): ts.SourceFile | null;
+export declare function npmStaticDepSf7(program: ts.Program, sf: ts.SourceFile, spec: string, resolutionKind?: "import" | "require"): ts.SourceFile | null;
 /** True when `expr` is the `module.exports` property access. */
 export declare function isModuleExportsAccess(expr: ts.Expression): expr is ts.PropertyAccessExpression;
 /** Classifies a statement as a CommonJS EXPORT assignment: