xbintsc 0.2.8 → 0.3.1

package/runtime/xt_values.c

@@ -117,6 +117,7 @@ int xt_truthy(xt_value v) {
   if (v == XT_UNDEFINED || v == XT_NULL) return 0;
   if (v == XT_FALSE) return 0;
   if (v == XT_TRUE) return 1;
+  if (XT_IS_BIGINT(v)) return XT_GET_PTR(v) != NULL && ((xt_bigint *)XT_GET_PTR(v))->sign != 0;
   if (XT_IS_STRING(v)) return xt_as_string(v)->length != 0;
   return 1; /* objects, arrays and functions are truthy */
 }
@@ -127,6 +128,7 @@ double xt_to_number(xt_value v) {
   if (v == XT_FALSE) return 0.0;
   if (v == XT_UNDEFINED) return NAN;
   if (v == XT_NULL) return 0.0;
+  if (XT_IS_BIGINT(v)) return xt_bigint_to_double_value(v);
   if (XT_IS_STRING(v)) {
     xt_string *s = xt_as_string(v);
     if (s->length == 0) return 0.0;
@@ -151,6 +153,7 @@ xt_value xt_to_string(xt_value v) {
   if (v == XT_NULL) return xt_string_from_cstr("null");
   if (v == XT_TRUE) return xt_string_from_cstr("true");
   if (v == XT_FALSE) return xt_string_from_cstr("false");
+  if (XT_IS_BIGINT(v)) return xt_bigint_to_decimal(v);
   if (XT_IS_ARRAY(v)) {
     xt_array *a = (xt_array *)XT_GET_PTR(v);
     /* Join elements with commas, like Array.prototype.toString. */
@@ -182,6 +185,7 @@ xt_value xt_typeof(xt_value v) {
   if (XT_IS_NUMBER(v)) return xt_string_from_cstr("number");
   if (XT_IS_STRING(v)) return xt_string_from_cstr("string");
   if (v == XT_TRUE || v == XT_FALSE) return xt_string_from_cstr("boolean");
+  if (XT_IS_BIGINT(v)) return xt_string_from_cstr("bigint");
   if (v == XT_UNDEFINED) return xt_string_from_cstr("undefined");
   if (XT_IS_FUNCTION(v)) return xt_string_from_cstr("function");
   if (v == XT_NULL) return xt_string_from_cstr("object");
@@ -192,32 +196,80 @@ xt_value xt_typeof(xt_value v) {
 /* Arithmetic                                                                */
 /* ------------------------------------------------------------------------- */
 
+static void xt_throw_mixed_bigint(void) {
+  xt_throw(xt_string_from_cstr("TypeError: Cannot mix BigInt and other types, use explicit conversions"));
+}
+
 xt_value xt_add(xt_value a, xt_value b) {
   if (XT_IS_NUMBER(a) && XT_IS_NUMBER(b)) {
     return xt_number(xt_to_double(a) + xt_to_double(b));
   }
+  if (XT_IS_BIGINT(a) && XT_IS_BIGINT(b)) return xt_bigint_add(a, b);
   /* JavaScript's `+` concatenates when either operand is a string. */
   if (XT_IS_STRING(a) || XT_IS_STRING(b)) {
     xt_value sa = xt_to_string(a);
     xt_value sb = xt_to_string(b);
     return xt_string_concat(xt_as_string(sa), xt_as_string(sb));
   }
+  if (XT_IS_BIGINT(a) || XT_IS_BIGINT(b)) {
+    xt_throw_mixed_bigint();
+    return XT_UNDEFINED;
+  }
   return xt_number(xt_to_number(a) + xt_to_number(b));
 }
 
-xt_value xt_sub(xt_value a, xt_value b) { return xt_number(xt_to_number(a) - xt_to_number(b)); }
-xt_value xt_mul(xt_value a, xt_value b) { return xt_number(xt_to_number(a) * xt_to_number(b)); }
-xt_value xt_div(xt_value a, xt_value b) { return xt_number(xt_to_number(a) / xt_to_number(b)); }
+xt_value xt_sub(xt_value a, xt_value b) {
+  if (XT_IS_BIGINT(a) && XT_IS_BIGINT(b)) return xt_bigint_sub(a, b);
+  if (XT_IS_BIGINT(a) || XT_IS_BIGINT(b)) {
+    xt_throw_mixed_bigint();
+    return XT_UNDEFINED;
+  }
+  return xt_number(xt_to_number(a) - xt_to_number(b));
+}
+
+xt_value xt_mul(xt_value a, xt_value b) {
+  if (XT_IS_BIGINT(a) && XT_IS_BIGINT(b)) return xt_bigint_mul(a, b);
+  if (XT_IS_BIGINT(a) || XT_IS_BIGINT(b)) {
+    xt_throw_mixed_bigint();
+    return XT_UNDEFINED;
+  }
+  return xt_number(xt_to_number(a) * xt_to_number(b));
+}
+
+xt_value xt_div(xt_value a, xt_value b) {
+  if (XT_IS_BIGINT(a) && XT_IS_BIGINT(b)) return xt_bigint_div(a, b);
+  if (XT_IS_BIGINT(a) || XT_IS_BIGINT(b)) {
+    xt_throw_mixed_bigint();
+    return XT_UNDEFINED;
+  }
+  return xt_number(xt_to_number(a) / xt_to_number(b));
+}
 
 xt_value xt_mod(xt_value a, xt_value b) {
+  if (XT_IS_BIGINT(a) && XT_IS_BIGINT(b)) return xt_bigint_mod(a, b);
+  if (XT_IS_BIGINT(a) || XT_IS_BIGINT(b)) {
+    xt_throw_mixed_bigint();
+    return XT_UNDEFINED;
+  }
   double x = xt_to_number(a);
   double y = xt_to_number(b);
   return xt_number(fmod(x, y));
 }
 
-xt_value xt_pow(xt_value a, xt_value b) { return xt_number(pow(xt_to_number(a), xt_to_number(b))); }
-xt_value xt_neg(xt_value a) { return xt_number(-xt_to_number(a)); }
-xt_value xt_pos(xt_value a) { return xt_number(xt_to_number(a)); }
+xt_value xt_pow(xt_value a, xt_value b) {
+  if (XT_IS_BIGINT(a) && XT_IS_BIGINT(b)) return xt_bigint_pow(a, b);
+  return xt_number(pow(xt_to_number(a), xt_to_number(b)));
+}
+
+xt_value xt_neg(xt_value a) {
+  if (XT_IS_BIGINT(a)) return xt_bigint_neg(a);
+  return xt_number(-xt_to_number(a));
+}
+
+xt_value xt_pos(xt_value a) {
+  if (XT_IS_BIGINT(a)) return a;
+  return xt_number(xt_to_number(a));
+}
 
 int32_t xt_to_int32(xt_value v) {
   double d = xt_to_number(v);
@@ -225,13 +277,61 @@ int32_t xt_to_int32(xt_value v) {
   return (int32_t)(uint32_t)(int64_t)d;
 }
 
-xt_value xt_bit_and(xt_value a, xt_value b) { return xt_number((double)(xt_to_int32(a) & xt_to_int32(b))); }
-xt_value xt_bit_or(xt_value a, xt_value b) { return xt_number((double)(xt_to_int32(a) | xt_to_int32(b))); }
-xt_value xt_bit_xor(xt_value a, xt_value b) { return xt_number((double)(xt_to_int32(a) ^ xt_to_int32(b))); }
-xt_value xt_bit_not(xt_value a) { return xt_number((double)(~xt_to_int32(a))); }
-xt_value xt_shl(xt_value a, xt_value b) { return xt_number((double)(int32_t)((uint32_t)xt_to_int32(a) << (xt_to_int32(b) & 31))); }
-xt_value xt_shr(xt_value a, xt_value b) { return xt_number((double)(xt_to_int32(a) >> (xt_to_int32(b) & 31))); }
+xt_value xt_bit_and(xt_value a, xt_value b) {
+  if (XT_IS_BIGINT(a) && XT_IS_BIGINT(b)) return xt_bigint_bit_and(a, b);
+  if (XT_IS_BIGINT(a) || XT_IS_BIGINT(b)) {
+    xt_throw_mixed_bigint();
+    return XT_UNDEFINED;
+  }
+  return xt_number((double)(xt_to_int32(a) & xt_to_int32(b)));
+}
+
+xt_value xt_bit_or(xt_value a, xt_value b) {
+  if (XT_IS_BIGINT(a) && XT_IS_BIGINT(b)) return xt_bigint_bit_or(a, b);
+  if (XT_IS_BIGINT(a) || XT_IS_BIGINT(b)) {
+    xt_throw_mixed_bigint();
+    return XT_UNDEFINED;
+  }
+  return xt_number((double)(xt_to_int32(a) | xt_to_int32(b)));
+}
+
+xt_value xt_bit_xor(xt_value a, xt_value b) {
+  if (XT_IS_BIGINT(a) && XT_IS_BIGINT(b)) return xt_bigint_bit_xor(a, b);
+  if (XT_IS_BIGINT(a) || XT_IS_BIGINT(b)) {
+    xt_throw_mixed_bigint();
+    return XT_UNDEFINED;
+  }
+  return xt_number((double)(xt_to_int32(a) ^ xt_to_int32(b)));
+}
+
+xt_value xt_bit_not(xt_value a) {
+  if (XT_IS_BIGINT(a)) return xt_bigint_bit_not(a);
+  return xt_number((double)(~xt_to_int32(a)));
+}
+
+xt_value xt_shl(xt_value a, xt_value b) {
+  if (XT_IS_BIGINT(a) && XT_IS_BIGINT(b)) return xt_bigint_shl(a, b);
+  if (XT_IS_BIGINT(a) || XT_IS_BIGINT(b)) {
+    xt_throw_mixed_bigint();
+    return XT_UNDEFINED;
+  }
+  return xt_number((double)(int32_t)((uint32_t)xt_to_int32(a) << (xt_to_int32(b) & 31)));
+}
+
+xt_value xt_shr(xt_value a, xt_value b) {
+  if (XT_IS_BIGINT(a) && XT_IS_BIGINT(b)) return xt_bigint_shr(a, b);
+  if (XT_IS_BIGINT(a) || XT_IS_BIGINT(b)) {
+    xt_throw_mixed_bigint();
+    return XT_UNDEFINED;
+  }
+  return xt_number((double)(xt_to_int32(a) >> (xt_to_int32(b) & 31)));
+}
+
 xt_value xt_ushr(xt_value a, xt_value b) {
+  if (XT_IS_BIGINT(a) || XT_IS_BIGINT(b)) {
+    xt_throw(xt_string_from_cstr("TypeError: BigInts have no unsigned right shift, use >> instead"));
+    return XT_UNDEFINED;
+  }
   return xt_number((double)(uint32_t)((uint32_t)xt_to_int32(a) >> (xt_to_int32(b) & 31)));
 }
 
@@ -239,6 +339,30 @@ xt_value xt_ushr(xt_value a, xt_value b) {
 /* Comparison                                                                */
 /* ------------------------------------------------------------------------- */
 
+/** Mixed numeric/bigint comparison; returns -1/0/1, or 2 for unordered. */
+static int xt_compare_numeric(xt_value a, xt_value b) {
+  if (XT_IS_BIGINT(a) && XT_IS_BIGINT(b)) return xt_bigint_compare(a, b);
+  if (XT_IS_BIGINT(a)) {
+    if (XT_IS_NUMBER(b)) return xt_bigint_compare_double(a, xt_to_double(b));
+    if (XT_IS_STRING(b)) {
+      double n = xt_to_number(b);
+      if (isnan(n)) return 2;
+      return xt_bigint_compare_double(a, n);
+    }
+    if (b == XT_TRUE) return xt_bigint_compare_double(a, 1.0);
+    if (b == XT_FALSE) return xt_bigint_compare_double(a, 0.0);
+    return 2;
+  }
+  if (XT_IS_BIGINT(b)) {
+    int cmp = xt_compare_numeric(b, a);
+    return cmp == 2 ? 2 : -cmp;
+  }
+  double x = xt_to_number(a);
+  double y = xt_to_number(b);
+  if (isnan(x) || isnan(y)) return 2;
+  return x < y ? -1 : (x > y ? 1 : 0);
+}
+
 xt_value xt_lt(xt_value a, xt_value b) {
   if (XT_IS_STRING(a) && XT_IS_STRING(b)) {
     xt_string *x = xt_as_string(a);
@@ -248,6 +372,7 @@ xt_value xt_lt(xt_value a, xt_value b) {
     if (cmp == 0) return xt_bool(x->length < y->length);
     return xt_bool(cmp < 0);
   }
+  if (XT_IS_BIGINT(a) || XT_IS_BIGINT(b)) return xt_bool(xt_compare_numeric(a, b) == -1);
   return xt_bool(xt_to_number(a) < xt_to_number(b));
 }
 
@@ -260,6 +385,10 @@ xt_value xt_le(xt_value a, xt_value b) {
     if (cmp == 0) return xt_bool(x->length <= y->length);
     return xt_bool(cmp < 0);
   }
+  if (XT_IS_BIGINT(a) || XT_IS_BIGINT(b)) {
+    int cmp = xt_compare_numeric(a, b);
+    return xt_bool(cmp != 2 && cmp <= 0);
+  }
   return xt_bool(xt_to_number(a) <= xt_to_number(b));
 }
 
@@ -271,6 +400,19 @@ static int xt_loose_equals(xt_value a, xt_value b) {
   if (XT_IS_STRING(a) && XT_IS_STRING(b)) return xt_string_equals(xt_as_string(a), xt_as_string(b));
   if (a == b) return 1;
   if ((a == XT_NULL && b == XT_UNDEFINED) || (a == XT_UNDEFINED && b == XT_NULL)) return 1;
+  if (XT_IS_BIGINT(a) || XT_IS_BIGINT(b)) {
+    xt_value big = XT_IS_BIGINT(a) ? a : b;
+    xt_value other = XT_IS_BIGINT(a) ? b : a;
+    if (XT_IS_BIGINT(other)) return xt_bigint_compare(big, other) == 0;
+    if (XT_IS_NUMBER(other)) return xt_bigint_compare_double(big, xt_to_double(other)) == 0;
+    if (XT_IS_STRING(other)) {
+      int cmp = xt_compare_numeric(big, other);
+      return cmp == 0;
+    }
+    if (other == XT_TRUE) return xt_bigint_compare_double(big, 1.0) == 0;
+    if (other == XT_FALSE) return xt_bigint_compare_double(big, 0.0) == 0;
+    return 0;
+  }
   if (XT_IS_BOOL(a)) return xt_loose_equals(xt_number(xt_to_number(a)), b);
   if (XT_IS_BOOL(b)) return xt_loose_equals(a, xt_number(xt_to_number(b)));
   if (XT_IS_STRING(a) && XT_IS_NUMBER(b)) return xt_to_number(a) == xt_to_double(b);
@@ -284,6 +426,7 @@ xt_value xt_ne(xt_value a, xt_value b) { return xt_bool(!xt_loose_equals(a, b));
 xt_value xt_seq(xt_value a, xt_value b) {
   if (XT_IS_NUMBER(a) && XT_IS_NUMBER(b)) return xt_bool(xt_to_double(a) == xt_to_double(b));
   if (XT_IS_STRING(a) && XT_IS_STRING(b)) return xt_bool(xt_string_equals(xt_as_string(a), xt_as_string(b)));
+  if (XT_IS_BIGINT(a) && XT_IS_BIGINT(b)) return xt_bool(xt_bigint_compare(a, b) == 0);
   return xt_bool(a == b);
 }
 

package/scripts/build-runtime.ts

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+/**
+ * Build the prebuilt runtime archives shipped with xbintsc:
+ *
+ *   runtime/lib/<os>-<arch>/core.a       compiled from RUNTIME_SOURCES
+ *   runtime/lib/<os>-<arch>/ext_node.a   compiled from nodeExtension.runtimeSources()
+ *
+ * The driver prefers these archives (see `src/driver/runtime-lib.ts`) and falls
+ * back to compiling the C sources on demand when they are missing. Run this in
+ * CI (or locally) after the runtime sources change.
+ *
+ * Environment:
+ *   xbintsc_CLANG  C compiler override (otherwise the resolved toolchain is used)
+ *   xbintsc_AR     archiver override (otherwise `llvm-ar`, then `ar`)
+ */
+
+import { mkdirSync, rmSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { basename, dirname, join, resolve } from "node:path";
+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 { nodeExtension } from "../src/extensions/node/index.js";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const runtimeDir = join(root, "runtime");
+const outDir = join(runtimeDir, "lib", platformSlug());
+const objDir = join(root, "build", "runtime-obj");
+
+if (process.platform === "win32") {
+  // The Windows release ships no prebuilt archives yet: the current MSVC CI
+  // cannot produce MinGW-compatible objects, so the driver compiles the C
+  // sources on demand. Revisit once the bundled MinGW-w64 ABI lands.
+  // See doc/self-contained-roadmap.md.
+  console.log("xbintsc: skipped runtime archives on Windows until the MinGW-w64 toolchain lands");
+  process.exit(0);
+}
+
+// Use the same toolchain the driver will: a bundled clang when present, with its
+// `LD_LIBRARY_PATH` (the legacy `libtinfo.so.5` on Linux) threaded through.
+const toolchain = resolveToolchain();
+const clang = toolchain.clang;
+const childEnv = Object.assign({}, process.env, toolchain.env);
+
+function isRunnable(candidate: string): boolean {
+  // An existing tool may still exit non-zero for `--version` (Apple `ar` does);
+  // we only care that spawning it did not fail with ENOENT.
+  return !spawnSync(candidate, [], { encoding: "utf8" }).error;
+}
+
+function findArchiver(clangPath: string): string {
+  const dir = dirname(clangPath);
+  const exe = process.platform === "win32" ? ".exe" : "";
+  const candidates = [
+    process.env.xbintsc_AR,
+    // A bundled toolchain ships `llvm-ar` next to clang.
+    dir === "." ? undefined : join(dir, `llvm-ar${exe}`),
+    "llvm-ar",
+    "ar",
+  ].filter((candidate): candidate is string => Boolean(candidate));
+  for (const candidate of candidates) {
+    if (isRunnable(candidate)) return candidate;
+  }
+  console.error("xbintsc: no archiver found; set xbintsc_AR to llvm-ar or ar");
+  process.exit(1);
+}
+
+function compile(sources: readonly string[], extension: string): string[] {
+  mkdirSync(objDir, { recursive: true });
+  const objects: string[] = [];
+  sources.forEach((source, index) => {
+    const object = join(objDir, `${extension}_${index}_${basename(source, ".c")}.o`);
+    const result = spawnSync(
+      clang,
+      ["-O2", "-D_CRT_SECURE_NO_WARNINGS", "-c", source, "-o", object, `-I${runtimeDir}`],
+      { stdio: "inherit", env: childEnv },
+    );
+    if (result.status !== 0) {
+      console.error(`xbintsc: failed to compile ${source}`);
+      process.exit(result.status ?? 1);
+    }
+    objects.push(object);
+  });
+  return objects;
+}
+
+function archive(name: string, objects: string[], ar: string): void {
+  mkdirSync(outDir, { recursive: true });
+  const output = join(outDir, name);
+  rmSync(output, { force: true });
+  const result = spawnSync(ar, ["rcs", output, ...objects], { stdio: "inherit", env: childEnv });
+  if (result.status !== 0) {
+    console.error(`xbintsc: failed to archive ${name}`);
+    process.exit(result.status ?? 1);
+  }
+  console.log(`xbintsc: wrote ${output}`);
+}
+
+console.log(`xbintsc: runtime toolchain ${clang} (${toolchain.source})`);
+const coreObjects = compile(RUNTIME_SOURCES.map((source) => join(runtimeDir, source)), "core");
+
+const ar = findArchiver(clang);
+archive("core.a", coreObjects, ar);
+
+const nodeSources = nodeExtension.runtimeSources?.() ?? [];
+if (nodeSources.length > 0) {
+  archive("ext_node.a", compile(nodeSources, "node"), ar);
+}

package/scripts/fetch-toolchain.ts

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+/**
+ * Download the pinned toolchain that xbintsc bundles for this host into
+ * `vendor/<os>-<arch>/`, so `build` needs no user-installed compiler:
+ *
+ *   Linux   -> official LLVM release (clang + lld + llvm-ar) plus the legacy
+ *              `libtinfo.so.5` shared library the official build still needs
+ *   Windows -> llvm-mingw (clang + lld + MinGW-w64 CRT/import libraries)
+ *   macOS   -> nothing; the Xcode Command Line Tools are the prerequisite
+ *
+ * Requires `curl`, `tar` and (on Linux) `ar` on PATH; all are present on
+ * GitHub-hosted runners. Pass `--force` to refetch an existing toolchain.
+ */
+
+import { copyFileSync, existsSync, mkdirSync, rmSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { platformSlug, vendorRootDir } from "../src/driver/paths.js";
+import { toolchainDownload, toolchainSupportLibraries } from "../src/driver/toolchain-download.js";
+
+const force = process.argv.includes("--force");
+const target = toolchainDownload();
+
+if (!target) {
+  console.log(
+    `xbintsc: no bundled toolchain for ${platformSlug()}; using the system SDK (macOS: Xcode Command Line Tools)`,
+  );
+  process.exit(0);
+}
+
+const vendorDir = join(vendorRootDir(), platformSlug());
+const clangName = process.platform === "win32" ? "clang.exe" : "clang";
+const clangPath = join(vendorDir, "bin", clangName);
+
+function run(command: string, args: readonly string[], cwd?: string): void {
+  const result = spawnSync(command, [...args], { stdio: "inherit", cwd });
+  if (result.status !== 0) {
+    console.error(`xbintsc: command failed: ${command} ${args.join(" ")}`);
+    process.exit(result.status ?? 1);
+  }
+}
+
+/** Download the first reachable URL to `dest`, failing after the last one. */
+function download(urls: readonly string[], dest: string): void {
+  for (const url of urls) {
+    console.log(`xbintsc: downloading ${url}`);
+    const result = spawnSync("curl", ["-fL", "--retry", "3", "-o", dest, url], { stdio: "inherit" });
+    if (result.status === 0) return;
+    console.log("xbintsc: download failed, trying the next mirror");
+  }
+  console.error(`xbintsc: could not download ${dest}`);
+  process.exit(1);
+}
+
+const workDir = join(tmpdir(), `xbintsc-toolchain-${process.pid}`);
+rmSync(workDir, { recursive: true, force: true });
+mkdirSync(workDir, { recursive: true });
+
+if (existsSync(clangPath) && !force) {
+  console.log(`xbintsc: toolchain already present at ${vendorDir}`);
+} else {
+  const archivePath = join(workDir, target.archive);
+  download([target.url], archivePath);
+  console.log(`xbintsc: extracting into ${vendorDir}`);
+  mkdirSync(vendorDir, { recursive: true });
+  // `tar` here is bsdtar on macOS/Windows and GNU tar on Linux; both accept
+  // `--strip-components`, and bsdtar also unpacks the `.zip` used on Windows.
+  run("tar", ["-xf", archivePath, "-C", vendorDir, `--strip-components=${target.stripComponents}`]);
+}
+
+// Shared libraries the bundled toolchain needs but the OS does not provide.
+const supportLibraries = toolchainSupportLibraries();
+if (supportLibraries.length > 0) {
+  const libDir = join(vendorDir, "lib");
+  mkdirSync(libDir, { recursive: true });
+  for (const library of supportLibraries) {
+    const dest = join(libDir, library.dest);
+    if (existsSync(dest) && !force) {
+      console.log(`xbintsc: already bundled ${library.dest}`);
+      continue;
+    }
+    const debPath = join(workDir, library.archive);
+    download(library.urls, debPath);
+    const debDir = join(workDir, `deb-${library.dest}`);
+    mkdirSync(debDir, { recursive: true });
+    // A `.deb` is an `ar` archive whose `data.tar.*` member holds the files.
+    run("ar", ["x", debPath], debDir);
+    run("tar", ["-xf", join(debDir, "data.tar.xz"), "-C", debDir]);
+    copyFileSync(join(debDir, library.member), dest);
+    console.log(`xbintsc: bundled ${library.dest}`);
+  }
+}
+
+rmSync(workDir, { recursive: true, force: true });
+
+if (!existsSync(clangPath)) {
+  console.error(`xbintsc: expected ${clangPath} after extraction`);
+  process.exit(1);
+}
+console.log(`xbintsc: done -> ${clangPath}`);

package/scripts/package-release.ts

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+/**
+ * Assemble a self-contained release archive for the current platform:
+ *
+ *   dist/release/xbintsc-<os>-<arch>.tar.gz        (or .tar.zst)
+ *   dist/release/xbintsc-<os>-<arch>.tar.gz.sha256
+ *
+ * The unpacked staging tree is built under `build/release-stage/`, never under
+ * `dist/release/`, so an upload glob over `dist/release/*` cannot accidentally
+ * ship the (multi-GB) tree alongside the archive.
+ *
+ * Layout inside the archive:
+ *
+ *   xbintsc-<os>-<arch>/
+ *     bin/xbintsc[.exe]     the self-hosted compiler
+ *     runtime/              C runtime sources + prebuilt runtime/lib/<slug>
+ *     vendor/<slug>/        the bundled clang+lld toolchain (Linux/Windows)
+ *     README.md
+ *
+ * The compiler locates `runtime/` and `vendor/` relative to its own executable
+ * (see `findRuntimeDir`/`findVendorDir`), so this tree runs with no system
+ * toolchain installed.
+ *
+ * Inputs:
+ *   - the self-hosted binary staged at `dist/xbintsc[.exe]` (CI copies it there)
+ *   - `vendor/<slug>/`, fetched by `scripts/fetch-toolchain.ts`
+ *   - `runtime/lib/<slug>/`, built by `scripts/build-runtime.ts`
+ */
+
+import { createHash } from "node:crypto";
+import {
+  copyFileSync,
+  cpSync,
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { spawnSync } from "node:child_process";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  findRuntimeDir,
+  platformSlug,
+  releaseArchiveBase,
+  releaseArchiveExtension,
+} from "../src/driver/paths.js";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const slug = platformSlug();
+const base = releaseArchiveBase();
+const exeSuffix = process.platform === "win32" ? ".exe" : "";
+
+function fail(message: string): never {
+  console.error(`xbintsc: ${message}`);
+  process.exit(1);
+}
+
+/** First existing path from a list of candidates. */
+function firstExisting(candidates: readonly string[]): string | undefined {
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return undefined;
+}
+
+/**
+ * Copy only the parts of the fetched toolchain that xbintsc actually runs.
+ *
+ * The official LLVM release unpacks to ~7 GB: every MLIR/Flang/lldb tool, the
+ * static archives and the full C++ headers. The compiler only shells out to the
+ * clang driver, the lld linker and llvm-ar, and clang additionally needs its own
+ * resource directory (`lib/clang/<version>`, the builtin headers and
+ * compiler-rt). Copying just those keeps the archive ~100x smaller.
+ */
+function stageToolchain(vendor: string, dest: string): void {
+  const exe = process.platform === "win32" ? ".exe" : "";
+  mkdirSync(join(dest, "bin"), { recursive: true });
+
+  const real = (...candidates: readonly string[]): string | undefined => {
+    const found = firstExisting(candidates.map((candidate) => join(vendor, candidate)));
+    return found ? realpathSync(found) : undefined;
+  };
+  const copyAs = (source: string | undefined, name: string): void => {
+    if (!source) return;
+    const target = join(dest, "bin", name);
+    copyFileSync(source, target);
+    if (process.platform !== "win32") chmodSync(target, 0o755);
+  };
+
+  // In the official release `clang`/`ld.lld` are symlinks into the bin/ dir;
+  // copy the resolved targets under the names the toolchain provider (and
+  // clang's `-fuse-ld=lld`) expect next to `bin/clang`.
+  copyAs(real(`bin/clang${exe}`, `bin/clang-18${exe}`), `clang${exe}`);
+  copyAs(real(`bin/ld.lld${exe}`, `bin/lld${exe}`), `ld.lld${exe}`);
+  copyAs(real(`bin/llvm-ar${exe}`, "bin/llvm-ar"), `llvm-ar${exe}`);
+
+  // clang's resource directory: builtin headers + compiler-rt archives.
+  const resourceDir = join(vendor, "lib", "clang");
+  if (existsSync(resourceDir)) {
+    cpSync(resourceDir, join(dest, "lib", "clang"), { recursive: true });
+  }
+
+  // Shared libraries the fetch placed next to the toolchain (on Linux that is
+  // the legacy `libtinfo.so.5` the official build still links).
+  const libDir = join(vendor, "lib");
+  if (existsSync(libDir)) {
+    for (const entry of readdirSync(libDir, { withFileTypes: true })) {
+      if (/^(.*\.so(\.\d+)*|.*\.dylib|.*\.dll)$/.test(entry.name)) {
+        cpSync(join(libDir, entry.name), join(dest, "lib", entry.name), { recursive: true });
+      }
+    }
+  }
+}
+
+const distDir = join(root, "dist");
+const binary = firstExisting([
+  join(distDir, `xbintsc${exeSuffix}`),
+  join(distDir, "main" + exeSuffix),
+  join(root, "scratch", "self", `main${exeSuffix}`),
+]);
+if (!binary) {
+  fail(`no self-hosted binary found under ${distDir} (expected dist/xbintsc${exeSuffix})`);
+}
+
+// Archives go to `dist/release/`; the unpacked staging tree goes to
+// `build/release-stage/` so the upload glob over `dist/release/*` cannot pick up
+// the raw tree (which would ship the toolchain twice, and uncompressed).
+const releaseRoot = join(distDir, "release");
+const stageRoot = join(root, "build", "release-stage");
+const stage = join(stageRoot, base);
+rmSync(stage, { recursive: true, force: true });
+mkdirSync(join(stage, "bin"), { recursive: true });
+mkdirSync(releaseRoot, { recursive: true });
+
+// 1. The compiler binary.
+const stagedBinary = join(stage, "bin", `xbintsc${exeSuffix}`);
+copyFileSync(binary, stagedBinary);
+if (process.platform !== "win32") chmodSync(stagedBinary, 0o755);
+console.log(`xbintsc: packaged binary ${basename(binary)} (${statSync(binary).size} bytes)`);
+
+// 2. The C runtime (sources fallback + prebuilt archives) next to the binary.
+cpSync(findRuntimeDir(), join(stage, "runtime"), { recursive: true });
+console.log("xbintsc: packaged runtime/");
+
+// 3. The bundled toolchain, when one was fetched for this platform.
+const vendor = join(root, "vendor", slug);
+if (existsSync(join(vendor, "bin"))) {
+  if (process.platform === "win32") {
+    // llvm-mingw spreads its MinGW-w64 CRT/import libraries across the tree, so
+    // bundling it whole is the safe default there for now.
+    cpSync(vendor, join(stage, "vendor", slug), { recursive: true });
+  } else {
+    stageToolchain(vendor, join(stage, "vendor", slug));
+  }
+  console.log(`xbintsc: packaged vendor/${slug}/`);
+} else if (process.platform === "linux" || process.platform === "win32") {
+  console.warn(
+    `xbintsc: warning: no vendor/${slug}/ found; the release will rely on a system toolchain. ` +
+      "Run `npm run fetch-toolchain` first for a self-contained archive.",
+  );
+} else {
+  console.log(`xbintsc: no bundled toolchain for ${slug}; relying on the system SDK (macOS)`);
+}
+
+// 4. Human-facing notes.
+for (const name of ["README.md", "LICENSE"]) {
+  const source = join(root, name);
+  if (existsSync(source)) copyFileSync(source, join(stage, name));
+}
+
+// 5. Archive it. Prefer zstd when available, otherwise gzip.
+const hasZstd = !spawnSync("zstd", ["--version"], { stdio: "ignore" }).error;
+const extension = releaseArchiveExtension(hasZstd);
+const archive = join(releaseRoot, `${base}${extension}`);
+rmSync(archive, { force: true });
+const tarArgs = ["-c", hasZstd ? "--zstd" : "-z", "-f", archive, "-C", stageRoot, base];
+const tar = spawnSync("tar", tarArgs, { stdio: "inherit" });
+if (tar.error) fail(`failed to run tar: ${tar.error.message}`);
+if (tar.status !== 0) fail(`tar exited with ${tar.status}`);
+
+// 6. Checksum, so users can verify the download.
+const digest = createHash("sha256").update(readFileSync(archive)).digest("hex");
+writeFileSync(`${archive}.sha256`, `${digest}  ${basename(archive)}\n`);
+
+console.log(`xbintsc: wrote ${archive} (${statSync(archive).size} bytes)`);
+console.log(`xbintsc: sha256 ${digest}`);

package/src/ast/expressions.ts

@@ -113,6 +113,8 @@ export interface PropertyAssignment extends Node {
 export interface ShorthandPropertyAssignment extends Node {
   readonly kind: SyntaxKind.ShorthandPropertyAssignment;
   readonly name: Identifier;
+  /** Present for `{ a = default }` when used as a destructuring target. */
+  readonly initializer?: Expression;
 }
 
 export interface SpreadElement extends Node {