xbintsc 0.3.3 → 0.3.5

package/src/codegen/generator/module.ts

@@ -9,7 +9,6 @@ import {
   type ArrowFunction,
   type Block,
   type Expression,
-  type Identifier,
   type Parameter,
 } from "../../ast/nodes.js";
 import type { ClassInfo, FunctionInfo, SymbolInfo } from "../../binder/binder.js";
@@ -94,7 +93,9 @@ export const moduleMethods: ModuleMethods = {
       label: 0,
       terminated: false,
       loops: [],
+      pendingLabels: [],
       tryFrames: [],
+      finallyStack: [],
       escapePointers: [],
       usesTry: false,
     };
@@ -157,11 +158,8 @@ export const moduleMethods: ModuleMethods = {
     if (fn.isConstructor && fn.classInfo?.parentExpression) {
       const explicitBody = (fn.node as { body?: Block }).body;
       const parent = fn.classInfo.parentExpression;
-      const unboundBuiltin =
-        parent.kind === SyntaxKind.Identifier &&
-        (parent as Identifier).text === "Error" &&
-        !this.binding.symbolOfIdentifier.get(parent as Identifier);
-      if (!explicitBody && !unboundBuiltin) {
+      const errorName = this.errorFamilyName(parent);
+      if (!explicitBody && !errorName) {
         const parentValue = this.emitExpression(parent);
         const parentProto = this.reg();
         this.emit(`  ${parentProto} = call i64 @xt_function_get_prototype(i64 ${parentValue})`);
@@ -170,10 +168,12 @@ export const moduleMethods: ModuleMethods = {
         this.emit(`  ${parentCtor} = call i64 @xt_get(i64 ${parentProto}, i64 ${ctorKey})`);
         const superThis = this.emitThis();
         this.emit(`  call i64 @xt_call_with_this(i64 ${parentCtor}, i64 ${superThis}, i32 %argc, i64* %argv)`);
-      } else if (!explicitBody && unboundBuiltin) {
-        // `extends Error` with no explicit constructor: initialise message/name.
+      } else if (!explicitBody && errorName) {
+        // `extends Error` / `extends TypeError` with no explicit constructor:
+        // initialise the instance's name and message from the arguments.
         const superThis = this.emitThis();
-        this.emit(`  call i64 @xt_error_init(i64 ${superThis}, i32 %argc, i64* %argv)`);
+        const nameValue = this.stringValue(errorName);
+        this.emit(`  call i64 @xt_error_init(i64 ${superThis}, i64 ${nameValue}, i32 %argc, i64* %argv)`);
       }
     }
 
@@ -274,14 +274,16 @@ export const moduleMethods: ModuleMethods = {
     const proto = this.reg();
     this.emit(`  ${proto} = call i64 @xt_object_new()`);
     if (classInfo.parentExpression) {
-      // `extends Error` (and other host builtins) have no runtime class value;
-      // the subclass still works, it simply does not inherit a prototype.
+      // `extends Error` / `extends TypeError` / other host builtins: chain the
+      // subclass prototype onto the builtin's prototype so `instanceof` works.
       const parent = classInfo.parentExpression;
-      const unboundBuiltin =
-        parent.kind === SyntaxKind.Identifier &&
-        (parent as Identifier).text === "Error" &&
-        !this.binding.symbolOfIdentifier.get(parent as Identifier);
-      if (!unboundBuiltin) {
+      const errorName = this.errorFamilyName(parent);
+      if (errorName) {
+        const nameValue = this.stringValue(errorName);
+        const parentProto = this.reg();
+        this.emit(`  ${parentProto} = call i64 @xt_error_prototype(i64 ${nameValue})`);
+        this.emit(`  call i64 @xt_object_set_prototype(i64 ${proto}, i64 ${parentProto})`);
+      } else {
         const parentValue = this.emitExpression(parent);
         const parentProto = this.reg();
         this.emit(`  ${parentProto} = call i64 @xt_function_get_prototype(i64 ${parentValue})`);
@@ -290,7 +292,9 @@ export const moduleMethods: ModuleMethods = {
     }
     for (const method of classInfo.methods) {
       const fnValue = this.emitClosureValue(method);
-      const key = this.stringValue(method.name);
+      const key = method.computedKey
+        ? this.emitExpression(method.computedKey)
+        : this.stringValue(method.name);
       const accessor = (method.node as { accessor?: "get" | "set" }).accessor;
       if (accessor === "get") {
         this.emit(`  call i64 @xt_object_define_getter(i64 ${proto}, i64 ${key}, i64 ${fnValue})`);
@@ -306,7 +310,9 @@ export const moduleMethods: ModuleMethods = {
     this.emit(`  call i64 @xt_set(i64 ${proto}, i64 ${ctorKey}, i64 ${ctor})`);
     for (const method of classInfo.statics) {
       const fnValue = this.emitClosureValue(method);
-      const key = this.stringValue(method.name);
+      const key = method.computedKey
+        ? this.emitExpression(method.computedKey)
+        : this.stringValue(method.name);
       this.emit(`  call i64 @xt_set(i64 ${ctor}, i64 ${key}, i64 ${fnValue})`);
     }
     for (const field of classInfo.fields) {

package/src/codegen/generator/state.ts

@@ -5,6 +5,7 @@
 import type { FunctionInfo } from "../../binder/binder.js";
 import type { BindResult } from "../../binder/binder.js";
 import type { BuiltinFunction, ExtensionModule } from "../../extensions/registry.js";
+import type { Block } from "../../ast/nodes.js";
 
 export interface Slot {
   /** Register holding the `i64*` to the storage. */
@@ -12,11 +13,23 @@ export interface Slot {
   readonly boxed: boolean;
 }
 
+/**
+ * One enclosing `try`/`finally` region, used to run the `finally` block when an
+ * abrupt completion (`return`/`break`/`continue`) exits it.
+ */
+export interface FinallyContext {
+  /** Number of active `try` frames just before this region's frame. */
+  readonly frameDepth: number;
+  readonly block: Block;
+}
+
 export interface LoopLabels {
   readonly breakLabel: string;
   readonly continueLabel: string;
   /** Number of enclosing `try` frames when the loop was entered. */
   readonly tryDepth?: number;
+  /** Labels attached to this loop (outermost first), for `break`/`continue`. */
+  readonly labels?: readonly string[];
 }
 
 export interface FunctionState {
@@ -28,7 +41,10 @@ export interface FunctionState {
   label: number;
   terminated: boolean;
   readonly loops: LoopLabels[];
+  /** Labels on enclosing `LabeledStatement`s, consumed by the next loop. */
+  readonly pendingLabels: string[];
   readonly tryFrames: string[];
+  readonly finallyStack: FinallyContext[];
   readonly escapePointers: string[];
   /** Alloca holding the `this` binding for the current function. */
   thisPtr?: string;
@@ -57,6 +73,8 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_string_from_cstr(i8*)",
   "declare i64 @xt_arg(i32, i64*, i32)",
   "declare i64 @xt_closure_new(i8*, i32, i64*)",
+  "declare i64 @xt_function_set_metadata(i64, i64, i32)",
+  "declare i64 @xt_function_set_generator(i64)",
   "declare i64 @xt_closure_call(i64, i32, i64*)",
   "declare i64 @xt_closure_env(i64, i32)",
   "declare i64 @xt_call_with_this(i64, i64, i32, i64*)",
@@ -108,7 +126,16 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_date_ctor(i32, i64*)",
   "declare i64 @xt_regexp_ctor(i32, i64*)",
   "declare i64 @xt_error_ctor(i32, i64*)",
-  "declare i64 @xt_error_init(i64, i32, i64*)",
+  "declare i64 @xt_type_error_ctor(i32, i64*)",
+  "declare i64 @xt_range_error_ctor(i32, i64*)",
+  "declare i64 @xt_syntax_error_ctor(i32, i64*)",
+  "declare i64 @xt_reference_error_ctor(i32, i64*)",
+  "declare i64 @xt_eval_error_ctor(i32, i64*)",
+  "declare i64 @xt_uri_error_ctor(i32, i64*)",
+  "declare i64 @xt_aggregate_error_ctor(i32, i64*)",
+  "declare i64 @xt_error_constructor(i64)",
+  "declare i64 @xt_error_prototype(i64)",
+  "declare i64 @xt_error_init(i64, i64, i32, i64*)",
   "declare i64 @xt_json_parse(i32, i64*)",
   "declare i64 @xt_json_stringify(i32, i64*)",
   "declare i64 @xt_object_from_entries(i64)",
@@ -169,6 +196,10 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_parse_float(i32, i64*)",
   "declare i64 @xt_is_nan(i32, i64*)",
   "declare i64 @xt_is_finite(i32, i64*)",
+  "declare i64 @xt_encode_uri_component(i32, i64*)",
+  "declare i64 @xt_encode_uri(i32, i64*)",
+  "declare i64 @xt_decode_uri_component(i32, i64*)",
+  "declare i64 @xt_decode_uri(i32, i64*)",
   "declare i64 @xt_number_ctor(i32, i64*)",
   "declare i64 @xt_bigint_ctor(i32, i64*)",
   "declare i64 @xt_bigint_static(i64, i32, i64*)",
@@ -185,17 +216,29 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_array_length(i64)",
   "declare i64 @xt_array_spread(i64, i64)",
   "declare i64 @xt_iter_length(i64)",
+  "declare i64 @xt_iter_open(i64)",
+  "declare i64 @xt_iter_has(i64, i64)",
   "declare i64 @xt_iter_value(i64, i64)",
+  "declare i64 @xt_yield(i64)",
+  "declare i64 @xt_yield_star(i64)",
   "declare i32 @xt_array_size(i64)",
   "declare i64* @xt_array_items(i64)",
   "declare i64 @xt_builtin_value_parseInt(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_parseFloat(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_isNaN(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_isFinite(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_encodeURIComponent(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_encodeURI(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_decodeURIComponent(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_decodeURI(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_number(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_string(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_boolean(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_bigint(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_symbol(i64, i64, i32, i64*)",
+  "declare i64 @xt_symbol(i32, i64*)",
+  "declare i64 @xt_symbol_static(i64, i32, i64*)",
+  "declare i64 @xt_symbol_get(i64)",
   "declare i64 @xt_get(i64, i64)",
   "declare i64 @xt_set(i64, i64, i64)",
   "declare i64 @xt_box_new(i64)",

package/src/codegen/generator/statements/control-flow.ts

@@ -7,7 +7,9 @@ import {
   type CaseClause,
   type Identifier,
   type IfStatement,
+  type LabeledStatement,
   type ReturnStatement,
+  type Statement,
   type SwitchStatement,
   type TryStatement,
 } from "../../../ast/nodes.js";
@@ -16,14 +18,54 @@ import type { Generator } from "../generator.js";
 
 export interface ControlFlowStatementMethods {
   emitIf(this: Generator, statement: IfStatement): void;
+  emitLabeled(this: Generator, statement: LabeledStatement): void;
   emitSwitch(this: Generator, statement: SwitchStatement): void;
   emitTry(this: Generator, statement: TryStatement): void;
   bindCatchVariable(this: Generator, variable: Identifier | undefined, value: string): void;
   emitReturn(this: Generator, statement: ReturnStatement): void;
   popTryFramesTo(this: Generator, depth: number): void;
+  runFinallysBeforeExit(this: Generator, targetTryDepth: number): void;
 }
 
 export const controlFlowStatementMethods: ControlFlowStatementMethods = {
+  /**
+   * `label: statement`. A label on a loop is attached to that loop's break and
+   * continue targets; a label on any other statement becomes a breakable
+   * region so `break label` can jump to its end.
+   */
+  emitLabeled(statement: LabeledStatement): void {
+    const labels: string[] = [];
+    let current: Statement = statement;
+    while (current.kind === SyntaxKind.LabeledStatement) {
+      labels.push((current as LabeledStatement).label.text);
+      current = (current as LabeledStatement).statement;
+    }
+    const isLoop =
+      current.kind === SyntaxKind.WhileStatement ||
+      current.kind === SyntaxKind.DoStatement ||
+      current.kind === SyntaxKind.ForStatement ||
+      current.kind === SyntaxKind.ForOfStatement ||
+      current.kind === SyntaxKind.ForInStatement;
+    if (isLoop) {
+      this.current.pendingLabels.push(...labels);
+      this.emitStatement(current);
+      /* The loop consumed them; guard against a loop kind that did not. */
+      this.current.pendingLabels.length = 0;
+      return;
+    }
+    const endLabel = this.label("label.end");
+    this.current.loops.push({
+      breakLabel: endLabel,
+      continueLabel: endLabel,
+      labels,
+      tryDepth: this.current.tryFrames.length,
+    });
+    this.emitStatement(current);
+    this.current.loops.pop();
+    if (!this.current.terminated) this.terminate(`br label %${endLabel}`);
+    this.startBlock(endLabel);
+  },
+
   emitIf(statement: IfStatement): void {
     const thenLabel = this.label("if.then");
     const elseLabel = statement.elseStatement ? this.label("if.else") : undefined;
@@ -115,6 +157,10 @@ export const controlFlowStatementMethods: ControlFlowStatementMethods = {
     const finallyLabel = statement.finallyBlock ? this.label("try.finally") : undefined;
     const endLabel = this.label("try.end");
     const hasCatch = !!statement.catchClause;
+    const finallyContext =
+      statement.finallyBlock && finallyLabel
+        ? { frameDepth: this.current.tryFrames.length, block: statement.finallyBlock }
+        : undefined;
 
     const frame = this.reg();
     this.emit(`  ${frame} = call i8* @xt_try_enter()`);
@@ -136,7 +182,9 @@ export const controlFlowStatementMethods: ControlFlowStatementMethods = {
     // Normal completion of the try block.
     this.startBlock(tryLabel);
     this.current.tryFrames.push(frameSlot);
+    if (finallyContext) this.current.finallyStack.push(finallyContext);
     this.emitStatements(statement.tryBlock.statements);
+    if (finallyContext) this.current.finallyStack.pop();
     this.current.tryFrames.pop();
     if (!this.current.terminated) {
       const currentFrame = this.reg();
@@ -153,7 +201,9 @@ export const controlFlowStatementMethods: ControlFlowStatementMethods = {
       this.emit(`  ${exception} = call i64 @xt_try_exception(i8* ${currentFrame})`);
       this.emit(`  call void @xt_try_leave(i8* ${currentFrame})`);
       this.bindCatchVariable(statement.catchClause!.variable, exception);
+      if (finallyContext) this.current.finallyStack.push(finallyContext);
       this.emitStatements(statement.catchClause!.block.statements);
+      if (finallyContext) this.current.finallyStack.pop();
       if (!this.current.terminated) this.terminate(`br label %${finallyLabel ?? endLabel}`);
     } else {
       // Without a catch clause the exception is remembered, then rethrown
@@ -209,6 +259,8 @@ export const controlFlowStatementMethods: ControlFlowStatementMethods = {
   emitReturn(statement: ReturnStatement): void {
     let value = statement.expression ? this.emitExpression(statement.expression) : i64(XT_UNDEFINED);
     if (this.current.fn.isAsync) value = this.wrapAsync(value);
+    this.runFinallysBeforeExit(0);
+    if (this.current.terminated) return;
     this.popTryFramesTo(0);
     this.terminate(`ret i64 ${value}`);
   },
@@ -222,4 +274,38 @@ export const controlFlowStatementMethods: ControlFlowStatementMethods = {
       this.emit(`  call void @xt_try_leave(i8* ${frame})`);
     }
   },
+
+  /**
+   * Run the `finally` blocks of every region whose frame is above
+   * `targetTryDepth`, innermost first, so an abrupt completion
+   * (`return`/`break`/`continue`) observes JavaScript's guarantee that each
+   * `finally` runs before control leaves its `try`.
+   *
+   * The blocks are emitted inline on the exiting path (the shared `finally`
+   * block still serves normal and exceptional completion). While a block runs,
+   * only the *outer* regions stay on {@link FunctionState.finallyStack}, so a
+   * `return` written inside `finally` overrides the pending completion without
+   * re-entering the same block. The stack is restored afterwards because the
+   * emission is path-local: sibling branches must still see every region.
+   */
+  runFinallysBeforeExit(targetTryDepth: number): void {
+    const saved = this.current.finallyStack.slice();
+    const restore = (): void => {
+      this.current.finallyStack.length = 0;
+      this.current.finallyStack.push(...saved);
+    };
+    for (let index = saved.length - 1; index >= 0; index--) {
+      const context = saved[index]!;
+      if (context.frameDepth < targetTryDepth) break;
+      this.current.finallyStack.length = 0;
+      this.current.finallyStack.push(...saved.slice(0, index));
+      this.popTryFramesTo(context.frameDepth);
+      this.emitStatements(context.block.statements);
+      if (this.current.terminated) {
+        restore();
+        return;
+      }
+    }
+    restore();
+  },
 };

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

@@ -7,6 +7,8 @@
 import {
   SyntaxKind,
   type Block,
+  type BreakStatement,
+  type ContinueStatement,
   type DoStatement,
   type EnumDeclaration,
   type Expression,
@@ -14,6 +16,7 @@ import {
   type ForOfStatement,
   type ForStatement,
   type IfStatement,
+  type LabeledStatement,
   type ReturnStatement,
   type Statement,
   type SwitchStatement,
@@ -63,6 +66,9 @@ export const statementDispatchMethods: StatementDispatchMethods = {
       case SyntaxKind.IfStatement:
         this.emitIf(statement as IfStatement);
         return;
+      case SyntaxKind.LabeledStatement:
+        this.emitLabeled(statement as LabeledStatement);
+        return;
       case SyntaxKind.WhileStatement:
         this.emitWhile(statement as WhileStatement);
         return;
@@ -86,18 +92,24 @@ export const statementDispatchMethods: StatementDispatchMethods = {
         this.emitReturn(statement as ReturnStatement);
         return;
       case SyntaxKind.BreakStatement: {
-        const loop = this.current.loops[this.current.loops.length - 1];
+        const loop = this.findLoop((statement as BreakStatement).label?.text);
         if (loop) {
-          this.popTryFramesTo(loop.tryDepth ?? 0);
-          this.terminate(`br label %${loop.breakLabel}`);
+          this.runFinallysBeforeExit(loop.tryDepth ?? 0);
+          if (!this.current.terminated) {
+            this.popTryFramesTo(loop.tryDepth ?? 0);
+            this.terminate(`br label %${loop.breakLabel}`);
+          }
         }
         return;
       }
       case SyntaxKind.ContinueStatement: {
-        const loop = this.current.loops[this.current.loops.length - 1];
+        const loop = this.findLoop((statement as ContinueStatement).label?.text);
         if (loop) {
-          this.popTryFramesTo(loop.tryDepth ?? 0);
-          this.terminate(`br label %${loop.continueLabel}`);
+          this.runFinallysBeforeExit(loop.tryDepth ?? 0);
+          if (!this.current.terminated) {
+            this.popTryFramesTo(loop.tryDepth ?? 0);
+            this.terminate(`br label %${loop.continueLabel}`);
+          }
         }
         return;
       }

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

@@ -14,6 +14,7 @@ import {
 } from "../../../ast/nodes.js";
 import { numberLiteral } from "../../values.js";
 import type { Generator } from "../generator.js";
+import type { LoopLabels } from "../state.js";
 
 export interface LoopStatementMethods {
   emitWhile(this: Generator, statement: WhileStatement): void;
@@ -21,9 +22,25 @@ export interface LoopStatementMethods {
   emitFor(this: Generator, statement: ForStatement): void;
   emitForOf(this: Generator, statement: ForOfStatement | ForInStatement): void;
   bindLoopVariable(this: Generator, initializer: VariableDeclarationList | Expression, value: string): void;
+  takePendingLabels(this: Generator): string[];
+  findLoop(this: Generator, label: string | undefined): LoopLabels | undefined;
 }
 
 export const loopStatementMethods: LoopStatementMethods = {
+  /** Consume labels accumulated by enclosing `LabeledStatement`s. */
+  takePendingLabels(): string[] {
+    return this.current.pendingLabels.splice(0, this.current.pendingLabels.length);
+  },
+
+  /** Innermost loop, or the innermost loop carrying `label`. */
+  findLoop(label: string | undefined) {
+    for (let i = this.current.loops.length - 1; i >= 0; i--) {
+      const loop = this.current.loops[i]!;
+      if (!label || loop.labels?.includes(label)) return loop;
+    }
+    return undefined;
+  },
+
   emitWhile(statement: WhileStatement): void {
     const condLabel = this.label("while.cond");
     const bodyLabel = this.label("while.body");
@@ -37,7 +54,7 @@ export const loopStatementMethods: LoopStatementMethods = {
     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.current.loops.push({ breakLabel: endLabel, continueLabel: condLabel, tryDepth: this.current.tryFrames.length, labels: this.takePendingLabels() });
     this.emitStatement(statement.statement);
     this.current.loops.pop();
     if (!this.current.terminated) this.terminate(`br label %${condLabel}`);
@@ -50,7 +67,7 @@ export const loopStatementMethods: LoopStatementMethods = {
     const endLabel = this.label("do.end");
     this.terminate(`br label %${bodyLabel}`);
     this.startBlock(bodyLabel);
-    this.current.loops.push({ breakLabel: endLabel, continueLabel: condLabel, tryDepth: this.current.tryFrames.length });
+    this.current.loops.push({ breakLabel: endLabel, continueLabel: condLabel, tryDepth: this.current.tryFrames.length, labels: this.takePendingLabels() });
     this.emitStatement(statement.statement);
     this.current.loops.pop();
     if (!this.current.terminated) this.terminate(`br label %${condLabel}`);
@@ -96,7 +113,7 @@ export const loopStatementMethods: LoopStatementMethods = {
     }
 
     this.startBlock(bodyLabel);
-    this.current.loops.push({ breakLabel: endLabel, continueLabel: updateLabel, tryDepth: this.current.tryFrames.length });
+    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}`);
@@ -112,12 +129,12 @@ export const loopStatementMethods: LoopStatementMethods = {
     const source = this.emitExpression(statement.expression);
     const isForIn = statement.kind === SyntaxKind.ForInStatement;
     // `for...in` iterates the enumerable keys (indices become strings);
-    // `for...of` iterates the values at each index.
-    const iterable = isForIn ? this.runtimeCall("xt_object_keys", [source]) : source;
+    // `for...of` resolves the iteration protocol once, then walks it.
+    const iterable = isForIn
+      ? this.runtimeCall("xt_object_keys", [source])
+      : this.runtimeCall("xt_iter_open", [source]);
     const indexPtr = this.alloca();
     this.emit(`  store i64 ${numberLiteral(0)}, i64* ${indexPtr}`);
-    const lengthValue = this.reg();
-    this.emit(`  ${lengthValue} = call i64 @xt_iter_length(i64 ${iterable})`);
 
     const condLabel = this.label("forof.cond");
     const bodyLabel = this.label("forof.body");
@@ -128,10 +145,11 @@ export const loopStatementMethods: LoopStatementMethods = {
     this.startBlock(condLabel);
     const index = this.reg();
     this.emit(`  ${index} = load i64, i64* ${indexPtr}`);
-    const inRange = this.reg();
-    this.emit(`  ${inRange} = call i64 @xt_lt(i64 ${index}, i64 ${lengthValue})`);
+    /* `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 ${inRange})`);
+    this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${hasValue})`);
     const nonzero = this.reg();
     this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
     this.terminate(`br i1 ${nonzero}, label %${bodyLabel}, label %${endLabel}`);
@@ -140,7 +158,7 @@ export const loopStatementMethods: LoopStatementMethods = {
     const element = this.reg();
     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.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}`);

package/src/codegen/generator/tables.ts

@@ -69,15 +69,51 @@ export const MATH_CONSTANTS: Record<string, number> = {
   SQRT1_2: Math.SQRT1_2,
 };
 
+/** Read-only numeric constants exposed on the global `Number` namespace. */
+export const NUMBER_CONSTANTS = new Set<string>([
+  "MAX_SAFE_INTEGER",
+  "MIN_SAFE_INTEGER",
+  "MAX_VALUE",
+  "MIN_VALUE",
+  "EPSILON",
+  "POSITIVE_INFINITY",
+  "NEGATIVE_INFINITY",
+  "NaN",
+]);
+
+/** The Error family. Each name is a first-class constructor: usable with `new`,
+ * as a value (`instanceof`, `typeof`) and as a superclass (`extends TypeError`).
+ * All map to runtime constructors with signature `(i32, i64*)`. */
+export const ERROR_CONSTRUCTORS: Record<string, string> = {
+  Error: "xt_error_ctor",
+  TypeError: "xt_type_error_ctor",
+  RangeError: "xt_range_error_ctor",
+  SyntaxError: "xt_syntax_error_ctor",
+  ReferenceError: "xt_reference_error_ctor",
+  EvalError: "xt_eval_error_ctor",
+  URIError: "xt_uri_error_ctor",
+  AggregateError: "xt_aggregate_error_ctor",
+};
+
+export function isErrorFamily(name: string): boolean {
+  return ERROR_CONSTRUCTORS[name] !== undefined;
+}
+
 export const GLOBAL_FUNCTIONS: Record<string, string> = {
   parseInt: "xt_parse_int",
   parseFloat: "xt_parse_float",
   isNaN: "xt_is_nan",
   isFinite: "xt_is_finite",
+  encodeURIComponent: "xt_encode_uri_component",
+  encodeURI: "xt_encode_uri",
+  decodeURIComponent: "xt_decode_uri_component",
+  decodeURI: "xt_decode_uri",
   Number: "xt_number_ctor",
   String: "xt_string_ctor",
   Boolean: "xt_boolean_ctor",
   BigInt: "xt_bigint_ctor",
+  Symbol: "xt_symbol",
+  ...ERROR_CONSTRUCTORS,
 };
 
 /** Global functions that are also usable as first-class values, each mapped to
@@ -87,10 +123,15 @@ export const BUILTIN_FUNCTION_VALUES: Record<string, string> = {
   parseFloat: "xt_builtin_value_parseFloat",
   isNaN: "xt_builtin_value_isNaN",
   isFinite: "xt_builtin_value_isFinite",
+  encodeURIComponent: "xt_builtin_value_encodeURIComponent",
+  encodeURI: "xt_builtin_value_encodeURI",
+  decodeURIComponent: "xt_builtin_value_decodeURIComponent",
+  decodeURI: "xt_builtin_value_decodeURI",
   Number: "xt_builtin_value_number",
   String: "xt_builtin_value_string",
   Boolean: "xt_builtin_value_boolean",
   BigInt: "xt_builtin_value_bigint",
+  Symbol: "xt_builtin_value_symbol",
 };
 
 /** Global namespaces whose static methods map to runtime dispatchers. */
@@ -102,6 +143,7 @@ export const NAMESPACE_STATICS: Record<string, string> = {
   Number: "xt_number_static",
   String: "xt_string_static",
   BigInt: "xt_bigint_static",
+  Symbol: "xt_symbol_static",
   Date: "xt_date_static",
   Promise: "xt_promise_static",
   path: "xt_path_static",
@@ -126,6 +168,7 @@ export const NAMESPACE_STATICS: Record<string, string> = {
 export const NAMESPACE_PROPERTIES: Record<string, string> = {
   process: "xt_process_get",
   "import.meta": "xt_import_meta",
+  Symbol: "xt_symbol_get",
 };
 
 /** Global constructors called as `new X(...)` (all have signature `(i32, i64*)`). */
@@ -135,7 +178,6 @@ 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",
@@ -146,6 +188,7 @@ export const CTOR_FUNCTIONS: Record<string, string> = {
   Socket: "xt_net_socket_ctor",
   Server: "xt_net_server_ctor",
   EventEmitter: "xt_event_emitter_ctor",
+  ...ERROR_CONSTRUCTORS,
 };
 
 export const BUILTIN_METHODS = new Set<string>([

package/src/driver/compiler.ts

@@ -8,7 +8,7 @@
  */
 
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { basename, dirname, extname, join, resolve } from "node:path";
+import { basename, extname, join, resolve } from "node:path";
 import { DiagnosticBag, type Diagnostic } from "../diagnostics/diagnostic.js";
 import { SourceFile } from "../diagnostics/source.js";
 import { Parser } from "../parser/parser.js";
@@ -153,6 +153,7 @@ export function build(entryPath: string, options: BuildOptions = {}): BuildResul
     }
   }
 
+  const runtimeDir = findRuntimeDir();
   const cacheKey = hashParts([
     COMPILER_VERSION,
     cacheText,
@@ -160,6 +161,7 @@ export function build(entryPath: string, options: BuildOptions = {}): BuildResul
     optimize,
     process.platform,
     registry.all().map((e) => e.name).join(","),
+    runtimeFingerprint(runtimeDir),
   ]);
 
   const cache = new BuildCache(cacheDir);
@@ -207,7 +209,6 @@ export function build(entryPath: string, options: BuildOptions = {}): BuildResul
     return { outputPath, irPath, cached: false, diagnostics: [], ir };
   }
 
-  const runtimeDir = findRuntimeDir();
   const { runtimeObjects, extensionObjects } = ensureRuntimeObjects(
     runner,
     clang,
@@ -251,10 +252,39 @@ export const RUNTIME_SOURCES = [
   "xt_stdlib2.c",
   "xt_promise.c",
   "xt_loop.c",
+  "xt_generator.c",
+  "xt_symbol.c",
   "xt_builtins.c",
   "xt_io.c",
 ] as const;
 
+/**
+ * Fingerprint every runtime artifact that can change a linked executable: the
+ * C sources, shared headers and `#include`d `.inc` fragments plus the shipped
+ * prebuilt archives. It feeds the executable cache key, so a runtime change
+ * invalidates a cached binary even when the entry source is untouched — the
+ * per-object cache cannot express that, because the freshness check runs before
+ * any compilation.
+ */
+function runtimeFingerprint(runtimeDir: string): string {
+  if (!existsSync(runtimeDir)) return "";
+  const parts: string[] = [];
+  const walk = (dir: string): void => {
+    for (const entry of readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (/\.(c|h|inc)$/.test(entry.name)) {
+        parts.push(entry.name, readFileSync(full, "utf8"));
+      } else {
+        parts.push(entry.name, readFileSync(full).toString("base64"));
+      }
+    }
+  };
+  walk(runtimeDir);
+  return hashParts(parts);
+}
+
 /**
  * Compile the core runtime and every extension source, reusing cached object
  * files keyed on the C source hash. Returns the object paths to link.