xbintsc 0.3.87 → 0.5.20

package/src/codegen/generator/statements/loops.ts

@@ -12,7 +12,7 @@ import {
   type VariableDeclarationList,
   type WhileStatement,
 } from "../../../ast/nodes.js";
-import { numberLiteral } from "../../values.js";
+import { i64, numberLiteral, XT_TRUE } from "../../values.js";
 import type { Generator } from "../generator.js";
 import type { LoopLabels } from "../state.js";
 
@@ -48,10 +48,7 @@ export const loopStatementMethods: LoopStatementMethods = {
     this.terminate(`br label %${condLabel}`);
     this.startBlock(condLabel);
     const condition = this.emitExpression(statement.condition);
-    const truthy = this.reg();
-    this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${condition})`);
-    const nonzero = this.reg();
-    this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
+    const nonzero = this.emitTruthiness(condition, statement.condition);
     this.terminate(`br i1 ${nonzero}, label %${bodyLabel}, label %${endLabel}`);
     this.startBlock(bodyLabel);
     this.current.loops.push({ breakLabel: endLabel, continueLabel: condLabel, tryDepth: this.current.tryFrames.length, labels: this.takePendingLabels() });
@@ -74,10 +71,7 @@ export const loopStatementMethods: LoopStatementMethods = {
 
     this.startBlock(condLabel);
     const condition = this.emitExpression(statement.condition);
-    const truthy = this.reg();
-    this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${condition})`);
-    const nonzero = this.reg();
-    this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
+    const nonzero = this.emitTruthiness(condition, statement.condition);
     this.terminate(`br i1 ${nonzero}, label %${bodyLabel}, label %${endLabel}`);
     this.startBlock(endLabel);
   },
@@ -103,10 +97,7 @@ export const loopStatementMethods: LoopStatementMethods = {
     this.startBlock(condLabel);
     if (statement.condition) {
       const condition = this.emitExpression(statement.condition);
-      const truthy = this.reg();
-      this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${condition})`);
-      const nonzero = this.reg();
-      this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
+      const nonzero = this.emitTruthiness(condition, statement.condition);
       this.terminate(`br i1 ${nonzero}, label %${bodyLabel}, label %${endLabel}`);
     } else {
       this.terminate(`br label %${bodyLabel}`);
@@ -128,6 +119,50 @@ export const loopStatementMethods: LoopStatementMethods = {
   emitForOf(statement: ForOfStatement | ForInStatement): void {
     const source = this.emitExpression(statement.expression);
     const isForIn = statement.kind === SyntaxKind.ForInStatement;
+    /* `for await (const x of xs)`: resolve the async iteration protocol once,
+     * await one step per iteration, then bind its `value`. Running the await
+     * inside the surrounding async coroutine is what makes the loop suspend
+     * between elements instead of blocking the event loop. */
+    if (!isForIn && (statement as ForOfStatement).awaitModifier) {
+      const iterable = this.runtimeCall("xt_async_iter_open", [source]);
+      const condLabel = this.label("forawait.cond");
+      const bodyLabel = this.label("forawait.body");
+      const updateLabel = this.label("forawait.update");
+      const endLabel = this.label("forawait.end");
+      this.terminate(`br label %${condLabel}`);
+
+      this.startBlock(condLabel);
+      const next = this.runtimeCall("xt_async_iter_next", [iterable]);
+      const step = this.runtimeCall("xt_await", [next]);
+      const doneKey = this.stringValue("done");
+      const done = this.runtimeCall("xt_get", [step, doneKey]);
+      /* `xt_truthy` returns i32, so it cannot go through `runtimeCall`
+       * (which types every result as i64). */
+      const truthy = this.reg();
+      this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${done})`);
+      const nonzero = this.reg();
+      this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
+      this.terminate(`br i1 ${nonzero}, label %${endLabel}, label %${bodyLabel}`);
+
+      this.startBlock(bodyLabel);
+      const valueKey = this.stringValue("value");
+      const element = this.runtimeCall("xt_get", [step, valueKey]);
+      this.bindLoopVariable(statement.initializer, element);
+      this.current.loops.push({
+        breakLabel: endLabel,
+        continueLabel: updateLabel,
+        tryDepth: this.current.tryFrames.length,
+        labels: this.takePendingLabels(),
+      });
+      this.emitStatement(statement.statement);
+      this.current.loops.pop();
+      if (!this.current.terminated) this.terminate(`br label %${updateLabel}`);
+
+      this.startBlock(updateLabel);
+      this.terminate(`br label %${condLabel}`);
+      this.startBlock(endLabel);
+      return;
+    }
     // `for...in` iterates the enumerable keys (indices become strings);
     // `for...of` resolves the iteration protocol once, then walks it.
     const iterable = isForIn
@@ -148,10 +183,9 @@ export const loopStatementMethods: LoopStatementMethods = {
     /* `xt_iter_has` covers generators too, which cannot be sized up front. */
     const hasValue = this.reg();
     this.emit(`  ${hasValue} = call i64 @xt_iter_has(i64 ${iterable}, i64 ${index})`);
-    const truthy = this.reg();
-    this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${hasValue})`);
+    /* `xt_iter_has` always returns a boolean tag, so skip `xt_truthy`. */
     const nonzero = this.reg();
-    this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
+    this.emit(`  ${nonzero} = icmp eq i64 ${hasValue}, ${i64(XT_TRUE)}`);
     this.terminate(`br i1 ${nonzero}, label %${bodyLabel}, label %${endLabel}`);
 
     this.startBlock(bodyLabel);

package/src/codegen/generator/tables.ts

@@ -37,6 +37,9 @@ export const BUILTIN_INSTANCEOF: Readonly<Record<string, number>> = {
   Date: 5,
   RegExp: 6,
   Promise: 7,
+  WeakMap: 8,
+  WeakSet: 9,
+  WeakRef: 10,
   Uint8Array: 16,
   Int8Array: 17,
   Uint8ClampedArray: 18,
@@ -153,6 +156,10 @@ export const GLOBAL_FUNCTIONS: Record<string, string> = {
   clearTimeout: "xt_clear_timeout",
   setInterval: "xt_set_interval",
   clearInterval: "xt_clear_interval",
+  setImmediate: "xt_set_immediate",
+  clearImmediate: "xt_clear_immediate",
+  queueMicrotask: "xt_queue_microtask",
+  structuredClone: "xt_structured_clone",
   fetch: "xt_fetch",
   Number: "xt_number_ctor",
   String: "xt_string_ctor",
@@ -177,6 +184,10 @@ export const BUILTIN_FUNCTION_VALUES: Record<string, string> = {
   clearTimeout: "xt_builtin_value_clearTimeout",
   setInterval: "xt_builtin_value_setInterval",
   clearInterval: "xt_builtin_value_clearInterval",
+  setImmediate: "xt_builtin_value_setImmediate",
+  clearImmediate: "xt_builtin_value_clearImmediate",
+  queueMicrotask: "xt_builtin_value_queueMicrotask",
+  structuredClone: "xt_builtin_value_structuredClone",
   fetch: "xt_builtin_value_fetch",
   Number: "xt_builtin_value_number",
   String: "xt_builtin_value_string",
@@ -233,9 +244,11 @@ export const NAMESPACE_STATICS: Record<string, string> = {
   Symbol: "xt_symbol_static",
   Date: "xt_date_static",
   Promise: "xt_promise_static",
+  ArrayBuffer: "xt_array_buffer_static",
   path: "xt_path_static",
   os: "xt_os_static",
   process: "xt_process_call",
+  performance: "xt_performance_call",
   Buffer: "xt_buffer_static",
   stream: "xt_stream_static",
   Readable: "xt_stream_static",
@@ -253,18 +266,39 @@ export const NAMESPACE_STATICS: Record<string, string> = {
   ...TYPED_ARRAY_STATICS,
 };
 
+/** The well-known symbols exposed as properties of the `Symbol` namespace. */
+export const SYMBOL_WELL_KNOWN = new Set<string>([
+  "asyncIterator",
+  "hasInstance",
+  "isConcatSpreadable",
+  "iterator",
+  "match",
+  "matchAll",
+  "replace",
+  "search",
+  "species",
+  "split",
+  "toPrimitive",
+  "toStringTag",
+  "unscopables",
+]);
+
 /** Namespace identifiers whose property access maps to a runtime getter. */
 export const NAMESPACE_PROPERTIES: Record<string, string> = {
   process: "xt_process_get",
   "import.meta": "xt_import_meta",
   Symbol: "xt_symbol_get",
+  performance: "xt_performance_get",
 };
 
 /** Global constructors called as `new X(...)` (all have signature `(i32, i64*)`). */
 export const CTOR_FUNCTIONS: Record<string, string> = {
-  Array: "xt_array_new",
+  Array: "xt_array_ctor",
   Map: "xt_map_ctor",
   Set: "xt_set_ctor",
+  WeakMap: "xt_weak_map_ctor",
+  WeakSet: "xt_weak_set_ctor",
+  WeakRef: "xt_weak_ref_ctor",
   Date: "xt_date_ctor",
   RegExp: "xt_regexp_ctor",
   Promise: "xt_promise_ctor",
@@ -277,10 +311,42 @@ export const CTOR_FUNCTIONS: Record<string, string> = {
   Socket: "xt_net_socket_ctor",
   Server: "xt_net_server_ctor",
   EventEmitter: "xt_event_emitter_ctor",
+  URLSearchParams: "xt_url_search_params_ctor",
+  TextEncoder: "xt_text_encoder_ctor",
+  TextDecoder: "xt_text_decoder_ctor",
+  ArrayBuffer: "xt_array_buffer_ctor",
+  DataView: "xt_data_view_ctor",
   ...ERROR_CONSTRUCTORS,
   ...TYPED_ARRAY_CTORS,
 };
 
+/**
+ * Built-in constructors that are also ordinary first-class values. The codegen
+ * lowers a bare reference (`const A = Array`) to `xt_builtin_constructor`, which
+ * returns a cached function with `name`/`length`, a `prototype` and the
+ * constructor's statics (`A.isArray`, `A.from`, ...).
+ */
+export const FIRST_CLASS_CONSTRUCTORS = new Set<string>([
+  "Array",
+  "Object",
+  "Function",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "WeakRef",
+  "Date",
+  "RegExp",
+  "Promise",
+  ...Object.keys(TYPED_ARRAYS),
+  ...Object.keys(ERROR_CONSTRUCTORS),
+  "Number",
+  "String",
+  "Boolean",
+  "BigInt",
+  "Symbol",
+]);
+
 export const BUILTIN_METHODS = new Set<string>([
   "push", "pop", "shift", "unshift", "join", "slice", "indexOf", "includes", "map", "forEach", "filter",
   "reduce", "concat", "reverse", "charAt", "charCodeAt", "substring", "substr", "split", "toUpperCase",
@@ -350,7 +416,7 @@ export const KIND_NAMES = new Map<number, string>([
   [SyntaxKind.DeleteExpression, "delete expression"],
   [SyntaxKind.AwaitExpression, "await expression"],
   [SyntaxKind.YieldExpression, "yield expression"],
-  [SyntaxKind.SwitchStatement, "switch statement"],
+  [SyntaxKind.ModuleDeclaration, "namespace declaration"],
 ]);
 
 /**
@@ -394,7 +460,7 @@ export function utf8Bytes(text: string): number[] {
   if (!hasMultiByteUnit(text)) {
     const bytes: number[] = [];
     for (let index = 0; index < text.length; index++) bytes.push(text.charCodeAt(index) & 0xff);
-    return bytes;
+    return combineSurrogateBytes(bytes);
   }
   const bytes: number[] = [];
   const length = text.length;
@@ -420,6 +486,47 @@ function hasMultiByteUnit(text: string): boolean {
   return false;
 }
 
+/**
+ * Join adjacent WTF-8 surrogate halves into one four-byte sequence.
+ *
+ * A literal such as `"\uD83D\uDE00"` scans to two separate three-byte
+ * escapes. JavaScript's string value is one code point, so the emitted bytes
+ * must be the four-byte UTF-8 form (and a lone escape must stay three bytes,
+ * which is why this runs after scanning rather than per escape).
+ */
+function combineSurrogateBytes(bytes: number[]): number[] {
+  const out: number[] = [];
+  for (let index = 0; index < bytes.length; index++) {
+    if (
+      index + 5 < bytes.length &&
+      bytes[index] === 0xed &&
+      bytes[index + 1]! >= 0xa0 &&
+      bytes[index + 1]! <= 0xaf &&
+      bytes[index + 2]! >= 0x80 &&
+      bytes[index + 2]! <= 0xbf &&
+      bytes[index + 3] === 0xed &&
+      bytes[index + 4]! >= 0xb0 &&
+      bytes[index + 4]! <= 0xbf &&
+      bytes[index + 5]! >= 0x80 &&
+      bytes[index + 5]! <= 0xbf
+    ) {
+      const high = ((bytes[index]! & 0x0f) << 12) | ((bytes[index + 1]! & 0x3f) << 6) | (bytes[index + 2]! & 0x3f);
+      const low = ((bytes[index + 3]! & 0x0f) << 12) | ((bytes[index + 4]! & 0x3f) << 6) | (bytes[index + 5]! & 0x3f);
+      const code = 0x10000 + ((high - 0xd800) << 10) + (low - 0xdc00);
+      out.push(
+        0xf0 | (code >> 18),
+        0x80 | ((code >> 12) & 0x3f),
+        0x80 | ((code >> 6) & 0x3f),
+        0x80 | (code & 0x3f),
+      );
+      index += 5;
+      continue;
+    }
+    out.push(bytes[index]!);
+  }
+  return out;
+}
+
 export function escapeBytes(bytes: readonly number[]): string {
   return bytes
     .map((byte) => {

package/src/diagnostics/diagnostic.ts

@@ -20,6 +20,7 @@ export enum DiagnosticCode {
   InvalidAssignmentTarget = 2005,
   DuplicateDefault = 2006,
   InvalidTypeSyntax = 2007,
+  NestingTooDeep = 2008,
 
   // Binder 3xxx
   DuplicateIdentifier = 3001,
@@ -42,6 +43,7 @@ export enum DiagnosticCode {
   IOError = 6002,
   ToolchainError = 6003,
   IncrementalCacheError = 6004,
+  CircularDependency = 6005,
 }
 
 export interface Diagnostic {
@@ -119,9 +121,27 @@ export function formatDiagnostic(d: Diagnostic, source?: SourceFile): string {
     const lineText = source.text.split("\n")[line - 1] ?? "";
     const end = d.end ?? d.start;
     const endCol = source.positionAt(end).column;
-    const caretPad = " ".repeat(Math.max(0, column - 1));
-    const caret = "^".repeat(Math.max(1, endCol - column));
-    excerpt = `\n${lineText}\n${caretPad}${caret}`;
+
+    /* Long lines (a minified bundle, a generated one-liner, deeply nested
+     * source) would otherwise print tens of thousands of characters and make
+     * the actual message impossible to find. Keep a window around the caret. */
+    const maxExcerpt = 160;
+    const caretIndex = Math.max(0, column - 1);
+    let windowStart = 0;
+    let windowEnd = lineText.length;
+    if (lineText.length > maxExcerpt) {
+      windowStart = Math.max(0, caretIndex - Math.floor(maxExcerpt / 2));
+      windowEnd = Math.min(lineText.length, windowStart + maxExcerpt);
+      if (windowEnd === lineText.length) windowStart = Math.max(0, windowEnd - maxExcerpt);
+    }
+    const prefix = windowStart > 0 ? "\u2026" : "";
+    const suffix = windowEnd < lineText.length ? "\u2026" : "";
+    const visible = lineText.slice(windowStart, windowEnd);
+    const visibleCaret = caretIndex - windowStart;
+    const caretWidth = Math.max(1, Math.min(endCol - column, visible.length - visibleCaret));
+    const caretPad = " ".repeat(prefix.length + Math.max(0, visibleCaret));
+    const caret = "^".repeat(caretWidth);
+    excerpt = `\n${prefix}${visible}${suffix}\n${caretPad}${caret}`;
   }
   return `${location} - ${severity} TS${d.code}: ${d.message}${excerpt}`;
 }

package/src/driver/app-artifacts.ts

@@ -0,0 +1,77 @@
+/**
+ * Platform artifacts that turn a linked program into a desktop application:
+ * the Windows-subystem entry shim, the embedded icon object and the Windows PE
+ * icon resource.
+ *
+ * They are collected separately from the link call so icon/GUI/package work
+ * has a home of its own instead of growing `build`.
+ */
+
+import type { ExtensionRegistry } from "../extensions/registry.js";
+import { ensureIconObject, EMPTY_ICON, IconError, type IconInfo } from "./icon.js";
+import { ensureWindowsEntryObject } from "./win-entry.js";
+import { ensureWindowsIconResource, resolveResourceCompiler } from "./win-icon.js";
+import type { AppConfig } from "./config.js";
+import type { Runner } from "./toolchain.js";
+
+export interface AppArtifactRequest {
+  readonly runner: Runner;
+  readonly clang: string;
+  readonly cacheDir: string;
+  readonly registry: ExtensionRegistry;
+  readonly app: AppConfig;
+  readonly icon: IconInfo | undefined;
+  readonly env: Record<string, string>;
+  readonly verbose: boolean | undefined;
+}
+
+export interface AppArtifacts {
+  /** Windows-subsystem entry shim, when the program is a GUI app. */
+  readonly entryObject?: string;
+  readonly iconObjects: readonly string[];
+  /** Extra linker flags implied by the subsystem (empty on other platforms). */
+  readonly linkerFlags: readonly string[];
+  /** Set when the icon could not be embedded; the caller reports it. */
+  readonly iconError?: string;
+}
+
+/**
+ * Build the objects (and flags) that accompany the program object.
+ *
+ * On Windows a GUI program links as a **Windows-subsystem** executable, so
+ * launching it does not flash a console window. That subsystem's C runtime
+ * wants `WinMain`, so a tiny shim object bridges it to the runtime's `main`.
+ * `app.console: true` keeps the console subsystem instead (useful while
+ * debugging, because stdout and stderr only exist there). Other platforms have
+ * no equivalent.
+ */
+export function ensureAppArtifacts(request: AppArtifactRequest): AppArtifacts {
+  const { runner, clang, cacheDir, registry, app, icon, env, verbose } = request;
+  const windowsSubsystem = process.platform === "win32" && registry.has("gui") && app.console !== true;
+  const linkerFlags = windowsSubsystem ? ["-Wl,/SUBSYSTEM:WINDOWS"] : [];
+  const entryObject = windowsSubsystem
+    ? ensureWindowsEntryObject(runner, clang, cacheDir, env)
+    : undefined;
+
+  const iconObjects: string[] = [];
+  // The GUI extension references the icon symbols unconditionally, so a GUI
+  // program gets an (empty) icon object even with no icon configured.
+  if (icon !== undefined || registry.has("gui")) {
+    try {
+      iconObjects.push(ensureIconObject(runner, clang, cacheDir, icon ?? EMPTY_ICON, env));
+      if (icon && process.platform === "win32") {
+        const resourceCompiler = resolveResourceCompiler(runner, clang);
+        if (resourceCompiler) {
+          iconObjects.push(ensureWindowsIconResource(runner, cacheDir, icon, resourceCompiler, env));
+        } else if (verbose) {
+          process.stderr.write("xbintsc: no llvm-rc found; skipping the embedded .exe icon\n");
+        }
+      }
+    } catch (error) {
+      if (error instanceof IconError) return { entryObject, iconObjects, linkerFlags, iconError: error.message };
+      throw error;
+    }
+  }
+
+  return { entryObject, iconObjects, linkerFlags };
+}

package/src/driver/build-key.ts

@@ -0,0 +1,55 @@
+/**
+ * The incremental-cache key.
+ *
+ * Everything that can change the produced binary belongs here: compiler
+ * version, source text, emit kind, optimization/LTO/PGO mode, platform,
+ * extension and runtime fingerprints, and the embedded application metadata.
+ * A feature that adds such an input edits this module (and the call site),
+ * not the build orchestration.
+ */
+
+import type { ExtensionRegistry } from "../extensions/registry.js";
+import { hashParts } from "./cache.js";
+import type { AppConfig } from "./config.js";
+import { compilerFingerprint, registryFingerprint, runtimeFingerprint } from "./fingerprint.js";
+import { COMPILER_VERSION } from "./version.js";
+import type { IconInfo } from "./icon.js";
+import type { PgoMode } from "./toolchain.js";
+
+export interface CacheKeyInput {
+  /** The text the build compiled: the entry source, or the bundled module text. */
+  readonly sourceText: string;
+  readonly emit: string;
+  readonly optimize: string;
+  readonly registry: ExtensionRegistry;
+  readonly runtimeDir: string;
+  readonly icon?: IconInfo;
+  readonly app: AppConfig;
+  readonly debug: boolean;
+  readonly lto: boolean;
+  readonly pgo?: PgoMode;
+  readonly pgoDir: string;
+}
+
+/** Hash every input that can change the produced binary. */
+export function buildCacheKey(input: CacheKeyInput): string {
+  const { app, icon, pgo } = input;
+  return hashParts([
+    COMPILER_VERSION,
+    compilerFingerprint(),
+    input.sourceText,
+    input.emit,
+    input.optimize,
+    process.platform,
+    registryFingerprint(input.registry),
+    runtimeFingerprint(input.runtimeDir),
+    icon ? hashParts(["icon", icon.format, Buffer.from(icon.bytes).toString("base64")]) : "",
+    app.name ?? "",
+    String(app.bundle ?? false),
+    app.bundleId ?? "",
+    String(input.debug),
+    String(input.lto),
+    pgo ?? "",
+    pgo ? input.pgoDir : "",
+  ]);
+}

package/src/driver/bundler/graph.ts

@@ -4,8 +4,8 @@
  */
 
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, extname } from "node:path";
-import { SyntaxKind, type ExportDeclaration, type ImportDeclaration, type Statement } from "../../ast/nodes.js";
+import { dirname, extname, relative } from "node:path";
+import { SyntaxKind, type ExportDeclaration, type ImportDeclaration, type NamedExports, type Statement } from "../../ast/nodes.js";
 import { bind } from "../../binder/binder.js";
 import { DiagnosticBag, DiagnosticCode } from "../../diagnostics/diagnostic.js";
 import { SourceFile } from "../../diagnostics/source.js";
@@ -16,12 +16,47 @@ import { classifyDependency } from "./resolve.js";
 import { collectRequireSites, isNodeModulesPath, usesCommonJS } from "./commonjs.js";
 import type { ModuleRecord } from "./types.js";
 
+/**
+ * True when an import has no runtime binding, so it is not a module edge:
+ * `import type { T } from "..."` or `import { type T } from "..."`. A
+ * side-effect-only import (`import "..."`) and an empty clause
+ * (`import {} from "..."`) both evaluate the module and *are* edges. Types are
+ * erased, so a type-only import must not pull the target into the bundle —
+ * and, in particular, must not turn the mutual `import type` references
+ * between source files into a circular-import error.
+ */
+function isTypeOnlyImport(declaration: ImportDeclaration): boolean {
+  const clause = declaration.importClause;
+  if (!clause) return false;
+  if (clause.isTypeOnly) return true;
+  if (clause.name) return false;
+  const bindings = clause.namedBindings;
+  if (!bindings) return true;
+  if (bindings.kind === SyntaxKind.NamespaceImport) return false;
+  // `import {} from "..."` is an empty clause but still evaluates the module.
+  return bindings.elements.length > 0 && bindings.elements.every((element) => element.isTypeOnly);
+}
+
+/** True when an export declaration only re-exports types. */
+function isTypeOnlyExport(declaration: ExportDeclaration): boolean {
+  if (declaration.isTypeOnly) return true;
+  const clause = declaration.exportClause;
+  if (!clause || clause.kind !== SyntaxKind.NamedExports) return false;
+  const elements = (clause as NamedExports).elements;
+  // `export {} from "..."` is a side-effect re-export, not a type-only one.
+  return elements.length > 0 && elements.every((element) => element.isTypeOnly);
+}
+
 function moduleSpecifierOf(statement: Statement): string | undefined {
   if (statement.kind === SyntaxKind.ImportDeclaration) {
-    return (statement as ImportDeclaration).moduleSpecifier.value;
+    const declaration = statement as ImportDeclaration;
+    if (isTypeOnlyImport(declaration)) return undefined;
+    return declaration.moduleSpecifier.value;
   }
   if (statement.kind === SyntaxKind.ExportDeclaration) {
-    const specifier = (statement as ExportDeclaration).moduleSpecifier;
+    const declaration = statement as ExportDeclaration;
+    if (isTypeOnlyExport(declaration)) return undefined;
+    const specifier = declaration.moduleSpecifier;
     if (specifier) return specifier.value;
   }
   return undefined;
@@ -36,15 +71,30 @@ export function loadGraph(
 ): ModuleRecord[] | undefined {
   const records = new Map<string, ModuleRecord>();
   const order: ModuleRecord[] = [];
-  const visiting = new Set<string>();
+  /* Modules on the current depth-first path, for cycle reporting. A module is
+   * added to `records` only after its dependencies finish, so a back edge is
+   * still "visiting" when it is reached. */
+  const stack: string[] = [];
   let counter = 0;
   let failed = false;
 
-  const load = (path: string): ModuleRecord | undefined => {
+  const load = (
+    path: string,
+    origin?: { readonly file: string; readonly statement: Statement },
+  ): ModuleRecord | undefined => {
     const existing = records.get(path);
     if (existing) return existing;
-    if (visiting.has(path)) {
-      diagnostics.error(DiagnosticCode.CodegenError, `Circular import detected involving '${path}'`);
+    if (stack.includes(path)) {
+      const start = stack.indexOf(path);
+      const cycle = [...stack.slice(start), path]
+        .map((entry) => relative(dirname(entryPath), entry))
+        .join(" -> ");
+      diagnostics.error(
+        DiagnosticCode.CircularDependency,
+        `Circular import detected: ${cycle}`,
+        origin?.statement,
+        origin?.file,
+      );
       failed = true;
       return undefined;
     }
@@ -53,7 +103,7 @@ export function loadGraph(
       failed = true;
       return undefined;
     }
-    visiting.add(path);
+    stack.push(path);
     const raw = sourceTextBytes(readFileSync(path, "utf8"));
     /* An extension may rewrite an imported asset (e.g. `.html`) into a TS
      * module before it is parsed. The core only sees the transformed text. */
@@ -68,7 +118,7 @@ export function loadGraph(
           error instanceof Error ? error.message : String(error),
         );
         failed = true;
-        visiting.delete(path);
+        stack.pop();
         return undefined;
       }
     }
@@ -90,7 +140,6 @@ export function loadGraph(
     // `require` / `module` / `exports` are only honoured inside `node_modules`,
     // so user code keeps its ESM-only diagnostic.
     record.commonjs = isNodeModulesPath(path) && usesCommonJS(bindResult);
-    records.set(path, record);
 
     for (const statement of sourceFile.statements) {
       const specifier = moduleSpecifierOf(statement);
@@ -107,7 +156,7 @@ export function loadGraph(
         failed = true;
         continue;
       }
-      load(dependency.path);
+      load(dependency.path, { file: path, statement });
     }
 
     // A CommonJS module's `require("...")` calls are dynamic import edges: the
@@ -118,7 +167,8 @@ export function loadGraph(
         if (dependency.kind === "file") load(dependency.path);
       }
     }
-    visiting.delete(path);
+    stack.pop();
+    records.set(path, record);
     order.push(record);
     return record;
   };

package/src/driver/bundler/merge.ts

@@ -77,8 +77,10 @@ export function bundleModules(
     for (const statement of record.sourceFile.statements) {
       if (statement.kind === SyntaxKind.ExportDeclaration) {
         const declaration = statement as ExportDeclaration;
+        if (declaration.isTypeOnly) continue;
         if (declaration.exportClause && declaration.exportClause.kind === SyntaxKind.NamedExports) {
           for (const specifier of declaration.exportClause.elements) {
+            if (specifier.isTypeOnly) continue;
             const localName = specifier.propertyName?.text ?? specifier.name.text;
             const exportedName = specifier.name.text;
             if (declaration.moduleSpecifier) {
@@ -144,7 +146,7 @@ export function bundleModules(
       const declaration = statement as ImportDeclaration;
       const dependency = dependencyOf(record, declaration.moduleSpecifier.value);
       const clause = declaration.importClause;
-      if (!clause || !dependency) continue;
+      if (!clause || clause.isTypeOnly || !dependency) continue;
       if (clause.name) {
         const target = dependency.exports.get("default") ?? dependency.exports.get("default");
         const local = scope.symbols.get(clause.name.text);
@@ -153,6 +155,7 @@ export function bundleModules(
       const bindings = clause.namedBindings;
       if (bindings && bindings.kind === SyntaxKind.NamedImports) {
         for (const specifier of bindings.elements) {
+          if (specifier.isTypeOnly) continue;
           const importedName = specifier.propertyName?.text ?? specifier.name.text;
           const target = dependency.exports.get(importedName);
           const local = scope.symbols.get(specifier.name.text);