xbintsc 0.2.4 → 0.2.6

package/src/codegen/generator/statements.ts

@@ -4,15 +4,19 @@
 
 import {
   SyntaxKind,
+  type ArrayBindingPattern,
+  type BindingName,
   type Block,
   type CaseClause,
   type DoStatement,
+  type EnumDeclaration,
   type Expression,
   type ForInStatement,
   type ForOfStatement,
   type ForStatement,
   type Identifier,
   type IfStatement,
+  type ObjectBindingPattern,
   type ReturnStatement,
   type Statement,
   type SwitchStatement,
@@ -23,12 +27,16 @@ import {
   type WhileStatement,
 } from "../../ast/nodes.js";
 import { i64, numberLiteral, XT_UNDEFINED } from "../values.js";
+import { propertyNameText } from "./tables.js";
 import type { Generator } from "./generator.js";
 
 export interface StatementMethods {
   emitStatements(this: Generator, statements: readonly Statement[]): void;
   emitStatement(this: Generator, statement: Statement): void;
   emitVariableStatement(this: Generator, statement: VariableStatement): void;
+  emitBindingPattern(this: Generator, name: BindingName, value: string): void;
+  emitBindingDefault(this: Generator, value: string, initializer: Expression): string;
+  emitEnum(this: Generator, statement: EnumDeclaration): void;
   emitIf(this: Generator, statement: IfStatement): void;
   emitWhile(this: Generator, statement: WhileStatement): void;
   emitDo(this: Generator, statement: DoStatement): void;
@@ -125,6 +133,9 @@ export const statementMethods: StatementMethods = {
         if (declaration) this.emitStatement(declaration);
         return;
       }
+      case SyntaxKind.EnumDeclaration:
+        this.emitEnum(statement as EnumDeclaration);
+        return;
       default:
         this.unsupported(statement, "statement");
     }
@@ -132,16 +143,130 @@ export const statementMethods: StatementMethods = {
 
   emitVariableStatement(statement: VariableStatement): void {
     for (const declaration of statement.declarationList.declarations) {
-      const symbol = this.binding.symbolOfDeclaration.get(declaration);
-      if (!symbol) continue;
-      if (this.current.slots.has(symbol.id)) continue; // hoisted `var`
-      const initial = declaration.initializer
-        ? this.emitExpression(declaration.initializer)
-        : i64(XT_UNDEFINED);
-      this.declareSlot(symbol, initial);
+      if (declaration.name.kind === SyntaxKind.Identifier) {
+        const symbol = this.binding.symbolOfDeclaration.get(declaration);
+        if (!symbol) {
+          if (declaration.initializer) this.emitExpression(declaration.initializer);
+          continue;
+        }
+        if (this.current.slots.has(symbol.id)) {
+          // Hoisted `var` (or an already-declared slot): keep evaluating the
+          // initializer for its side effects, but do not redeclare the slot.
+          if (declaration.initializer) this.emitExpression(declaration.initializer);
+          continue;
+        }
+        if (symbol.boxed) {
+          // A captured binding lives in a box. Create the box *before*
+          // evaluating the initializer so a self-referencing closure
+          // (`const f = () => f()`) captures the box, not a copy of the
+          // still-uninitialised value.
+          this.declareSlot(symbol, i64(XT_UNDEFINED));
+          if (declaration.initializer) this.writeSlot(symbol, this.emitExpression(declaration.initializer));
+          continue;
+        }
+        const initial = declaration.initializer ? this.emitExpression(declaration.initializer) : i64(XT_UNDEFINED);
+        this.declareSlot(symbol, initial);
+      } else {
+        const initial = declaration.initializer ? this.emitExpression(declaration.initializer) : i64(XT_UNDEFINED);
+        this.emitBindingPattern(declaration.name, initial);
+      }
+    }
+  },
+
+  /** Lower a destructuring binding pattern, declaring each bound identifier. */
+  emitBindingPattern(name: BindingName, value: string): void {
+    if (name.kind === SyntaxKind.Identifier) {
+      const symbol = this.binding.symbolOfDeclaration.get(name);
+      if (!symbol) return;
+      if (this.current.slots.has(symbol.id)) this.writeSlot(symbol, value);
+      else this.declareSlot(symbol, value);
+      return;
+    }
+    if (name.kind === SyntaxKind.ArrayBindingPattern) {
+      const pattern = name as ArrayBindingPattern;
+      for (let index = 0; index < pattern.elements.length; index++) {
+        const element = pattern.elements[index];
+        if (!element) continue;
+        let elementValue: string;
+        if (element.dotDotDotToken) {
+          const startPtr = this.alloca();
+          this.emit(`  store i64 ${numberLiteral(index)}, i64* ${startPtr}`);
+          const sliceName = this.stringValue("slice");
+          elementValue = this.reg();
+          this.emit(`  ${elementValue} = call i64 @xt_call_method(i64 ${value}, i64 ${sliceName}, i32 1, i64* ${startPtr})`);
+        } else {
+          elementValue = this.reg();
+          this.emit(`  ${elementValue} = call i64 @xt_get(i64 ${value}, i64 ${numberLiteral(index)})`);
+        }
+        if (element.initializer) elementValue = this.emitBindingDefault(elementValue, element.initializer);
+        this.emitBindingPattern(element.name, elementValue);
+      }
+      return;
+    }
+    const pattern = name as ObjectBindingPattern;
+    for (const element of pattern.elements) {
+      const key = element.propertyName ?? (element.name.kind === SyntaxKind.Identifier ? element.name : undefined);
+      if (element.dotDotDotToken) {
+        this.unsupported(element, "object rest destructuring");
+        continue;
+      }
+      const keyValue = this.stringValue(key ? propertyNameText(key) : "undefined");
+      let elementValue = this.reg();
+      this.emit(`  ${elementValue} = call i64 @xt_get(i64 ${value}, i64 ${keyValue})`);
+      if (element.initializer) elementValue = this.emitBindingDefault(elementValue, element.initializer);
+      this.emitBindingPattern(element.name, elementValue);
     }
   },
 
+  /** `x = fallback` in a binding pattern: only apply when `x` is `undefined`. */
+  emitBindingDefault(value: string, initializer: Expression): string {
+    const fallback = this.emitExpression(initializer);
+    const isUndefined = this.reg();
+    this.emit(`  ${isUndefined} = call i64 @xt_seq(i64 ${value}, i64 ${i64(XT_UNDEFINED)})`);
+    const truthy = this.reg();
+    this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${isUndefined})`);
+    const condition = this.reg();
+    this.emit(`  ${condition} = icmp ne i32 ${truthy}, 0`);
+    const result = this.reg();
+    this.emit(`  ${result} = select i1 ${condition}, i64 ${fallback}, i64 ${value}`);
+    return result;
+  },
+
+  /**
+   * `enum E { A, B }` (and `const enum`) lowers to a runtime object with both
+   * forward (`E.A`) and reverse (`E[0] === "A"`) numeric mappings.
+   */
+  emitEnum(statement: EnumDeclaration): void {
+    const symbol = this.binding.symbolOfDeclaration.get(statement);
+    const object = this.reg();
+    this.emit(`  ${object} = call i64 @xt_object_new()`);
+    let next = 0;
+    for (const member of statement.members) {
+      const name = propertyNameText(member.name);
+      const key = this.stringValue(name);
+      let value: string;
+      if (member.initializer) {
+        value = this.emitExpression(member.initializer);
+        if (member.initializer.kind === SyntaxKind.NumericLiteral) {
+          const numeric = (member.initializer as { value?: number }).value ?? 0;
+          next = numeric + 1;
+        } else {
+          next++; 
+        }
+      } else {
+        value = numberLiteral(next);
+        next++;
+      }
+      this.emit(`  call i64 @xt_set(i64 ${object}, i64 ${key}, i64 ${value})`);
+      // Reverse mapping (only meaningful for numeric members).
+      if (!member.initializer || member.initializer.kind === SyntaxKind.NumericLiteral) {
+        const reverseKey = this.stringValue(name);
+        this.emit(`  call i64 @xt_set(i64 ${object}, i64 ${value}, i64 ${reverseKey})`);
+      }
+    }
+    if (symbol) this.declareSlot(symbol, object);
+  },
+
   emitIf(statement: IfStatement): void {
     const thenLabel = this.label("if.then");
     const elseLabel = statement.elseStatement ? this.label("if.else") : undefined;
@@ -178,7 +303,6 @@ export const statementMethods: StatementMethods = {
     const nonzero = this.reg();
     this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
     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 });
     this.emitStatement(statement.statement);
@@ -260,7 +384,7 @@ export const statementMethods: StatementMethods = {
     const indexPtr = this.alloca();
     this.emit(`  store i64 ${numberLiteral(0)}, i64* ${indexPtr}`);
     const lengthValue = this.reg();
-    this.emit(`  ${lengthValue} = call i64 @xt_array_length(i64 ${iterable})`);
+    this.emit(`  ${lengthValue} = call i64 @xt_iter_length(i64 ${iterable})`);
 
     const condLabel = this.label("forof.cond");
     const bodyLabel = this.label("forof.body");
@@ -281,7 +405,7 @@ export const statementMethods: StatementMethods = {
 
     this.startBlock(bodyLabel);
     const element = this.reg();
-    this.emit(`  ${element} = call i64 @xt_get(i64 ${iterable}, i64 ${index})`);
+    this.emit(`  ${element} = call i64 @xt_iter_value(i64 ${iterable}, i64 ${index})`);
     this.bindLoopVariable(statement.initializer, element);
     this.current.loops.push({ breakLabel: endLabel, continueLabel: updateLabel, tryDepth: this.current.tryFrames.length });
     this.emitStatement(statement.statement);
@@ -300,7 +424,11 @@ export const statementMethods: StatementMethods = {
     if (initializer.kind === SyntaxKind.VariableDeclarationList) {
       const declaration = initializer.declarations[0];
       if (!declaration) return;
-      const symbol = this.binding.symbolOfDeclaration.get(declaration);
+      if (declaration.name.kind !== SyntaxKind.Identifier) {
+        this.emitBindingPattern(declaration.name, value);
+        return;
+      }
+      const symbol = this.binding.symbolOfDeclaration.get(declaration) ?? this.binding.symbolOfDeclaration.get(declaration.name);
       if (symbol) {
         if (this.current.slots.has(symbol.id)) this.writeSlot(symbol, value);
         else this.declareSlot(symbol, value);

package/src/codegen/generator/tables.ts

@@ -79,6 +79,18 @@ export const GLOBAL_FUNCTIONS: Record<string, string> = {
   Boolean: "xt_boolean_ctor",
 };
 
+/** Global functions that are also usable as first-class values, each mapped to
+ * a runtime trampoline with the closure ABI. */
+export const BUILTIN_FUNCTION_VALUES: Record<string, string> = {
+  parseInt: "xt_builtin_value_parseInt",
+  parseFloat: "xt_builtin_value_parseFloat",
+  isNaN: "xt_builtin_value_isNaN",
+  isFinite: "xt_builtin_value_isFinite",
+  Number: "xt_builtin_value_number",
+  String: "xt_builtin_value_string",
+  Boolean: "xt_builtin_value_boolean",
+};
+
 /** Global namespaces whose static methods map to runtime dispatchers. */
 export const NAMESPACE_STATICS: Record<string, string> = {
   Math: "xt_math_call",
@@ -107,6 +119,7 @@ export const NAMESPACE_STATICS: Record<string, string> = {
 /** 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",
 };
 
 /** Global constructors called as `new X(...)` (all have signature `(i32, i64*)`). */
@@ -116,6 +129,7 @@ export const CTOR_FUNCTIONS: Record<string, string> = {
   Set: "xt_set_ctor",
   Date: "xt_date_ctor",
   RegExp: "xt_regexp_ctor",
+  Error: "xt_error_ctor",
   Promise: "xt_promise_ctor",
   Buffer: "xt_buffer_ctor",
   Readable: "xt_readable_ctor",

package/src/codegen/values.ts

@@ -5,32 +5,101 @@
  * value uses a tag in the high 16 bits plus a 48-bit payload. The compiler
  * emits these constants directly into LLVM IR, so this module (together with
  * runtime/rt.h) is the single source of truth for the representation.
+ *
+ * The constants are written as pre-computed signed 64-bit decimal literals
+ * rather than BigInt expressions, and `numberLiteral` derives the raw bits of a
+ * double with plain arithmetic. That keeps this module free of BigInt and
+ * typed-array APIs so the compiler can be compiled by itself on every platform.
  */
 
-export const XT_TAG_MASK = 0xffff000000000000n;
-export const XT_NUMBER_MASK = 0xfff8000000000000n;
+/** `0xffff000000000000` as a signed i64. */
+export const XT_TAG_MASK = "-281474976710656";
+/** `0xfff8000000000000` as a signed i64. */
+export const XT_NUMBER_MASK = "-2251799813685248";
 
-export const XT_UNDEFINED = 0xfff8000000000000n;
-export const XT_NULL = 0xfff9000000000000n;
-export const XT_FALSE = 0xfffa000000000000n;
-export const XT_TRUE = 0xfffb000000000000n;
-export const XT_STRING = 0xfffc000000000000n;
-export const XT_OBJECT = 0xfffd000000000000n;
-export const XT_ARRAY = 0xfffe000000000000n;
-export const XT_FUNCTION = 0xffff000000000000n;
+export const XT_UNDEFINED = "-2251799813685248"; // 0xfff8000000000000
+export const XT_NULL = "-1970324836974592"; // 0xfff9000000000000
+export const XT_FALSE = "-1688849860263936"; // 0xfffa000000000000
+export const XT_TRUE = "-1407374883553280"; // 0xfffb000000000000
+export const XT_STRING = "-1125899906842624"; // 0xfffc000000000000
+export const XT_OBJECT = "-844424930131968"; // 0xfffd000000000000
+export const XT_ARRAY = "-562949953421312"; // 0xfffe000000000000
+export const XT_FUNCTION = "-281474976710656"; // 0xffff000000000000
 
 /** Render a 64-bit constant the way LLVM expects signed i64 literals. */
-export function i64(value: bigint): string {
-  return BigInt.asIntN(64, value).toString();
+export function i64(value: string): string {
+  return value;
 }
 
 /** The raw 64 bits of an IEEE-754 double, as a signed i64 literal. */
 export function numberLiteral(value: number): string {
-  const view = new DataView(new ArrayBuffer(8));
-  view.setFloat64(0, value);
-  return i64(view.getBigInt64(0));
+  if (value !== value) return "9221120237041090560"; // 0x7ff8000000000000 (NaN)
+  const negative = value < 0 || (value === 0 && 1 / value < 0);
+  const abs = negative ? -value : value;
+  let high: number;
+  let low: number;
+  if (abs === 0) {
+    high = 0;
+    low = 0;
+  } else if (abs === Infinity) {
+    high = 0x7ff00000;
+    low = 0;
+  } else {
+    let exponent = Math.floor(Math.log2(abs));
+    while (exponent < 1023 && Math.pow(2, exponent + 1) <= abs) exponent++;
+    while (exponent > -1022 && Math.pow(2, exponent) > abs) exponent--;
+    let mantissa = Math.round((abs / Math.pow(2, exponent) - 1) * 4503599627370496);
+    let biased = exponent + 1023;
+    if (biased <= 0) {
+      mantissa = Math.round((abs / Math.pow(2, -1022)) * 4503599627370496);
+      biased = 0;
+    } else if (mantissa >= 4503599627370496) {
+      mantissa = 0;
+      biased += 1;
+    }
+    high = biased * 0x100000 + Math.floor(mantissa / 0x100000000);
+    low = mantissa % 0x100000000;
+  }
+  if (negative) high += 0x80000000;
+  return signedDecimal(high >>> 0, low >>> 0);
 }
 
 export function booleanLiteral(value: boolean): string {
-  return i64(value ? XT_TRUE : XT_FALSE);
+  return value ? XT_TRUE : XT_FALSE;
+}
+
+/** Two's-complement (high, low) 32-bit halves as a signed decimal string. */
+function signedDecimal(high: number, low: number): string {
+  if (high >= 0x80000000) {
+    let h = (~high) >>> 0;
+    let l = (~low) >>> 0;
+    l = (l + 1) >>> 0;
+    if (l === 0) h = (h + 1) >>> 0;
+    return "-" + unsignedDecimal(h, l);
+  }
+  return unsignedDecimal(high, low);
+}
+
+/** Unsigned 64-bit `high * 2^32 + low` as a decimal string. */
+function unsignedDecimal(high: number, low: number): string {
+  const digits: number[] = [];
+  let h = high;
+  if (h === 0) digits.push(0);
+  while (h > 0) {
+    digits.push(h % 10);
+    h = Math.floor(h / 10);
+  }
+  let carry = low;
+  for (let i = 0; i < digits.length; i++) {
+    const current = digits[i]! * 4294967296 + carry;
+    digits[i] = current % 10;
+    carry = Math.floor(current / 10);
+  }
+  while (carry > 0) {
+    digits.push(carry % 10);
+    carry = Math.floor(carry / 10);
+  }
+  let out = "";
+  for (let i = digits.length - 1; i >= 0; i--) out += digits[i]!;
+  return out;
 }

package/src/diagnostics/source.ts

@@ -80,15 +80,20 @@ export class SourceFile {
  * and stable across platforms which is exactly what the incremental cache
  * needs. Collision resistance is not a security property here.
  */
-export function hashText(text: string, seed = 0xcbf29ce484222325n): string {
-  let hash = seed;
-  const prime = 0x100000001b3n;
-  const mask = 0xffffffffffffffffn;
+export function hashText(text: string, seed = 0): string {
+  // Two independent 32-bit FNV-1a lanes give a wide, stable fingerprint
+  // without relying on BigInt, which the compiler cannot assume at runtime.
+  let a = (0xcbf29ce4 ^ seed) >>> 0;
+  let b = (0x84222325 ^ seed) >>> 0;
+  const prime = 0x01000193;
   for (let i = 0; i < text.length; i++) {
-    hash ^= BigInt(text.charCodeAt(i));
-    hash = (hash * prime) & mask;
+    const code = text.charCodeAt(i);
+    a = Math.imul(a ^ (code & 0xff), prime) >>> 0;
+    a = Math.imul(a ^ (code >>> 8), prime) >>> 0;
+    b = Math.imul(b ^ (code >>> 8), prime) >>> 0;
+    b = Math.imul(b ^ (code & 0xff), prime) >>> 0;
   }
-  return hash.toString(16).padStart(16, "0");
+  return (a >>> 0).toString(16).padStart(8, "0") + (b >>> 0).toString(16).padStart(8, "0");
 }
 
 /** Combine several hashes/strings into one stable fingerprint. */

package/src/driver/compiler.ts

@@ -7,7 +7,7 @@
  * nothing relevant changed.
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { basename, dirname, extname, join, resolve } from "node:path";
 import { DiagnosticBag, type Diagnostic } from "../diagnostics/diagnostic.js";
 import { SourceFile } from "../diagnostics/source.js";
@@ -73,6 +73,35 @@ export function compileString(source: string, fileName = "input.ts", extensions?
   return { ir, diagnostics: diagnostics.diagnostics };
 }
 
+/**
+ * Compile a file to LLVM IR, bundling every reachable relative module first so
+ * that imports from other TypeScript sources resolve exactly like `build`.
+ */
+export function compileEntry(entryPath: string, extensions?: ExtensionRegistry): CompileStringResult {
+  const absoluteEntry = resolve(entryPath);
+  const sourceText = readFileSync(absoluteEntry, "utf8");
+  const file = new SourceFile(absoluteEntry, sourceText);
+  const diagnostics = new DiagnosticBag();
+  const parser = new Parser(file, diagnostics);
+  let sourceFile = parser.parseSourceFile();
+  const isModule = sourceFile.statements.some(
+    (statement) =>
+      statement.kind === SyntaxKind.ImportDeclaration ||
+      statement.kind === SyntaxKind.ExportDeclaration ||
+      statement.kind === SyntaxKind.ExportAssignment,
+  );
+  if (isModule) {
+    const bundled = bundleModules(absoluteEntry, diagnostics);
+    if (bundled) sourceFile = bundled.sourceFile;
+  }
+  const registry = extensions ?? createDefaultRegistry();
+  const { ir } = generate(sourceFile, diagnostics, {
+    builtins: registry.builtins(),
+    modules: registry.modules(),
+  });
+  return { ir, diagnostics: diagnostics.diagnostics };
+}
+
 function executableName(entry: string, outDir: string, explicit: string | undefined): string {
   if (explicit) return resolve(explicit);
   const base = basename(entry, extname(entry));
@@ -217,9 +246,22 @@ function ensureRuntimeObjects(
   cacheDir: string,
   registry: ExtensionRegistry,
 ): RuntimeObjects {
+  /* Runtime objects depend on the shared headers (rt.h/rt_internal.h/...),
+     so a header change must invalidate every cached object. Hash them all. */
+  const headerParts: string[] = [];
+  const collectHeaders = (dir: string): void => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) collectHeaders(full);
+      else if (entry.name.endsWith(".h")) headerParts.push(readFileSync(full, "utf8"));
+    }
+  };
+  collectHeaders(runtimeDir);
+  const headerStamp = hashParts(headerParts);
+
   const compileOne = (sourcePath: string, tag: string): string => {
     const body = readFileSync(sourcePath, "utf8");
-    const key = hashParts(["runtime", COMPILER_VERSION, tag, body, clang, process.platform]);
+    const key = hashParts(["runtime", COMPILER_VERSION, tag, headerStamp, body, clang, process.platform]);
     const objectPath = join(cacheDir, `${tag}-${key}.o`);
     if (!existsSync(objectPath)) {
       compileC(runner, clang, sourcePath, objectPath, runtimeDir);

package/src/driver/modules.ts

@@ -65,6 +65,18 @@ function isExternalSpecifier(specifier: string): boolean {
 
 function resolveModule(fromDir: string, specifier: string): string | undefined {
   const base = resolve(fromDir, specifier);
+  // TypeScript sources are imported using their emitted `.js` extension
+  // (`import ... from "./foo.js"`), so map the extension back to the source
+  // file before probing the usual suffixes.
+  const candidates = [base];
+  const jsExtension = /\.(?:m|c)?jsx?$/.exec(base);
+  if (jsExtension) {
+    const stem = base.slice(0, jsExtension.index);
+    candidates.push(`${stem}.ts`, `${stem}.tsx`, `${stem}.mts`, `${stem}.cts`);
+  }
+  for (const candidate of candidates) {
+    if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
+  }
   for (const suffix of RESOLVE_SUFFIXES) {
     const candidate = base + suffix;
     if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
@@ -86,8 +98,10 @@ function declarationName(node: Node): Identifier | undefined {
     case SyntaxKind.TypeAliasDeclaration:
     case SyntaxKind.ModuleDeclaration:
       return (node as { name?: Identifier }).name;
-    case SyntaxKind.VariableDeclaration:
-      return (node as VariableDeclaration).name;
+    case SyntaxKind.VariableDeclaration: {
+      const name = (node as VariableDeclaration).name;
+      return name.kind === SyntaxKind.Identifier ? name : undefined;
+    }
     default:
       return undefined;
   }
@@ -349,7 +363,7 @@ function exportedNames(statement: Statement): string[] {
   const names: string[] = [];
   if (statement.kind === SyntaxKind.VariableStatement) {
     for (const declaration of (statement as VariableStatement).declarationList.declarations) {
-      if (declaration.name) names.push(declaration.name.text);
+      collectBindingIdentifiers(declaration.name, names);
     }
   } else {
     const name = declarationName(statement);
@@ -358,6 +372,17 @@ function exportedNames(statement: Statement): string[] {
   return names;
 }
 
+function collectBindingIdentifiers(name: import("../ast/declarations.js").BindingName, out: string[]): void {
+  if (name.kind === SyntaxKind.Identifier) {
+    out.push(name.text);
+    return;
+  }
+  const elements = name.kind === SyntaxKind.ArrayBindingPattern ? name.elements : name.elements;
+  for (const element of elements) {
+    if (element) collectBindingIdentifiers(element.name, out);
+  }
+}
+
 /** Turn `export default expr` into a synthetic `const` declaration. */
 function exportAssignmentToStatement(record: ModuleRecord, assignment: ExportAssignment): Statement {
   const name: Identifier = {

package/src/extensions/node/child_process/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Node's `child_process` module: `spawnSync(command, args, options)`, backed by
+ * `runtime/ext_node/child_process`. Captures stdout/stderr as UTF-8 strings and
+ * honours `options.cwd`, which is all the compiler's toolchain wrapper needs.
+ */
+
+import type { NodeModule } from "../module.js";
+import { resolveFrom } from "../module.js";
+import type { BuiltinFunction, ModuleExports } from "../../registry.js";
+
+const builtins: Record<string, BuiltinFunction> = {
+  spawnSync: { symbol: "xt_child_process_spawn_sync" },
+};
+
+const exports: ModuleExports = {
+  spawnSync: { symbol: "xt_child_process_spawn_sync" },
+};
+
+export const childProcessModule: NodeModule = {
+  name: "child_process",
+  runtimeSources: () => [resolveFrom(import.meta.url, "../../../../runtime/ext_node/child_process/child_process.c")],
+  builtins: () => builtins,
+  exports: () => exports,
+};

package/src/extensions/node/crypto/index.ts

@@ -0,0 +1,23 @@
+/**
+ * Node's `crypto` module: `createHash(...).update(...).digest("hex")`, backed
+ * by a self-contained SHA-256 in `runtime/ext_node/crypto`.
+ */
+
+import type { NodeModule } from "../module.js";
+import { resolveFrom } from "../module.js";
+import type { BuiltinFunction, ModuleExports } from "../../registry.js";
+
+const builtins: Record<string, BuiltinFunction> = {
+  createHash: { symbol: "xt_crypto_create_hash" },
+};
+
+const exports: ModuleExports = {
+  createHash: { symbol: "xt_crypto_create_hash" },
+};
+
+export const cryptoModule: NodeModule = {
+  name: "crypto",
+  runtimeSources: () => [resolveFrom(import.meta.url, "../../../../runtime/ext_node/crypto/crypto.c")],
+  builtins: () => builtins,
+  exports: () => exports,
+};

package/src/extensions/node/index.ts

@@ -22,6 +22,9 @@ import { streamModule } from "./stream/index.js";
 import { netModule } from "./net/index.js";
 import { dgramModule } from "./dgram/index.js";
 import { httpModule } from "./http/index.js";
+import { urlModule } from "./url/index.js";
+import { cryptoModule } from "./crypto/index.js";
+import { childProcessModule } from "./child_process/index.js";
 
 /** Every Node module the extension currently provides. */
 const modules: readonly NodeModule[] = [
@@ -35,6 +38,9 @@ const modules: readonly NodeModule[] = [
   netModule,
   dgramModule,
   httpModule,
+  urlModule,
+  cryptoModule,
+  childProcessModule,
 ];
 
 export const nodeExtension: Extension = {

package/src/extensions/node/module.ts

@@ -7,6 +7,7 @@
 
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { findRuntimeDir } from "../../driver/paths.js";
 import type { BuiltinFunction, ModuleExports } from "../registry.js";
 
 export interface NodeModule {
@@ -26,7 +27,18 @@ export interface NodeModule {
   exports?(): ModuleExports;
 }
 
-/** Resolve a path relative to the folder of the module that calls this. */
+/**
+ * Resolve a C runtime source that is written relative to an extension module
+ * (e.g. `../../../../runtime/ext_node/fs/read_file.c`).
+ *
+ * When running from source the page is resolved against the calling module's
+ * own URL, but inside a compiled xbintsc binary `import.meta.url` points at the
+ * executable, so the module-relative form no longer resolves. Anchor on the
+ * discovered runtime directory instead, which is correct in both worlds.
+ */
 export function resolveFrom(importMetaUrl: string, relative: string): string {
+  const marker = "runtime/";
+  const index = relative.indexOf(marker);
+  if (index >= 0) return resolve(findRuntimeDir(), relative.slice(index + marker.length));
   return resolve(dirname(fileURLToPath(importMetaUrl)), relative);
 }

package/src/extensions/node/url/index.ts

@@ -0,0 +1,26 @@
+/**
+ * Node's `url` module: `pathToFileURL` / `fileURLToPath`, backed by
+ * `runtime/ext_node/url`. These are the helpers the compiler uses to relate
+ * `import.meta.url`, `process.argv[1]` and filesystem paths.
+ */
+
+import type { NodeModule } from "../module.js";
+import { resolveFrom } from "../module.js";
+import type { BuiltinFunction, ModuleExports } from "../../registry.js";
+
+const builtins: Record<string, BuiltinFunction> = {
+  pathToFileURL: { symbol: "xt_url_path_to_file_url" },
+  fileURLToPath: { symbol: "xt_url_file_url_to_path" },
+};
+
+const exports: ModuleExports = {
+  pathToFileURL: { symbol: "xt_url_path_to_file_url" },
+  fileURLToPath: { symbol: "xt_url_file_url_to_path" },
+};
+
+export const urlModule: NodeModule = {
+  name: "url",
+  runtimeSources: () => [resolveFrom(import.meta.url, "../../../../runtime/ext_node/url/url.c")],
+  builtins: () => builtins,
+  exports: () => exports,
+};