xbintsc 0.3.81 → 0.3.87

package/runtime/xt_stdlib2/strings.inc

@@ -9,13 +9,16 @@ static xt_value xt_string_pad(xt_value value, xt_value lengthValue, xt_value pad
   if (!pad || pad->length == 0) return value;
   size_t total = (size_t)target;
   xt_string *out = xt_string_alloc(total);
+  char *mutable = xt_string_mutable(out);
+  const char *text = xt_string_bytes(s);
+  const char *padBytes = xt_string_bytes(pad);
   size_t needed = total - s->length;
   if (start) {
-    for (size_t i = 0; i < needed; i++) out->data[i] = pad->data[i % pad->length];
-    memcpy(out->data + needed, s->data, s->length);
+    for (size_t i = 0; i < needed; i++) mutable[i] = padBytes[i % pad->length];
+    memcpy(mutable + needed, text, s->length);
   } else {
-    memcpy(out->data, s->data, s->length);
-    for (size_t i = 0; i < needed; i++) out->data[s->length + i] = pad->data[i % pad->length];
+    memcpy(mutable, text, s->length);
+    for (size_t i = 0; i < needed; i++) mutable[s->length + i] = padBytes[i % pad->length];
   }
   return XT_FROM_PTR(XT_TAG_STRING, out);
 }
@@ -23,11 +26,12 @@ static xt_value xt_string_pad(xt_value value, xt_value lengthValue, xt_value pad
 static xt_value xt_string_trim_side(xt_value value, int start) {
   xt_string *s = xt_as_string(value);
   if (!s) return value;
+  const char *bytes = xt_string_bytes(s);
   uint32_t begin = 0;
   uint32_t end = s->length;
-  if (start) { while (begin < end && isspace((unsigned char)s->data[begin])) begin++; }
-  else { while (end > begin && isspace((unsigned char)s->data[end - 1])) end--; }
-  return xt_string_new(s->data + begin, end - begin);
+  if (start) { while (begin < end && isspace((unsigned char)bytes[begin])) begin++; }
+  else { while (end > begin && isspace((unsigned char)bytes[end - 1])) end--; }
+  return xt_string_new(bytes + begin, end - begin);
 }
 
 static xt_value xt_string_at(xt_value value, xt_value indexValue) {
@@ -36,7 +40,7 @@ static xt_value xt_string_at(xt_value value, xt_value indexValue) {
   int32_t index = indexValue == XT_UNDEFINED ? 0 : xt_to_int32(indexValue);
   if (index < 0) index += (int32_t)s->length;
   if (index < 0 || (uint32_t)index >= s->length) return XT_UNDEFINED;
-  return xt_string_new(s->data + index, 1);
+  return xt_string_new(xt_string_bytes(s) + index, 1);
 }
 
 static xt_value xt_string_replace_all(xt_value value, xt_value searchValue, xt_value replacementValue) {
@@ -46,20 +50,23 @@ static xt_value xt_string_replace_all(xt_value value, xt_value searchValue, xt_v
   xt_string *search = xt_as_string(xt_to_string(searchValue));
   xt_string *replacement = xt_as_string(xt_to_string(replacementValue));
   if (!search || search->length == 0) return value;
+  const char *text = xt_string_bytes(s);
+  const char *needle = xt_string_bytes(search);
+  const char *repl = xt_string_bytes(replacement);
   size_t capacity = s->length + replacement->length * 4 + 16;
   char *out = (char *)malloc(capacity);
   if (!out) abort();
   size_t length = 0;
   uint32_t i = 0;
   while (i < s->length) {
-    if (i + search->length <= s->length && memcmp(s->data + i, search->data, search->length) == 0) {
+    if (i + search->length <= s->length && memcmp(text + i, needle, search->length) == 0) {
       if (length + replacement->length + 2 > capacity) { capacity = (length + replacement->length + 2) * 2; out = (char *)realloc(out, capacity); if (!out) abort(); }
-      memcpy(out + length, replacement->data, replacement->length);
+      memcpy(out + length, repl, replacement->length);
       length += replacement->length;
       i += search->length;
     } else {
       if (length + 2 > capacity) { capacity *= 2; out = (char *)realloc(out, capacity); if (!out) abort(); }
-      out[length++] = s->data[i++];
+      out[length++] = text[i++];
     }
   }
   xt_value result = xt_string_new(out, length);
@@ -106,17 +113,19 @@ xt_value xt_ext_string_method(xt_value target, const char *method, int32_t argc,
     if (limit > (int32_t)s->length) limit = (int32_t)s->length;
     int32_t nlen = (int32_t)needle->length;
     if (nlen == 0) return xt_number((double)(limit < 0 ? 0 : limit));
+    const char *text = xt_string_bytes(s);
+    const char *need = xt_string_bytes(needle);
     int32_t i = limit;
     if (i > (int32_t)s->length - nlen) i = (int32_t)s->length - nlen;
     for (; i >= 0; i--) {
-      if (memcmp(s->data + i, needle->data, (size_t)nlen) == 0) return xt_number((double)i);
+      if (memcmp(text + i, need, (size_t)nlen) == 0) return xt_number((double)i);
     }
     return xt_number(-1);
   }
   if (strcmp(method, "localeCompare") == 0) {
     xt_string *a = xt_as_string(target);
     xt_string *b = xt_as_string(xt_to_string(xt_arg_at(argc, argv, 0)));
-    int cmp = strcmp(a ? a->data : "", b ? b->data : "");
+    int cmp = strcmp(a ? xt_string_bytes(a) : "", b ? xt_string_bytes(b) : "");
     return xt_number(cmp < 0 ? -1 : cmp > 0 ? 1 : 0);
   }
   if (strcmp(method, "codePointAt") == 0) {
@@ -124,7 +133,7 @@ xt_value xt_ext_string_method(xt_value target, const char *method, int32_t argc,
     if (!s) return XT_UNDEFINED;
     int32_t index = xt_to_int32(xt_arg_at(argc, argv, 0));
     if (index < 0 || (uint32_t)index >= s->length) return XT_UNDEFINED;
-    return xt_number((double)(unsigned char)s->data[index]);
+    return xt_number((double)(unsigned char)xt_string_bytes(s)[index]);
   }
   if (strcmp(method, "valueOf") == 0 || strcmp(method, "toString") == 0) return target;
   *handled = 0;

package/runtime/xt_symbol.c

@@ -98,7 +98,7 @@ xt_value xt_symbol_to_string(xt_value value) {
   char *buffer = (char *)malloc(8 + length);
   if (!buffer) abort();
   memcpy(buffer, "Symbol(", 7);
-  if (description) memcpy(buffer + 7, description->data, length);
+  if (description) memcpy(buffer + 7, xt_string_bytes(description), length);
   buffer[7 + length] = ')';
   xt_value result = xt_string_new(buffer, 8 + length);
   free(buffer);

package/runtime/xt_values/comparison.inc

@@ -33,7 +33,7 @@ xt_value xt_lt(xt_value a, xt_value b) {
     xt_string *x = xt_as_string(a);
     xt_string *y = xt_as_string(b);
     size_t n = x->length < y->length ? x->length : y->length;
-    int cmp = memcmp(x->data, y->data, n);
+    int cmp = memcmp(xt_string_bytes(x), xt_string_bytes(y), n);
     if (cmp == 0) return xt_bool(x->length < y->length);
     return xt_bool(cmp < 0);
   }
@@ -48,7 +48,7 @@ xt_value xt_le(xt_value a, xt_value b) {
     xt_string *x = xt_as_string(a);
     xt_string *y = xt_as_string(b);
     size_t n = x->length < y->length ? x->length : y->length;
-    int cmp = memcmp(x->data, y->data, n);
+    int cmp = memcmp(xt_string_bytes(x), xt_string_bytes(y), n);
     if (cmp == 0) return xt_bool(x->length <= y->length);
     return xt_bool(cmp < 0);
   }

package/runtime/xt_values/constructors.inc

@@ -10,19 +10,22 @@ xt_value xt_number(double d) { return xt_from_double(d); }
 xt_string *xt_string_alloc(size_t length) {
   xt_string *s = (xt_string *)xt_alloc(sizeof(xt_string), XT_OBJECT_KIND_STRING);
   s->length = (uint32_t)length;
+  /* Keep the terminator in the allocation: many consumers hand `flat` to libc. */
   s->capacity = (uint32_t)length + 1;
-  s->data = (char *)malloc(s->capacity);
-  if (!s->data) {
+  s->flat = (char *)malloc(s->capacity);
+  if (!s->flat) {
     fprintf(stderr, "xbintsc: out of memory allocating string\n");
     abort();
   }
-  s->data[length] = '\0';
+  s->flat[length] = '\0';
+  s->left = NULL;
+  s->right = NULL;
   return s;
 }
 
 xt_value xt_string_new(const char *data, size_t len) {
   xt_string *s = xt_string_alloc(len);
-  if (len > 0) memcpy(s->data, data, len);
+  if (len > 0) memcpy(s->flat, data, len);
   return XT_FROM_PTR(XT_TAG_STRING, s);
 }
 
@@ -30,9 +33,11 @@ xt_value xt_string_from_cstr(const char *data) { return xt_string_new(data, strl
 
 xt_string *xt_as_string(xt_value v);
 
+char *xt_string_mutable(xt_string *s) { return s ? s->flat : NULL; }
+
 const char *xt_string_data(xt_value value) {
   xt_string *s = xt_as_string(value);
-  return s ? s->data : NULL;
+  return s ? xt_string_bytes(s) : NULL;
 }
 
 int32_t xt_string_length_value(xt_value value) {

package/runtime/xt_values/conversions.inc

@@ -24,8 +24,9 @@ double xt_to_number(xt_value v) {
   if (XT_IS_BIGINT(v)) return xt_bigint_to_double_value(v);
   if (XT_IS_STRING(v)) {
     xt_string *s = xt_as_string(v);
-    const char *begin = s->data;
-    const char *end = s->data + s->length;
+    const char *bytes = xt_string_bytes(s);
+    const char *begin = bytes;
+    const char *end = bytes + s->length;
     while (begin < end && isspace((unsigned char)*begin)) begin++;
     while (end > begin && isspace((unsigned char)end[-1])) end--;
     size_t length = (size_t)(end - begin);
@@ -83,7 +84,7 @@ xt_value xt_to_string(xt_value v) {
         out = (char *)realloc(out, capacity);
       }
       if (i > 0) out[length++] = ',';
-      memcpy(out + length, str->data, str->length);
+      memcpy(out + length, xt_string_bytes(str), str->length);
       length += str->length;
       out[length] = '\0';
     }

package/runtime/xt_values/strings.inc

@@ -2,6 +2,12 @@
 /* Strings                                                                   */
 /* ------------------------------------------------------------------------- */
 
+/* Concatenations up to this many bytes are copied eagerly. The copy is cheaper
+ * than a cons node for the short strings that dominate everyday code, and a
+ * loop that keeps appending crosses the threshold quickly, after which every
+ * append is O(1). */
+#define XT_STRING_CONS_THRESHOLD 32
+
 xt_string *xt_as_string(xt_value v) {
   if (XT_IS_STRING(v)) return (xt_string *)XT_GET_PTR(v);
   return NULL;
@@ -9,14 +15,82 @@ xt_string *xt_as_string(xt_value v) {
 
 int32_t xt_string_length(xt_string *s) { return (int32_t)s->length; }
 
+const char *xt_string_bytes(xt_string *s) {
+  if (!s) return NULL;
+  if (s->flat) return s->flat;
+
+  /* The tree is traversed depth-first without recursion: a loop that appends
+   * 100k times produces a 100k-deep left spine, which would overflow the C
+   * stack. Right children are pushed so the leftmost leaf is emitted first. */
+  size_t total = (size_t)s->length;
+  char *out = (char *)malloc(total + 1);
+  if (!out) {
+    fprintf(stderr, "xbintsc: out of memory flattening string\n");
+    abort();
+  }
+
+  size_t capacity = 64;
+  size_t count = 0;
+  xt_string **stack = (xt_string **)malloc(sizeof(xt_string *) * capacity);
+  if (!stack) {
+    fprintf(stderr, "xbintsc: out of memory flattening string\n");
+    abort();
+  }
+  stack[count++] = s;
+
+  size_t offset = 0;
+  while (count > 0) {
+    xt_string *node = stack[--count];
+    if (node->flat) {
+      memcpy(out + offset, node->flat, node->length);
+      offset += node->length;
+      continue;
+    }
+    if (count + 2 > capacity) {
+      while (count + 2 > capacity) capacity *= 2;
+      xt_string **grown = (xt_string **)realloc(stack, sizeof(xt_string *) * capacity);
+      if (!grown) {
+        fprintf(stderr, "xbintsc: out of memory flattening string\n");
+        abort();
+      }
+      stack = grown;
+    }
+    if (node->right) stack[count++] = node->right;
+    if (node->left) stack[count++] = node->left;
+  }
+  free(stack);
+
+  out[offset] = '\0';
+  s->flat = out;
+  s->capacity = (uint32_t)(total + 1);
+  s->left = NULL;
+  s->right = NULL;
+  return s->flat;
+}
+
 static xt_value xt_string_concat(xt_string *a, xt_string *b) {
+  if (a->length == 0) return XT_FROM_PTR(XT_TAG_STRING, b);
+  if (b->length == 0) return XT_FROM_PTR(XT_TAG_STRING, a);
   size_t total = (size_t)a->length + (size_t)b->length;
-  xt_string *out = xt_string_alloc(total);
-  memcpy(out->data, a->data, a->length);
-  memcpy(out->data + a->length, b->data, b->length);
+  if (total <= XT_STRING_CONS_THRESHOLD) {
+    xt_string *out = xt_string_alloc(total);
+    memcpy(out->flat, xt_string_bytes(a), a->length);
+    memcpy(out->flat + a->length, xt_string_bytes(b), b->length);
+    return XT_FROM_PTR(XT_TAG_STRING, out);
+  }
+  xt_string *out = (xt_string *)xt_alloc(sizeof(xt_string), XT_OBJECT_KIND_STRING);
+  out->length = (uint32_t)total;
+  out->capacity = 0;
+  out->flat = NULL;
+  out->left = a;
+  out->right = b;
   return XT_FROM_PTR(XT_TAG_STRING, out);
 }
 
 int xt_string_equals(xt_string *a, xt_string *b) {
-  return a->length == b->length && memcmp(a->data, b->data, a->length) == 0;
+  /* Interned literals (property names above all) are shared, so identity is the
+   * common case and skips the length, flattening and byte comparison entirely. */
+  if (a == b) return 1;
+  if (a->length != b->length) return 0;
+  return memcmp(xt_string_bytes(a), xt_string_bytes(b), a->length) == 0;
 }

package/scripts/bench.ts

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+/**
+ * Build and time a small, fixed benchmark suite.
+ *
+ * The numbers are wall-clock times on the current machine, so they are only
+ * useful for comparing revisions of the compiler (or the same revision against
+ * Node): run `npm run bench` before and after a change to the runtime or
+ * codegen. Each program is compiled with the normal driver (cache bypassed) and
+ * executed several times; the table reports the fastest run to reduce noise.
+ *
+ * Usage:
+ *   npm run bench                 # every benchmark, 3 runs, with Node for scale
+ *   npm run bench -- --runs 5     # more runs (minimum is reported)
+ *   npm run bench -- --filter prop
+ *   npm run bench -- --no-node    # skip the Node comparison
+ */
+
+import { spawnSync } from "node:child_process";
+import { mkdirSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { build } from "../src/driver/index.js";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const outDir = join(root, "build", "bench");
+const cacheDir = join(root, "build", "bench-cache");
+
+interface Benchmark {
+  readonly name: string;
+  /** Plain JavaScript so the same source can run under Node. */
+  readonly source: string;
+}
+
+const BENCHMARKS: readonly Benchmark[] = [
+  {
+    name: "numeric",
+    source: `
+let total = 0;
+for (let i = 0; i < 50000000; i++) total = total + i;
+console.log(total);
+`,
+  },
+  {
+    name: "property",
+    source: `
+const object = { x: 0 };
+for (let i = 0; i < 5000000; i++) object.x = object.x + 1;
+console.log(object.x);
+`,
+  },
+  {
+    name: "array",
+    source: `
+const values = [];
+for (let i = 0; i < 3000000; i++) values[i] = i;
+let total = 0;
+for (let i = 0; i < 3000000; i++) total = total + values[i];
+console.log(total);
+`,
+  },
+  {
+    name: "string-concat",
+    source: `
+let text = "";
+for (let i = 0; i < 100000; i++) text = text + "a";
+console.log(text.length);
+`,
+  },
+];
+
+interface Options {
+  readonly runs: number;
+  readonly filter?: string;
+  readonly node: boolean;
+}
+
+function parseOptions(argv: readonly string[]): Options {
+  let runs = 3;
+  let filter: string | undefined;
+  let node = true;
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index]!;
+    if (arg === "--no-node") node = false;
+    else if (arg === "--runs") runs = Math.max(1, Number(argv[++index]) || 1);
+    else if (arg.startsWith("--runs=")) runs = Math.max(1, Number(arg.slice("--runs=".length)) || 1);
+    else if (arg === "--filter") filter = argv[++index];
+    else if (arg.startsWith("--filter=")) filter = arg.slice("--filter=".length);
+    else if (arg === "--help" || arg === "-h") {
+      process.stdout.write(
+        "usage: npm run bench [-- --runs N] [--filter <substr>] [--no-node]\n",
+      );
+      process.exit(0);
+    }
+  }
+  return { runs, filter, node };
+}
+
+function minTimeMs(runs: number, execute: () => void): number {
+  let best = Number.POSITIVE_INFINITY;
+  for (let run = 0; run < runs; run++) {
+    const start = process.hrtime.bigint();
+    execute();
+    const elapsed = Number(process.hrtime.bigint() - start) / 1e6;
+    if (elapsed < best) best = elapsed;
+  }
+  return best;
+}
+
+function formatMs(value: number | undefined): string {
+  return value === undefined ? "-" : `${value.toFixed(1)} ms`;
+}
+
+function main(): number {
+  const options = parseOptions(process.argv.slice(2));
+  mkdirSync(outDir, { recursive: true });
+  mkdirSync(cacheDir, { recursive: true });
+  const benchmarks = BENCHMARKS.filter(
+    (benchmark) => options.filter === undefined || benchmark.name.includes(options.filter),
+  );
+  if (benchmarks.length === 0) {
+    process.stderr.write(`xbintsc: no benchmark matches '${options.filter}'\n`);
+    return 1;
+  }
+
+  const rows: { name: string; ours?: number; node?: number; bytes?: number }[] = [];
+  for (const benchmark of benchmarks) {
+    const entry = join(outDir, `${benchmark.name}.ts`);
+    writeFileSync(entry, benchmark.source);
+    const result = build(entry, {
+      emit: "exe",
+      outDir: join(outDir, "bin"),
+      cacheDir,
+      force: true,
+    });
+    const errors = result.diagnostics.filter((diagnostic) => diagnostic.category === "error");
+    if (errors.length > 0) {
+      for (const error of errors) process.stderr.write(`xbintsc: ${error.message}\n`);
+      return 1;
+    }
+    const bytes = statSync(result.outputPath).size;
+    const ours = minTimeMs(options.runs, () => {
+      const executed = spawnSync(result.outputPath, [], { stdio: "ignore" });
+      if (executed.status !== 0) throw new Error(`${benchmark.name} exited with ${executed.status}`);
+    });
+
+    let nodeTime: number | undefined;
+    if (options.node) {
+      const script = join(outDir, `${benchmark.name}.mjs`);
+      writeFileSync(script, benchmark.source);
+      nodeTime = minTimeMs(options.runs, () => {
+        const executed = spawnSync(process.execPath, [script], { stdio: "ignore" });
+        if (executed.status !== 0) throw new Error(`${benchmark.name} (node) exited with ${executed.status}`);
+      });
+    }
+    rows.push({ name: benchmark.name, ours, node: nodeTime, bytes });
+  }
+
+  const header = ["benchmark", "xbintsc", "node", "size"];
+  process.stdout.write(
+    `${header[0]!.padEnd(16)}${header[1]!.padStart(12)}${header[2]!.padStart(12)}${header[3]!.padStart(12)}\n`,
+  );
+  for (const row of rows) {
+    const size = row.bytes === undefined ? "-" : `${Math.round(row.bytes / 1024)} KB`;
+    process.stdout.write(
+      `${row.name.padEnd(16)}${formatMs(row.ours).padStart(12)}${formatMs(row.node).padStart(12)}${size.padStart(12)}\n`,
+    );
+  }
+  process.stdout.write(`\nfastest of ${options.runs} run(s) on ${process.platform}-${process.arch}\n`);
+  return 0;
+}
+
+process.exit(main());

package/scripts/build-runtime.ts

@@ -21,6 +21,7 @@ import { fileURLToPath } from "node:url";
 import { RUNTIME_SOURCES } from "../src/driver/compiler.js";
 import { platformSlug } from "../src/driver/paths.js";
 import { resolveToolchain } from "../src/driver/toolchain-provider.js";
+import { RUNTIME_CFLAGS } from "../src/driver/toolchain.js";
 import { nodeExtension } from "../src/extensions/node/index.js";
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
@@ -72,7 +73,7 @@ function compile(sources: readonly string[], extension: string): string[] {
     const object = join(objDir, `${extension}_${index}_${basename(source, ".c")}.o`);
     const result = spawnSync(
       clang,
-      ["-O2", "-Wall", "-Wextra", "-D_CRT_SECURE_NO_WARNINGS", "-c", source, "-o", object, `-I${runtimeDir}`],
+      [...RUNTIME_CFLAGS, "-c", source, "-o", object, `-I${runtimeDir}`],
       { stdio: "inherit", env: childEnv },
     );
     if (result.status !== 0) {

package/scripts/check-version.ts

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+/**
+ * Verify that `COMPILER_VERSION` (reported by `xbintsc version` / `doctor` and
+ * embedded in the incremental cache key) matches the version in `package.json`
+ * (which names the release archives).
+ *
+ * Release automation runs this before tagging. A mismatch means an upgraded
+ * compiler can reuse binaries produced by the previous one while presenting the
+ * wrong version to bug reports.
+ */
+
+import { readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+/** Read the version literal from the compiler source. */
+export function compilerVersionOf(root: string): string {
+  const text = readFileSync(join(root, "src", "driver", "compiler.ts"), "utf8");
+  const match = /export const COMPILER_VERSION = "([^"]+)"/.exec(text);
+  if (!match) throw new Error("COMPILER_VERSION is not declared in src/driver/compiler.ts");
+  return match[1]!;
+}
+
+/** Read the published version from package.json. */
+export function packageVersionOf(root: string): string {
+  const parsed = JSON.parse(readFileSync(join(root, "package.json"), "utf8")) as { version?: string };
+  if (!parsed.version) throw new Error("package.json has no version field");
+  return parsed.version;
+}
+
+/** Returns a human-readable mismatch message, or `undefined` when in sync. */
+export function checkCompilerVersion(root: string): string | undefined {
+  const packageVersion = packageVersionOf(root);
+  const compilerVersion = compilerVersionOf(root);
+  if (packageVersion === compilerVersion) return undefined;
+  return (
+    `COMPILER_VERSION is "${compilerVersion}" but package.json is "${packageVersion}".\n` +
+    'Update COMPILER_VERSION in src/driver/compiler.ts (it keys the incremental cache), or fix package.json.'
+  );
+}
+
+const invokedDirectly =
+  process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href;
+
+if (invokedDirectly) {
+  const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+  const mismatch = checkCompilerVersion(root);
+  if (mismatch) {
+    process.stderr.write(`xbintsc: version mismatch\n${mismatch}\n`);
+    process.exit(1);
+  }
+  process.stdout.write(`xbintsc: version ${compilerVersionOf(root)} matches package.json\n`);
+}

package/src/ast/common.ts

@@ -207,4 +207,27 @@ export interface SourceFileNode extends Node {
   readonly statements: Statement[];
   readonly fileName: string;
   readonly text: string;
+  /**
+   * For a bundled program: the original module each node was parsed from.
+   *
+   * The bundler merges every module into one `SourceFile`, but the nodes keep
+   * their module-local `start`/`end` offsets. Diagnostics must therefore report
+   * the module a node came from, not the entry file, or a cross-module error
+   * shows the wrong file and a nonsensical excerpt. Absent for a single-file
+   * compile, where `fileName` is the only source.
+   */
+  readonly origins?: Map<object, string>;
+  /**
+   * For a bundled program: the original text of every module, keyed like
+   * {@link origins}. A node's `start` is relative to its module's text, so
+   * computing a frame's line number needs that text rather than the merged
+   * concatenation in `text`.
+   */
+  readonly moduleTexts?: Map<string, string>;
+  /**
+   * Bundler-generated symbol prefixes (`m0_`, `m1_`, …). Display names (stack
+   * frames, symbol suffixes) strip them so a bundled `fail()` still shows as
+   * `fail`, not `m1_fail`.
+   */
+  readonly modulePrefixes?: readonly string[];
 }