xbintsc 0.3.25 → 0.3.46

package/scripts/check-file-length.ts

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+/**
+ * Enforce the per-file line budget for code ESLint cannot parse.
+ *
+ * ESLint's `max-lines` rule already caps the TypeScript/JavaScript sources at
+ * 600 lines (see `eslint.config.js`). This script applies the same budget to
+ * the runtime's C, C++, Rust and `#include`d `.inc` fragments plus shell
+ * scripts, so *every* code file stays focused and small.
+ *
+ * Vendored third-party sources that must ship verbatim (notably the
+ * single-header `stb_image.h`) are exempt: they are not ours to split.
+ *
+ * Run via `npm run lint` (or `tsx scripts/check-file-length.ts`).
+ */
+
+import { readdirSync, readFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = resolve(fileURLToPath(new URL(".", import.meta.url)), "..");
+
+/** Maximum number of lines allowed in a single code file. */
+const MAX_LINES = 600;
+
+const CODE_EXTENSIONS = new Set([".c", ".h", ".cc", ".cpp", ".hpp", ".rs", ".inc", ".sh"]);
+
+const IGNORED_DIRECTORIES = new Set([
+  ".git",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules",
+  "scratch",
+  "target",
+  "vendor",
+]);
+
+/** Vendored third-party sources that ship verbatim and are not ours to split. */
+const VENDORED_FILES = new Set([join("runtime", "ext_gui", "stb_image.h")]);
+
+interface Offense {
+  file: string;
+  lines: number;
+}
+
+function countLines(path: string): number {
+  const content = readFileSync(path, "utf8");
+  if (content.length === 0) return 0;
+  // A trailing newline terminates the last line instead of starting a new one.
+  const lines = content.split("\n");
+  return content.endsWith("\n") ? lines.length - 1 : lines.length;
+}
+
+function collect(dir: string, offenses: Offense[]): 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()) {
+      if (IGNORED_DIRECTORIES.has(entry.name)) continue;
+      // `runtime/lib` holds prebuilt archives, never sources.
+      if (relative(root, full) === join("runtime", "lib")) continue;
+      collect(full, offenses);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    const dot = entry.name.lastIndexOf(".");
+    if (dot < 0 || !CODE_EXTENSIONS.has(entry.name.slice(dot))) continue;
+    const file = relative(root, full);
+    if (VENDORED_FILES.has(file)) continue;
+    const lines = countLines(full);
+    if (lines > MAX_LINES) offenses.push({ file, lines });
+  }
+}
+
+const offenses: Offense[] = [];
+collect(root, offenses);
+
+if (offenses.length > 0) {
+  console.error(`xbintsc: code files must stay under ${MAX_LINES} lines - split them by responsibility:`);
+  for (const offense of offenses.sort((a, b) => b.lines - a.lines)) {
+    console.error(`  ${offense.file}: ${offense.lines} lines`);
+  }
+  process.exit(1);
+}
+
+console.log(`xbintsc: all code files are within ${MAX_LINES} lines`);

package/src/cli/main.ts

@@ -14,6 +14,7 @@
 
 import { spawnSync } from "node:child_process";
 import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { formatDiagnostic, type Diagnostic } from "../diagnostics/diagnostic.js";
 import { SourceFile } from "../diagnostics/source.js";
@@ -25,6 +26,15 @@ import { realRunner } from "../driver/toolchain.js";
 import { createDefaultRegistry, type ExtensionRegistry } from "../extensions/registry.js";
 import { bundledExtensions } from "../extensions/catalog.js";
 import { nativeExtensionFromManifest } from "../extensions/native.js";
+import { resolveResourceCompiler } from "../driver/win-icon.js";
+import {
+  CONFIG_FILE_NAME,
+  findProjectConfig,
+  loadProjectConfig,
+  resolveConfigPaths,
+  type AppConfig,
+  type ProjectConfig,
+} from "../driver/config.js";
 
 export interface CliIo {
   readonly stdout: (text: string) => void;
@@ -43,7 +53,18 @@ interface ParsedArgs {
   readonly passthrough: string[];
 }
 
-const VALUE_FLAGS = new Set(["output", "out", "emit", "optimize", "ext", "ext-native"]);
+const VALUE_FLAGS = new Set([
+  "output",
+  "out",
+  "emit",
+  "optimize",
+  "ext",
+  "ext-native",
+  "config",
+  "icon",
+  "app-id",
+  "app-name",
+]);
 
 function parseArgs(argv: readonly string[]): ParsedArgs {
   const positionals: string[] = [];
@@ -95,29 +116,22 @@ function parseArgs(argv: readonly string[]): ParsedArgs {
   return { command: positionals.shift(), positionals, flags, passthrough };
 }
 
-function buildRegistry(flags: Map<string, string | boolean>): ExtensionRegistry {
+function buildRegistry(extNames: readonly string[], nativeManifests: readonly string[]): ExtensionRegistry {
   const registry = createDefaultRegistry();
-  const requested = flags.get("ext");
-  if (typeof requested === "string") {
-    const bundled = bundledExtensions();
-    for (const name of requested.split(",").map((n) => n.trim()).filter(Boolean)) {
-      const extension = bundled.find((candidate) => candidate.name === name);
-      if (!extension) throw new Error(`Unknown extension '${name}'`);
-      registry.register(extension);
-    }
+  const bundled = bundledExtensions();
+  for (const name of extNames) {
+    const extension = bundled.find((candidate) => candidate.name === name);
+    if (!extension) throw new Error(`Unknown extension '${name}'`);
+    registry.register(extension);
   }
-  // Each `--ext-native` value is a manifest path describing a pre-built C++ or
-  // Rust library; several manifests may be comma separated.
-  const native = flags.get("ext-native");
-  if (typeof native === "string") {
-    for (const manifest of native.split(",").map((n) => n.trim()).filter(Boolean)) {
-      registry.register(nativeExtensionFromManifest(manifest));
-    }
+  // Each manifest describes a pre-built C++ or Rust library.
+  for (const manifest of nativeManifests) {
+    registry.register(nativeExtensionFromManifest(manifest));
   }
   // Hint the extensions that ship with xbintsc but were not enabled, so a
   // missing `import` of a known module points at the flag that enables it
   // (`pass --ext node`) instead of failing later with a confusing error.
-  for (const extension of bundledExtensions()) {
+  for (const extension of bundled) {
     if (!registry.has(extension.name)) registry.hintExtension(extension);
   }
   return registry;
@@ -131,6 +145,11 @@ function printDiagnostics(diagnostics: readonly Diagnostic[], fileName: string,
     source = undefined;
   }
   for (const diagnostic of diagnostics) {
+    // Driver-level diagnostics (icon, config, …) have no source location.
+    if (diagnostic.fileName === undefined && diagnostic.start === undefined) {
+      io.stderr(`error TS${diagnostic.code}: ${diagnostic.message}\n`);
+      continue;
+    }
     io.stderr(formatDiagnostic(diagnostic, source) + "\n");
   }
 }
@@ -153,6 +172,13 @@ Options:
       --ext <names>     Comma separated extensions (e.g. node)
       --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
 `;
@@ -190,9 +216,70 @@ function doctor(io: CliIo): number {
   } catch {
     io.stdout("runtime lib: unavailable\n");
   }
+
+  try {
+    const toolchain = resolveToolchain();
+    const resource = resolveResourceCompiler(realRunner, toolchain.clang);
+    io.stdout(`icon res   : ${resource ? `${resource.tool} (${resource.kind})` : "none (.exe icon disabled)"}\n`);
+  } catch {
+    io.stdout("icon res   : unknown\n");
+  }
   return 0;
 }
 
+type ConfigResolution =
+  | { readonly ok: true; readonly config: ProjectConfig }
+  | { readonly ok: false; readonly error: string };
+
+/**
+ * Resolve the project config for a command: `--config <path>` selects one
+ * explicitly, `--no-config` disables discovery, otherwise we walk up from the
+ * entry file (or the cwd) looking for {@link CONFIG_FILE_NAME}.
+ */
+function resolveProjectConfig(
+  flags: Map<string, string | boolean>,
+  cliEntry: string | undefined,
+): ConfigResolution {
+  try {
+    const explicit = flags.get("config");
+    if (typeof explicit === "string") {
+      return { ok: true, config: resolveConfigPaths(loadProjectConfig(explicit)) };
+    }
+    if (flags.has("no-config")) return { ok: true, config: {} };
+    const startDir = cliEntry ? dirname(resolve(cliEntry)) : process.cwd();
+    const found = findProjectConfig(startDir);
+    if (!found) return { ok: true, config: {} };
+    return { ok: true, config: resolveConfigPaths(loadProjectConfig(found)) };
+  } catch (error) {
+    return { ok: false, error: (error as Error).message };
+  }
+}
+
+/** Merge `app.*` config with the CLI overrides (`--icon`, `--bundle`, …). */
+function mergeAppConfig(flags: Map<string, string | boolean>, config: ProjectConfig): AppConfig {
+  const base = config.app ?? {};
+  const name = typeof flags.get("app-name") === "string" ? (flags.get("app-name") as string) : base.name;
+  const bundleId = typeof flags.get("app-id") === "string" ? (flags.get("app-id") as string) : base.bundleId;
+  const bundle = flags.has("bundle") ? true : base.bundle;
+  const icon = typeof flags.get("icon") === "string" ? (flags.get("icon") as string) : base.icon;
+  return {
+    ...(name !== undefined ? { name } : {}),
+    ...(bundleId !== undefined ? { bundleId } : {}),
+    ...(bundle !== undefined ? { bundle } : {}),
+    ...(icon !== undefined ? { icon } : {}),
+  };
+}
+
+/** Split a comma-separated CLI flag into a trimmed, non-empty list. */
+function listFlag(flags: Map<string, string | boolean>, name: string): string[] | undefined {
+  const value = flags.get(name);
+  if (typeof value !== "string") return undefined;
+  return value
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
 export function run(argv: readonly string[], io: CliIo = defaultIo): number {
   const args = parseArgs(argv);
   const command = args.command;
@@ -212,12 +299,20 @@ export function run(argv: readonly string[], io: CliIo = defaultIo): number {
   }
 
   if (command === "emit") {
-    const entry = args.positionals[0];
+    const cliEntry = args.positionals[0];
+    const resolved = resolveProjectConfig(args.flags, cliEntry);
+    if (!resolved.ok) {
+      io.stderr(`xbintsc: ${resolved.error}\n`);
+      return 1;
+    }
+    const entry = cliEntry ?? resolved.config.entry;
     if (!entry) {
-      io.stderr("xbintsc: emit requires a source file\n");
+      io.stderr(`xbintsc: emit requires a source file (or 'entry' in ${CONFIG_FILE_NAME})\n`);
       return 1;
     }
-    const registry = buildRegistry(args.flags);
+    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);
     if (diagnostics.some((d) => d.category === "error")) {
       printDiagnostics(diagnostics, entry, io);
@@ -228,21 +323,33 @@ export function run(argv: readonly string[], io: CliIo = defaultIo): number {
   }
 
   if (command === "build" || command === "run") {
-    const entry = args.positionals[0];
+    const cliEntry = args.positionals[0];
+    const resolved = resolveProjectConfig(args.flags, cliEntry);
+    if (!resolved.ok) {
+      io.stderr(`xbintsc: ${resolved.error}\n`);
+      return 1;
+    }
+    const config = resolved.config;
+    const entry = cliEntry ?? config.entry;
     if (!entry) {
-      io.stderr(`xbintsc: ${command} requires a source file\n`);
+      io.stderr(`xbintsc: ${command} requires a source file (or 'entry' in ${CONFIG_FILE_NAME})\n`);
       return 1;
     }
     const emit = (args.flags.get("emit") as EmitKind | undefined) ?? "exe";
-    const optimize = (args.flags.get("optimize") as string | undefined) ?? "2";
+    const optimize = (args.flags.get("optimize") as string | undefined) ?? config.optimize ?? "2";
+    const extNames = listFlag(args.flags, "ext") ?? config.extensions ?? [];
+    const nativeManifests = listFlag(args.flags, "ext-native") ?? config.extNative ?? [];
+    const registry = buildRegistry(extNames, nativeManifests);
+
     const result = build(entry, {
-      output: typeof args.flags.get("output") === "string" ? (args.flags.get("output") as string) : undefined,
-      outDir: typeof args.flags.get("out") === "string" ? (args.flags.get("out") as string) : undefined,
+      output: typeof args.flags.get("output") === "string" ? (args.flags.get("output") as string) : config.output,
+      outDir: typeof args.flags.get("out") === "string" ? (args.flags.get("out") as string) : config.outDir,
       emit,
       optimize: optimize as "0" | "1" | "2" | "3",
-      force: Boolean(args.flags.get("force")),
+      force: Boolean(args.flags.get("force")) || config.force === true,
       verbose: Boolean(args.flags.get("verbose")),
-      extensions: buildRegistry(args.flags),
+      extensions: registry,
+      app: mergeAppConfig(args.flags, config),
     });
 
     if (result.diagnostics.some((d) => d.category === "error")) {
@@ -251,7 +358,8 @@ export function run(argv: readonly string[], io: CliIo = defaultIo): number {
     }
 
     if (command === "build") {
-      io.stdout(`xbintsc: wrote ${result.outputPath}${result.cached ? " (cached)" : ""}\n`);
+      const bundle = result.bundlePath ? ` (bundle: ${result.bundlePath})` : "";
+      io.stdout(`xbintsc: wrote ${result.outputPath}${result.cached ? " (cached)" : ""}${bundle}\n`);
       return 0;
     }
 

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

@@ -13,7 +13,7 @@ import {
   type PropertyAccessExpression,
 } from "../../../ast/nodes.js";
 import { i64, numberLiteral, XT_TRUE, XT_UNDEFINED } from "../../values.js";
-import { MATH_CONSTANTS, NAMESPACE_PROPERTIES, NUMBER_CONSTANTS } from "../tables.js";
+import { MATH_CONSTANTS, NAMESPACE_PROPERTIES, NUMBER_CONSTANTS, TYPED_ARRAYS } from "../tables.js";
 import type { Generator } from "../generator.js";
 
 export interface AccessCallMethods {
@@ -121,6 +121,14 @@ export const accessCallMethods: AccessCallMethods = {
         return result;
       }
     }
+    if (
+      node.expression.kind === SyntaxKind.Identifier &&
+      !this.binding.symbolOfIdentifier.get(node.expression as Identifier) &&
+      node.name.text === "BYTES_PER_ELEMENT"
+    ) {
+      const typed = TYPED_ARRAYS[(node.expression as Identifier).text];
+      if (typed) return numberLiteral(typed.bytes);
+    }
     const object = this.emitExpression(node.expression);
     return this.emitPropertyGet(object, node.name.text);
   },

package/src/codegen/generator/module.ts

@@ -227,9 +227,19 @@ export const moduleMethods: ModuleMethods = {
 
   emitMain(): void {
     const moduleName = this.functionName(this.binding.moduleFunction);
+    // Module bindings and class constructors live in globals; register them as
+    // GC roots before the module body runs so a collection cannot free them.
+    const roots = [...this.classGlobals.values(), ...this.moduleGlobals.values()];
+    const rootLines = roots.map((name) => `  call void @xt_gc_add_root(i64* ${name})`);
     this.functions.push(
       [
         "define i32 @main(i32 %argc, i8** %argv) {",
+        "  %stackbase = alloca i64",
+        "  %stackbase.ptr = bitcast i64* %stackbase to i8*",
+        "  call void @xt_gc_set_stack_base(i8* %stackbase.ptr)",
+        "  call void @xt_gc_init()",
+        ...rootLines,
+        "  call void @xt_gc_arm()",
         "  call void @xt_set_program_args(i32 %argc, i8** %argv)",
         `  %result = call i64 @${moduleName}(i64 ${i64(XT_UNDEFINED)}, i64 ${i64(XT_UNDEFINED)}, i32 0, i64* null)`,
         "  call void @xt_drain_microtasks()",

package/src/codegen/generator/state.ts

@@ -103,6 +103,10 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_await(i64)",
   "declare void @xt_drain_microtasks()",
   "declare void @xt_run_event_loop()",
+  "declare void @xt_gc_init()",
+  "declare void @xt_gc_set_stack_base(i8*)",
+  "declare void @xt_gc_arm()",
+  "declare void @xt_gc_add_root(i64*)",
   "declare i64 @xt_promise_resolve(i64)",
   "declare i64 @xt_promise_reject(i64)",
   "declare i64 @xt_promise_ctor(i32, i64*)",
@@ -116,6 +120,24 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_os_static(i64, i32, i64*)",
   "declare i64 @xt_buffer_static(i64, i32, i64*)",
   "declare i64 @xt_buffer_ctor(i32, i64*)",
+  "declare i64 @xt_ta_u8_ctor(i32, i64*)",
+  "declare i64 @xt_ta_u8_static(i64, i32, i64*)",
+  "declare i64 @xt_ta_i8_ctor(i32, i64*)",
+  "declare i64 @xt_ta_i8_static(i64, i32, i64*)",
+  "declare i64 @xt_ta_u8c_ctor(i32, i64*)",
+  "declare i64 @xt_ta_u8c_static(i64, i32, i64*)",
+  "declare i64 @xt_ta_u16_ctor(i32, i64*)",
+  "declare i64 @xt_ta_u16_static(i64, i32, i64*)",
+  "declare i64 @xt_ta_i16_ctor(i32, i64*)",
+  "declare i64 @xt_ta_i16_static(i64, i32, i64*)",
+  "declare i64 @xt_ta_u32_ctor(i32, i64*)",
+  "declare i64 @xt_ta_u32_static(i64, i32, i64*)",
+  "declare i64 @xt_ta_i32_ctor(i32, i64*)",
+  "declare i64 @xt_ta_i32_static(i64, i32, i64*)",
+  "declare i64 @xt_ta_f32_ctor(i32, i64*)",
+  "declare i64 @xt_ta_f32_static(i64, i32, i64*)",
+  "declare i64 @xt_ta_f64_ctor(i32, i64*)",
+  "declare i64 @xt_ta_f64_static(i64, i32, i64*)",
   "declare i64 @xt_stream_static(i64, i32, i64*)",
   "declare i64 @xt_readable_ctor(i32, i64*)",
   "declare i64 @xt_writable_ctor(i32, i64*)",
@@ -219,6 +241,7 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_clear_timeout(i32, i64*)",
   "declare i64 @xt_set_interval(i32, i64*)",
   "declare i64 @xt_clear_interval(i32, i64*)",
+  "declare i64 @xt_fetch(i32, i64*)",
   "declare i64 @xt_number_ctor(i32, i64*)",
   "declare i64 @xt_bigint_ctor(i32, i64*)",
   "declare i64 @xt_bigint_static(i64, i32, i64*)",
@@ -254,6 +277,7 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_builtin_value_clearTimeout(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_setInterval(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_clearInterval(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_fetch(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*)",

package/src/codegen/generator/tables.ts

@@ -127,6 +127,7 @@ export const GLOBAL_FUNCTIONS: Record<string, string> = {
   clearTimeout: "xt_clear_timeout",
   setInterval: "xt_set_interval",
   clearInterval: "xt_clear_interval",
+  fetch: "xt_fetch",
   Number: "xt_number_ctor",
   String: "xt_string_ctor",
   Boolean: "xt_boolean_ctor",
@@ -150,6 +151,7 @@ export const BUILTIN_FUNCTION_VALUES: Record<string, string> = {
   clearTimeout: "xt_builtin_value_clearTimeout",
   setInterval: "xt_builtin_value_setInterval",
   clearInterval: "xt_builtin_value_clearInterval",
+  fetch: "xt_builtin_value_fetch",
   Number: "xt_builtin_value_number",
   String: "xt_builtin_value_string",
   Boolean: "xt_builtin_value_boolean",
@@ -157,6 +159,42 @@ export const BUILTIN_FUNCTION_VALUES: Record<string, string> = {
   Symbol: "xt_builtin_value_symbol",
 };
 
+/** Typed-array globals: constructor, static dispatcher and element width. */
+export const TYPED_ARRAYS: Record<string, { ctor: string; static: string; bytes: number }> = {
+  Uint8Array: { ctor: "xt_ta_u8_ctor", static: "xt_ta_u8_static", bytes: 1 },
+  Int8Array: { ctor: "xt_ta_i8_ctor", static: "xt_ta_i8_static", bytes: 1 },
+  Uint8ClampedArray: { ctor: "xt_ta_u8c_ctor", static: "xt_ta_u8c_static", bytes: 1 },
+  Uint16Array: { ctor: "xt_ta_u16_ctor", static: "xt_ta_u16_static", bytes: 2 },
+  Int16Array: { ctor: "xt_ta_i16_ctor", static: "xt_ta_i16_static", bytes: 2 },
+  Uint32Array: { ctor: "xt_ta_u32_ctor", static: "xt_ta_u32_static", bytes: 4 },
+  Int32Array: { ctor: "xt_ta_i32_ctor", static: "xt_ta_i32_static", bytes: 4 },
+  Float32Array: { ctor: "xt_ta_f32_ctor", static: "xt_ta_f32_static", bytes: 4 },
+  Float64Array: { ctor: "xt_ta_f64_ctor", static: "xt_ta_f64_static", bytes: 8 },
+};
+
+const TYPED_ARRAY_CTORS: Record<string, string> = {
+  Uint8Array: "xt_ta_u8_ctor",
+  Int8Array: "xt_ta_i8_ctor",
+  Uint8ClampedArray: "xt_ta_u8c_ctor",
+  Uint16Array: "xt_ta_u16_ctor",
+  Int16Array: "xt_ta_i16_ctor",
+  Uint32Array: "xt_ta_u32_ctor",
+  Int32Array: "xt_ta_i32_ctor",
+  Float32Array: "xt_ta_f32_ctor",
+  Float64Array: "xt_ta_f64_ctor",
+};
+const TYPED_ARRAY_STATICS: Record<string, string> = {
+  Uint8Array: "xt_ta_u8_static",
+  Int8Array: "xt_ta_i8_static",
+  Uint8ClampedArray: "xt_ta_u8c_static",
+  Uint16Array: "xt_ta_u16_static",
+  Int16Array: "xt_ta_i16_static",
+  Uint32Array: "xt_ta_u32_static",
+  Int32Array: "xt_ta_i32_static",
+  Float32Array: "xt_ta_f32_static",
+  Float64Array: "xt_ta_f64_static",
+};
+
 /** Global namespaces whose static methods map to runtime dispatchers. */
 export const NAMESPACE_STATICS: Record<string, string> = {
   Math: "xt_math_call",
@@ -186,6 +224,7 @@ export const NAMESPACE_STATICS: Record<string, string> = {
   util: "xt_util_static",
   querystring: "xt_querystring_static",
   assert: "xt_assert_static",
+  ...TYPED_ARRAY_STATICS,
 };
 
 /** Namespace identifiers whose property access maps to a runtime getter. */
@@ -213,6 +252,7 @@ export const CTOR_FUNCTIONS: Record<string, string> = {
   Server: "xt_net_server_ctor",
   EventEmitter: "xt_event_emitter_ctor",
   ...ERROR_CONSTRUCTORS,
+  ...TYPED_ARRAY_CTORS,
 };
 
 export const BUILTIN_METHODS = new Set<string>([