xbintsc 0.5.23 → 0.5.32

package/src/cli/help.ts

@@ -0,0 +1,65 @@
+/**
+ * The `--help` text.
+ *
+ * It lives apart from the command dispatch so the executable entry point stays
+ * under the repository's per-file line budget; the text is data, not logic.
+ */
+
+import { CONFIG_FILE_NAME } from "../driver/config.js";
+import { COMPILER_VERSION } from "../driver/version.js";
+
+export const HELP = `xbintsc ${COMPILER_VERSION} - TypeScript binary compiler
+
+Usage:
+  xbintsc build <file.ts> [options]   Compile to a native binary
+  xbintsc run <file.ts> [-- args]     Compile and execute
+  xbintsc check <file.ts>             Parse, bind and check without linking
+  xbintsc watch <file.ts> [options]   Rebuild whenever the source tree changes
+  xbintsc emit <file.ts>              Print LLVM IR
+  xbintsc doctor                      Report the resolved toolchain
+  xbintsc version                     Print the version
+  xbintsc help                        Show this message
+
+Options:
+  -o, --output <path>   Output path
+      --out <dir>       Output directory (default: build/)
+      --emit <kind>     exe | obj | ir (default: exe)
+  -O0..-O3              Optimization level (default: -O2)
+      --ext <names>     Comma separated extensions (e.g. node,gui,media)
+      --ext-native <m>  Register a C++/Rust extension from a JSON manifest
+                        (comma separated for several)
+      --config <path>   Use a project config (default: auto-detect
+                        ${CONFIG_FILE_NAME})
+      --no-config       Do not read any project config
+      --icon <path>     Embed an application icon (PNG/ICO/ICNS)
+      --bundle          macOS: also produce a .app bundle
+      --app-name <name> Bundle / display name
+      --app-id <id>     macOS bundle identifier (e.g. com.example.demo)
+      --force           Ignore the incremental cache
+      --verbose         Print progress information
+      --time            Print per-phase build timings
+      --debug           Emit debug info (DWARF/CodeView) and keep frame pointers
+      --check           Run the semantic checker (default)
+      --no-check        Skip the semantic checker; only erase type syntax
+      --lto             Compile program and runtime to LTO bitcode; link with lld
+      --pgo-generate [dir]  Build an instrumented binary writing profiles to dir
+      --pgo-use [dir]   Build with the profiles collected from --pgo-generate
+      --json            Print diagnostics as a JSON array on stdout
+      --no-hints        Do not append the "hint: … see <doc>" line to failures
+
+xbintsc compiles a subset of TypeScript to a native binary. Types are erased;
+only inference-free facts (names, redeclarations, call arity) are checked.
+Node built-ins need --ext node, packages in node_modules are bundled at build
+time, and clang 16+ is required to link.
+
+Installed as a project dependency (npm):
+  npx xbintsc doctor
+  npx xbintsc build <entry.ts> --out build
+  npx xbintsc run <entry.ts>
+The first build compiles the C runtime; later builds reuse the cache.
+
+Docs: doc/ai/README.md (task guide) - doc/ai/language-support.md (subset) -
+doc/ai/troubleshooting.md (failures) - llms.txt (index of every document).
+When installed from npm, these live under node_modules/xbintsc/doc/ and
+node_modules/xbintsc/doc/npm-package.md is the project guide.
+`;

package/src/cli/hints.ts

@@ -173,7 +173,8 @@ export function documentationFor(diagnostic: Diagnostic): DocumentationPointer |
         path: "doc/unimplemented/modules.md",
       };
 
-    // The checker codes are defined but never emitted today.
+    /* TS3001/TS3002 also reach here through the generic subset hint above;
+     * every checker code is emitted now, so they all share this pointer. */
     case DiagnosticCode.TypeMismatch:
     case DiagnosticCode.NotCallable:
     case DiagnosticCode.PropertyNotFound:

package/src/cli/main.ts

@@ -44,6 +44,7 @@ import {
   type ProjectConfig,
 } from "../driver/config.js";
 import { fingerprintTree, startWatching } from "./watch.js";
+import { HELP } from "./help.js";
 
 /** Sentinel: watch mode keeps the process alive instead of exiting. */
 const KEEP_RUNNING = -1;
@@ -238,51 +239,6 @@ function reportConfigError(error: string, io: CliIo): number {
   return 1;
 }
 
-const HELP = `xbintsc ${COMPILER_VERSION} - TypeScript binary compiler
-
-Usage:
-  xbintsc build <file.ts> [options]   Compile to a native binary
-  xbintsc run <file.ts> [-- args]     Compile and execute
-  xbintsc check <file.ts>             Parse and bind without linking
-  xbintsc watch <file.ts> [options]   Rebuild whenever the source tree changes
-  xbintsc emit <file.ts>              Print LLVM IR
-  xbintsc doctor                      Report the resolved toolchain
-  xbintsc version                     Print the version
-  xbintsc help                        Show this message
-
-Options:
-  -o, --output <path>   Output path
-      --out <dir>       Output directory (default: build/)
-      --emit <kind>     exe | obj | ir (default: exe)
-  -O0..-O3              Optimization level (default: -O2)
-      --ext <names>     Comma separated extensions (e.g. node,gui,media)
-      --ext-native <m>  Register a C++/Rust extension from a JSON manifest
-                        (comma separated for several)
-      --config <path>   Use a project config (default: auto-detect
-                        ${CONFIG_FILE_NAME})
-      --no-config       Do not read any project config
-      --icon <path>     Embed an application icon (PNG/ICO/ICNS)
-      --bundle          macOS: also produce a .app bundle
-      --app-name <name> Bundle / display name
-      --app-id <id>     macOS bundle identifier (e.g. com.example.demo)
-      --force           Ignore the incremental cache
-      --verbose         Print progress information
-      --time            Print per-phase build timings
-      --debug           Emit debug info (DWARF/CodeView) and keep frame pointers
-      --lto             Compile program and runtime to LTO bitcode; link with lld
-      --pgo-generate [dir]  Build an instrumented binary writing profiles to dir
-      --pgo-use [dir]   Build with the profiles collected from --pgo-generate
-      --json            Print diagnostics as a JSON array on stdout
-      --no-hints        Do not append the "hint: … see <doc>" line to failures
-
-xbintsc compiles a subset of TypeScript to a native binary. Types are erased
-(never checked), Node built-ins need --ext node, packages in node_modules are
-bundled at build time, and clang 16+ is required to link.
-
-Docs: doc/ai/README.md (task guide) - doc/ai/language-support.md (subset) -
-doc/ai/troubleshooting.md (failures) - llms.txt (index of every document)
-`;
-
 /**
  * Report the resolved toolchain and runtime locations.
  *
@@ -445,9 +401,12 @@ function dispatch(argv: readonly string[], io: CliIo): number {
     const extNames = listFlag(args.flags, "ext") ?? resolved.config.extensions ?? [];
     const nativeManifests = listFlag(args.flags, "ext-native") ?? resolved.config.extNative ?? [];
     const registry = buildRegistry(extNames, nativeManifests);
-    /* Front-end only: parse, bundle and lower far enough to report binder /
-     * unsupported-feature diagnostics, but never invoke clang or write output. */
-    const { diagnostics } = compileEntry(entry, registry);
+    /* Front-end only: parse, bundle, check and lower far enough to report
+     * semantic / unsupported-feature diagnostics, but never invoke clang or
+     * write output. The checker is on unless `--no-check` is passed. */
+    const { diagnostics } = compileEntry(entry, registry, {
+      check: !args.flags.has("no-check"),
+    });
     const failed = diagnostics.some((diagnostic) => diagnostic.category === "error");
     if (args.flags.has("json")) {
       io.stdout(`${JSON.stringify(diagnostics)}\n`);
@@ -496,7 +455,10 @@ function dispatch(argv: readonly string[], io: CliIo): number {
     const extNames = listFlag(args.flags, "ext") ?? resolved.config.extensions ?? [];
     const nativeManifests = listFlag(args.flags, "ext-native") ?? resolved.config.extNative ?? [];
     const registry = buildRegistry(extNames, nativeManifests);
-    const { ir, diagnostics } = compileEntry(entry, registry, { debug: Boolean(args.flags.get("debug")) });
+    const { ir, diagnostics } = compileEntry(entry, registry, {
+      debug: Boolean(args.flags.get("debug")),
+      check: !args.flags.has("no-check"),
+    });
     if (diagnostics.some((d) => d.category === "error")) {
       if (args.flags.has("json")) {
         io.stdout(`${JSON.stringify(diagnostics)}\n`);
@@ -554,6 +516,7 @@ function dispatch(argv: readonly string[], io: CliIo): number {
       extensions: registry,
       app: mergeAppConfig(args.flags, config),
       debug: Boolean(args.flags.get("debug")),
+      check: !args.flags.has("no-check"),
       lto: Boolean(args.flags.get("lto")) || config.lto === true,
       ...(pgo ? { pgo } : {}),
       ...(pgoDir ? { pgoDir } : {}),

package/src/codegen/generator/calls/access.ts

@@ -14,6 +14,7 @@ import {
 } from "../../../ast/nodes.js";
 import { i64, numberLiteral, XT_TRUE, XT_UNDEFINED } from "../../values.js";
 import { MATH_CONSTANTS, NAMESPACE_PROPERTIES, NUMBER_CONSTANTS, SYMBOL_WELL_KNOWN, TYPED_ARRAYS } from "../tables.js";
+import { isSuperKeyword } from "./super.js";
 import type { Generator } from "../generator.js";
 
 export interface AccessCallMethods {
@@ -50,12 +51,8 @@ export const accessCallMethods: AccessCallMethods = {
   },
 
   emitPropertyAccess(node: PropertyAccessExpression): string {
-    if (node.expression.kind === SyntaxKind.Identifier && (node.expression as Identifier).text === "super") {
-      const thisValue = this.emitThis();
-      const proto = this.reg();
-      this.emit(`  ${proto} = call i64 @xt_object_get_prototype(i64 ${thisValue})`);
-      const parentProto = this.reg();
-      this.emit(`  ${parentProto} = call i64 @xt_object_get_prototype(i64 ${proto})`);
+    if (isSuperKeyword(node.expression)) {
+      const parentProto = this.emitSuperHolder();
       const key = this.stringValue(node.name.text);
       const value = this.reg();
       this.emit(`  ${value} = call i64 @xt_get(i64 ${parentProto}, i64 ${key})`);
@@ -139,13 +136,16 @@ export const accessCallMethods: AccessCallMethods = {
   },
 
   emitElementAccess(node: ElementAccessExpression): string {
-    const object = this.emitExpression(node.expression);
+    /* `super[key]` reads from the parent prototype (or the parent constructor
+     * inside a `static` method), not from the `super` keyword itself. */
+    const isSuper = isSuperKeyword(node.expression);
+    const object = isSuper ? this.emitSuperHolder() : this.emitExpression(node.expression);
     const access = (): string => {
       const key = this.emitExpression(node.argumentExpression);
       const result = this.reg();
       /* Array-index reads are not object property layouts, so skip the IC for
        * a numeric literal; every other key may benefit from it. */
-      if (node.argumentExpression.kind === SyntaxKind.NumericLiteral) {
+      if (isSuper || node.argumentExpression.kind === SyntaxKind.NumericLiteral) {
         this.emit(`  ${result} = call i64 @xt_get(i64 ${object}, i64 ${key})`);
       } else {
         const cache = this.icCachePointer();

package/src/codegen/generator/calls/invocation.ts

@@ -24,6 +24,7 @@ import {
   MATH_FUNCTIONS,
   NAMESPACE_STATICS,
 } from "../tables.js";
+import { isSuperKeyword } from "./super.js";
 import type { Generator } from "../generator.js";
 
 export interface InvocationCallMethods {
@@ -72,9 +73,7 @@ export const invocationCallMethods: InvocationCallMethods = {
       const access = callee as PropertyAccessExpression;
       const special = this.tryEmitBuiltinCall(node, access);
       if (special) return special;
-      if (access.expression.kind === SyntaxKind.Identifier && (access.expression as Identifier).text === "super") {
-        return this.emitSuperCall(node, access);
-      }
+      if (isSuperKeyword(access.expression)) return this.emitSuperCall(node, access);
       const object = this.emitExpression(access.expression);
       const name = this.stringValue(access.name.text);
       const args = this.emitArguments(node.arguments);
@@ -84,6 +83,7 @@ export const invocationCallMethods: InvocationCallMethods = {
     }
     if (callee.kind === SyntaxKind.ElementAccessExpression) {
       const access = callee as ElementAccessExpression;
+      if (isSuperKeyword(access.expression)) return this.emitSuperElementCall(node, access);
       const object = this.emitExpression(access.expression);
       const name = this.emitExpression(access.argumentExpression);
       const args = this.emitArguments(node.arguments);
@@ -111,8 +111,11 @@ export const invocationCallMethods: InvocationCallMethods = {
         const fn = declaration ? this.binding.functionOfNode.get(declaration) : undefined;
         /* Generator and `async` functions are not called directly: the call
          * must create a suspended generator / start a coroutine, so fall
-         * through to the closure-call path. */
-        if (fn && !fn.isGenerator && !fn.isAsync) {
+         * through to the closure-call path. The same applies to a function that
+         * captures outer bindings (or `this`): the direct call passes no
+         * environment, so its free variables would read `undefined` and writes
+         * to them would be lost. */
+        if (fn && !fn.isGenerator && !fn.isAsync && fn.captures.length === 0 && !fn.capturesThis) {
           const args = this.emitArguments(node.arguments);
           const result = this.reg();
           this.emit(

package/src/codegen/generator/calls/super.ts

@@ -3,14 +3,29 @@
  */
 
 import {
+  SyntaxKind,
   type CallExpression,
+  type ElementAccessExpression,
+  type Expression,
+  type Identifier,
   type PropertyAccessExpression,
 } from "../../../ast/nodes.js";
 import type { Generator } from "../generator.js";
 
+/** True when `node` is the `super` keyword (it never binds to a symbol). */
+export function isSuperKeyword(node: Expression): boolean {
+  return node.kind === SyntaxKind.Identifier && (node as Identifier).text === "super";
+}
+
 export interface SuperCallMethods {
   emitSuperConstructor(this: Generator, node: CallExpression): string;
   emitSuperCall(this: Generator, node: CallExpression, access: PropertyAccessExpression): string;
+  /** `super[key](...)`: look the method up on the parent holder and call it
+   *  with the current `this`. */
+  emitSuperElementCall(this: Generator, node: CallExpression, access: ElementAccessExpression): string;
+  /** The object `super.x` reads from: the parent prototype for an instance
+   * method, the parent constructor for a `static` method or static block. */
+  emitSuperHolder(this: Generator): string;
 }
 
 export const superCallMethods: SuperCallMethods = {
@@ -28,8 +43,16 @@ export const superCallMethods: SuperCallMethods = {
       );
       return result;
     }
+    /* The parent prototype is decided by the *class* whose constructor is
+     * running, never by walking `this`: an instance of a subclass sits at the
+     * bottom of a longer chain, so `getPrototype(getPrototype(this))` from a
+     * base constructor resolves to that very class again (`C extends B extends
+     * A`: inside `B`, the walk answers `B.prototype`) and `super()` recurses
+     * forever. `getPrototype(getPrototype(C))` is `C.prototype`'s parent, which
+     * is what the heritage clause installed. */
+    const owner = classInfo ? this.emitClassReference(classInfo) : thisValue;
     const proto = this.reg();
-    this.emit(`  ${proto} = call i64 @xt_object_get_prototype(i64 ${thisValue})`);
+    this.emit(`  ${proto} = call i64 @xt_function_get_prototype(i64 ${owner})`);
     const parentProto = this.reg();
     this.emit(`  ${parentProto} = call i64 @xt_object_get_prototype(i64 ${proto})`);
     const key = this.stringValue("__ctor");
@@ -43,10 +66,7 @@ export const superCallMethods: SuperCallMethods = {
 
   emitSuperCall(node: CallExpression, access: PropertyAccessExpression): string {
     const thisValue = this.emitThis();
-    const proto = this.reg();
-    this.emit(`  ${proto} = call i64 @xt_object_get_prototype(i64 ${thisValue})`);
-    const parentProto = this.reg();
-    this.emit(`  ${parentProto} = call i64 @xt_object_get_prototype(i64 ${proto})`);
+    const parentProto = this.emitSuperHolder();
     const key = this.stringValue(access.name.text);
     const method = this.reg();
     this.emit(`  ${method} = call i64 @xt_get(i64 ${parentProto}, i64 ${key})`);
@@ -55,4 +75,46 @@ export const superCallMethods: SuperCallMethods = {
     this.emit(`  ${result} = call i64 @xt_call_with_this(i64 ${method}, i64 ${thisValue}, i32 ${args.argc}, i64* ${args.ptr})`);
     return result;
   },
+
+  emitSuperElementCall(node: CallExpression, access: ElementAccessExpression): string {
+    const thisValue = this.emitThis();
+    const parentProto = this.emitSuperHolder();
+    const key = this.emitExpression(access.argumentExpression);
+    const method = this.reg();
+    this.emit(`  ${method} = call i64 @xt_get(i64 ${parentProto}, i64 ${key})`);
+    const args = this.emitArguments(node.arguments);
+    const result = this.reg();
+    this.emit(`  ${result} = call i64 @xt_call_with_this(i64 ${method}, i64 ${thisValue}, i32 ${args.argc}, i64* ${args.ptr})`);
+    return result;
+  },
+
+  emitSuperHolder(): string {
+    /* Same reasoning as `emitSuperConstructor`: the holder is a property of the
+     * *class*, not of the receiver. Walking `this` would resolve `super.foo()`
+     * inside a base method to the receiver's own prototype, so a subclass
+     * instance would call the override it was trying to bypass. */
+    const classInfo = this.current.fn.classInfo;
+    if (classInfo) {
+      const owner = this.emitClassReference(classInfo);
+      /* A static context has the constructor as `this`, and its own prototype
+       * already is the parent constructor (static inheritance). */
+      if (this.current.fn.isStatic) {
+        const parentCtor = this.reg();
+        this.emit(`  ${parentCtor} = call i64 @xt_object_get_prototype(i64 ${owner})`);
+        return parentCtor;
+      }
+      const ownProto = this.reg();
+      this.emit(`  ${ownProto} = call i64 @xt_function_get_prototype(i64 ${owner})`);
+      const parentProto = this.reg();
+      this.emit(`  ${parentProto} = call i64 @xt_object_get_prototype(i64 ${ownProto})`);
+      return parentProto;
+    }
+    const thisValue = this.emitThis();
+    const holder = this.reg();
+    this.emit(`  ${holder} = call i64 @xt_object_get_prototype(i64 ${thisValue})`);
+    if (this.current.fn.isStatic) return holder;
+    const parentProto = this.reg();
+    this.emit(`  ${parentProto} = call i64 @xt_object_get_prototype(i64 ${holder})`);
+    return parentProto;
+  },
 };

package/src/codegen/generator/context.ts

@@ -14,6 +14,7 @@ import { i64, XT_UNDEFINED } from "../values.js";
 import type {
   BuiltinFunction,
   ExtensionModule,
+  GlobalValue,
   ModuleExport,
   ModuleExports,
 } from "../../extensions/registry.js";
@@ -25,6 +26,8 @@ export class GeneratorContext {
   readonly sourceFile: SourceFileNode;
   readonly diagnostics: DiagnosticBag;
   readonly builtins: Readonly<Record<string, BuiltinFunction>>;
+  /** Extension-provided global values, read through a nullary runtime getter. */
+  readonly globalValues: Readonly<Record<string, GlobalValue>>;
   readonly modules: Readonly<Record<string, ExtensionModule>>;
   /** Module specifier -> extension name for known but unregistered extensions. */
   readonly moduleHints: Readonly<Record<string, string>>;
@@ -85,17 +88,31 @@ export class GeneratorContext {
   debugUnit?: string;
   debugFlags: string[] = [];
   debugSubroutineType?: string;
+  /** True when the checker already reported unresolved names (see `generate`). */
+  readonly check: boolean;
   current!: FunctionState;
 
-  constructor(sourceFile: SourceFileNode, diagnostics: DiagnosticBag, options: CodegenOptions = {}) {
+  /**
+   * `binding` is passed by `generate`, which binds once and runs the checker on
+   * the same symbol table. It stays optional so a direct construction still
+   * works for tests and embedders.
+   */
+  constructor(
+    sourceFile: SourceFileNode,
+    diagnostics: DiagnosticBag,
+    options: CodegenOptions = {},
+    binding?: BindResult,
+  ) {
     this.sourceFile = sourceFile;
     this.diagnostics = diagnostics;
-    this.binding = bind(sourceFile);
+    this.binding = binding ?? bind(sourceFile);
     this.builtins = options.builtins ?? {};
+    this.globalValues = options.globalValues ?? {};
     this.modules = options.modules ?? {};
     this.moduleHints = options.moduleHints ?? {};
     this.target = options.target ?? { platform: process.platform, arch: process.arch };
     this.debug = options.debug === true;
+    this.check = options.check !== false;
     this.resolveImports();
   }
 
@@ -346,31 +363,30 @@ export class GeneratorContext {
   declareSlot(symbol: SymbolInfo, initial: string): void {
     const globalName = this.moduleGlobals.get(symbol.id);
     if (globalName) {
+      let boxed = initial;
       if (symbol.boxed) {
-        const box = this.reg();
-        this.emit(`  ${box} = call i64 @xt_box_new(i64 ${initial})`);
-        this.emit(`  store i64 ${box}, i64* ${globalName}`);
-      } else {
-        this.emit(`  store i64 ${initial}, i64* ${globalName}`);
+        boxed = this.reg();
+        this.emit(`  ${boxed} = call i64 @xt_box_new(i64 ${initial})`);
       }
+      this.emit(`  store i64 ${boxed}, i64* ${globalName}`);
       this.current.slots.set(symbol.id, { ptr: globalName, boxed: symbol.boxed });
       return;
     }
     const ptr = this.alloca();
+    let stored = initial;
     if (symbol.boxed) {
-      const box = this.reg();
-      this.emit(`  ${box} = call i64 @xt_box_new(i64 ${initial})`);
-      this.emit(`  store i64 ${box}, i64* ${ptr}`);
-    } else {
-      this.emit(`  store i64 ${initial}, i64* ${ptr}`);
+      stored = this.reg();
+      this.emit(`  ${stored} = call i64 @xt_box_new(i64 ${initial})`);
     }
+    this.emit(`  store i64 ${stored}, i64* ${ptr}`);
     this.current.slots.set(symbol.id, { ptr, boxed: symbol.boxed });
   }
 
+  /** Bind a capture: the environment carries the symbol's box, so reads and
+   *  writes inside the closure see the enclosing binding. */
   defineCaptureSlot(symbol: SymbolInfo, box: string): void {
     const ptr = this.alloca();
     this.emit(`  store i64 ${box}, i64* ${ptr}`);
-    // A captured symbol is always boxed; the environment holds the box.
     this.current.slots.set(symbol.id, { ptr, boxed: true });
   }
 
@@ -577,10 +593,6 @@ function requireSpecifier(node: Node): string | undefined {
 
 /** A bare module specifier (`fs`, `node:fs`, `@scope/pkg`), not a file path. */
 function isBareSpecifier(specifier: string): boolean {
-  return (
-    !specifier.startsWith(".") &&
-    !specifier.startsWith("/") &&
-    !specifier.startsWith("\\") &&
-    !/^[A-Za-z]:[\\/]/.test(specifier)
-  );
+  const relative = [".", "/", "\\"].some((prefix) => specifier.startsWith(prefix));
+  return !relative && !/^[A-Za-z]:[\\/]/.test(specifier);
 }

package/src/codegen/generator/debug.ts

@@ -12,6 +12,7 @@
 
 import type { Node } from "../../ast/nodes.js";
 import type { FunctionInfo } from "../../binder/binder.js";
+import { artifactPath } from "../../canonical.js";
 import { escapeBytes, utf8Bytes } from "./tables.js";
 import type { Generator } from "./generator.js";
 
@@ -71,7 +72,7 @@ export const debugMethods: DebugMethods = {
   },
 
   debugFileFor(fileName) {
-    const normalized = fileName.split("\\").join("/");
+    const normalized = artifactPath(fileName);
     const existing = this.debugFiles.get(normalized);
     if (existing) return existing;
     const slash = normalized.lastIndexOf("/");

package/src/codegen/generator/expressions/primary.ts

@@ -20,6 +20,7 @@ import {
   type PostfixUnaryExpression,
   type PrefixUnaryExpression,
   type PropertyAccessExpression,
+  type SequenceExpression,
   type TaggedTemplateExpression,
   type TemplateLiteral,
   type YieldExpression,
@@ -28,12 +29,20 @@ import {
 import { SymbolKind, type SymbolInfo } from "../../../binder/binder.js";
 import { DiagnosticCode } from "../../../diagnostics/diagnostic.js";
 import { i64, numberLiteral, XT_FALSE, XT_NULL, XT_TRUE, XT_UNDEFINED } from "../../values.js";
-import { BUILTIN_FUNCTION_VALUES, CTOR_FUNCTIONS, ERROR_CONSTRUCTORS, FIRST_CLASS_CONSTRUCTORS } from "../tables.js";
+import {
+  BUILTIN_FUNCTION_VALUES,
+  CTOR_FUNCTIONS,
+  ERROR_CONSTRUCTORS,
+  FIRST_CLASS_CONSTRUCTORS,
+  NAMESPACE_VALUES,
+} from "../tables.js";
+import type { GlobalValue } from "../../../extensions/registry.js";
 import type { Generator } from "../generator.js";
 
 export interface PrimaryExpressionMethods {
   emitExpression(this: Generator, node: Expression): string;
   emitIdentifier(this: Generator, identifier: Identifier): string;
+  emitGlobalValue(this: Generator, value: GlobalValue): string;
   emitFunctionValue(this: Generator, symbol: SymbolInfo): string;
   emitTemplate(this: Generator, node: TemplateLiteral): string;
   emitTaggedTemplate(this: Generator, node: TaggedTemplateExpression): string;
@@ -41,6 +50,7 @@ export interface PrimaryExpressionMethods {
   emitNew(this: Generator, node: NewExpression): string;
   emitAwait(this: Generator, node: AwaitExpression): string;
   emitYield(this: Generator, node: YieldExpression): string;
+  emitSequence(this: Generator, node: SequenceExpression): string;
 }
 
 export const primaryExpressionMethods: PrimaryExpressionMethods = {
@@ -135,6 +145,8 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
         return this.emitPostfix(node as PostfixUnaryExpression);
       case SyntaxKind.ConditionalExpression:
         return this.emitConditional(node as ConditionalExpression);
+      case SyntaxKind.SequenceExpression:
+        return this.emitSequence(node as SequenceExpression);
       case SyntaxKind.CallExpression:
         return this.emitCall(node as CallExpression);
       case SyntaxKind.PropertyAccessExpression:
@@ -218,6 +230,21 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
         return rest;
       }
       default: {
+        const namespaceValue = NAMESPACE_VALUES[identifier.text];
+        if (namespaceValue) {
+          /* `Math` is a namespace at call sites (`Math.max(a, b)` becomes
+           * `xt_math_call`) and an object as a value: `const cos = Math.cos`,
+           * `const { sqrt, PI } = Math`. */
+          this.extraDeclarations.add(`declare i64 @${namespaceValue}(i32, i64*)`);
+          const result = this.reg();
+          this.emit(`  ${result} = call i64 @${namespaceValue}(i32 0, i64* null)`);
+          return result;
+        }
+        const extensionGlobal = this.globalValues[identifier.text];
+        if (extensionGlobal) {
+          // `window`, `document`, `AudioContext`: a host-provided global value.
+          return this.emitGlobalValue(extensionGlobal);
+        }
         if (FIRST_CLASS_CONSTRUCTORS.has(identifier.text)) {
           // `const A = Array`, `arr.filter(Boolean)`, `new (Map)()`: the
           // constructor is an ordinary function value backed by the runtime.
@@ -249,27 +276,56 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
          * error has already been reported; "Cannot find name '<error>'" is
          * pure noise on top of it. */
         if (identifier.text === "<error>") return i64(XT_UNDEFINED);
-        this.diagnostics.error(
-          DiagnosticCode.CannotFindName,
-          `Cannot find name '${identifier.text}'`,
-          identifier,
-          this.fileNameOf(identifier),
-        );
+        /* The checker runs before code generation and owns this diagnostic
+         * (including the "is it a runtime global?" decision). Keeping the
+         * fallback for `--no-check` avoids reporting the same name twice. */
+        if (!this.check) {
+          this.diagnostics.error(
+            DiagnosticCode.CannotFindName,
+            `Cannot find name '${identifier.text}'`,
+            identifier,
+            this.fileNameOf(identifier),
+          );
+        }
         return i64(XT_UNDEFINED);
       }
     }
   },
 
+  /**
+   * Read an extension-provided global (`window`, `document`, `new Image()`).
+   * The getter is a normal runtime call with the uniform ABI; the optional
+   * argument is how one getter serves a whole family of host types.
+   */
+  emitGlobalValue(value: GlobalValue): string {
+    this.extraDeclarations.add(`declare i64 @${value.symbol}(i32, i64*)`);
+    let argc = "0";
+    let pointer = "i64* null";
+    if (value.argument !== undefined) {
+      const argument = this.stringValue(value.argument);
+      const slot = `%gval${this.current.allocas.length}`;
+      this.current.allocas.push(`${slot} = alloca i64, i32 1`);
+      const cell = this.reg();
+      this.emit(`  ${cell} = getelementptr i64, i64* ${slot}, i32 0`);
+      this.emit(`  store i64 ${argument}, i64* ${cell}`);
+      argc = "1";
+      pointer = `i64* ${slot}`;
+    }
+    const result = this.reg();
+    this.emit(`  ${result} = call i64 @${value.symbol}(i32 ${argc}, ${pointer})`);
+    return result;
+  },
+
   emitFunctionValue(symbol: SymbolInfo): string {
     const declaration = symbol.declarations[0];
     const fn = declaration ? this.binding.functionOfNode.get(declaration) : undefined;
     if (!fn) return i64(XT_UNDEFINED);
-    const cast = this.reg();
-    this.emit(`  ${cast} = bitcast i64 (i64, i64, i32, i64*)* @${this.functionName(fn)} to i8*`);
-    const closure = this.reg();
-    this.emit(`  ${closure} = call i64 @xt_closure_new(i8* ${cast}, i32 0, i64* null)`);
-    this.emitFunctionMetadata(closure, fn);
-    return closure;
+    /* A declared function is a value like any closure: it captures the outer
+     * bindings its body mentions, so build the environment instead of calling
+     * `xt_closure_new` with a null one. A null environment silently turns every
+     * free variable into `undefined` and drops the writes back to the box
+     * (`function bump() { count += 1 }` never advanced `count`). */
+    return this.emitClosureValue(fn);
   },
 
   emitThis(): string {
@@ -299,6 +355,13 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
     return result;
   },
 
+  /** `a, b, c`: evaluate in order for their side effects, yield the last. */
+  emitSequence(node: SequenceExpression): string {
+    let value = i64(XT_UNDEFINED);
+    for (const expression of node.expressions) value = this.emitExpression(expression);
+    return value;
+  },
+
   emitNew(node: NewExpression): string {
     const callee = node.expression;
     // A `new` expression is where the innermost frame's line should point for
@@ -326,6 +389,14 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
           this.emit(`  ${result} = call i64 @${ctor}(i32 ${args.argc}, i64* ${args.ptr})`);
           return result;
         }
+        const extensionConstructor = this.globalValues[identifier.text];
+        if (extensionConstructor) {
+          const ctorValue = this.emitGlobalValue(extensionConstructor);
+          const args = this.emitArguments(node.arguments);
+          const result = this.reg();
+          this.emit(`  ${result} = call i64 @xt_new(i64 ${ctorValue}, i32 ${args.argc}, i64* ${args.ptr})`);
+          return result;
+        }
         if (identifier.text === "Object") {
           if (node.arguments.length > 0) return this.emitExpression(node.arguments[0]!);
           return this.runtimeCall("xt_object_new", []);