xbintsc 0.3.5 → 0.3.7

package/runtime/rt_internal.h

@@ -235,9 +235,11 @@ typedef struct xt_try_frame {
  *    `_setjmp(jmp_buf, void *frame)` itself, so the frame must be passed
  *    explicitly -- exactly what its own `setjmp` macro does.
  *
- * The generated IR always emits the two-argument form, because it is already
- * IR and clang will not rewrite it. `_setjmp` (rather than the `setjmp` macro)
- * is used so it pairs with the plain `longjmp` in `xt_throw`. */
+ * The generated IR emits the two-argument form, because it is already IR and
+ * clang will not rewrite it. On Windows ARM64 it names `_setjmpex` (and the
+ * entry stack pointer from `llvm.sponentry`) instead, matching clang's own
+ * lowering there. `_setjmp`/`_setjmpex` (rather than the `setjmp` macro) is
+ * used so it pairs with the plain `longjmp` in `xt_throw`. */
 #if defined(_WIN32) && !defined(__MINGW32__)
 #define xt_try_setjmp(framePtr) _setjmp(((xt_try_frame *)(framePtr))->buf)
 #elif defined(_WIN32) && defined(__aarch64__)

package/runtime/xt_ext.h

@@ -0,0 +1,109 @@
+/*
+ * xbintsc native-extension helper header.
+ *
+ * Include this from a C or C++ extension that xbintsc links into a generated
+ * binary. It pulls in the runtime ABI (`rt.h`) and adds small helpers for the
+ * common job of reading the `(argc, argv)` arguments and building result
+ * values. In C++ everything is wrapped in `extern "C"` by `rt.h`, so a
+ * definition like
+ *
+ *     XT_EXT_FN(mathx_add) {
+ *       double a = xt_ext_number(argc, argv, 0, 0);
+ *       double b = xt_ext_number(argc, argv, 1, 0);
+ *       return xt_number(a + b);
+ *     }
+ *
+ * exports a symbol callable from TypeScript (via a native manifest) without any
+ * name mangling.
+ *
+ * Build the extension with the same clang that xbintsc uses, keeping the
+ * runtime directory on the include path:
+ *
+ *     clang++ -O2 -fPIC -I<runtime> -c mathx.cpp -o mathx.o
+ *     ar rcs libmathx.a mathx.o
+ */
+#ifndef XT_EXT_H
+#define XT_EXT_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "rt.h"
+
+#ifdef __cplusplus
+#define XT_EXT_FN(name) extern "C" xt_value name(int32_t argc, xt_value *argv)
+#else
+#define XT_EXT_FN(name) xt_value name(int32_t argc, xt_value *argv)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * XT_EXT_FN(name) declares/defines an exported entry point with the signature
+ * the code generator uses for builtins and module exports:
+ *
+ *     xt_value name(int32_t argc, xt_value *argv);
+ *
+ * In C++ it also gives the definition C linkage, so the symbol is never
+ * name-mangled and the manifest can reference it directly.
+ */
+
+/** The `index`-th argument, or `undefined` when it was not supplied. */
+static inline xt_value xt_ext_arg(int32_t argc, xt_value *argv, int32_t index) {
+  if (argv == NULL || index < 0 || index >= argc) return XT_UNDEFINED;
+  return argv[index];
+}
+
+/** The `index`-th argument coerced to a number, or `fallback` when absent. */
+static inline double xt_ext_number(int32_t argc, xt_value *argv, int32_t index, double fallback) {
+  xt_value value = xt_ext_arg(argc, argv, index);
+  if (XT_IS_UNDEFINED(value)) return fallback;
+  return xt_to_number(value);
+}
+
+/** The `index`-th argument coerced to a 32-bit integer. */
+static inline int32_t xt_ext_int(int32_t argc, xt_value *argv, int32_t index, int32_t fallback) {
+  return (int32_t)xt_ext_number(argc, argv, index, (double)fallback);
+}
+
+/** The `index`-th argument coerced to a boolean. */
+static inline int xt_ext_bool(int32_t argc, xt_value *argv, int32_t index, int fallback) {
+  xt_value value = xt_ext_arg(argc, argv, index);
+  if (XT_IS_UNDEFINED(value)) return fallback;
+  return xt_truthy(value);
+}
+
+/**
+ * Borrow the UTF-8 bytes of the `index`-th argument when it is a string.
+ * Returns `NULL` and stores 0 in `*length` otherwise. The pointer stays valid
+ * for the lifetime of the value (the runtime arena never frees).
+ */
+static inline const char *xt_ext_string(int32_t argc, xt_value *argv, int32_t index, size_t *length) {
+  xt_value value = xt_ext_arg(argc, argv, index);
+  if (!XT_IS_STRING(value)) {
+    if (length != NULL) *length = 0;
+    return NULL;
+  }
+  if (length != NULL) *length = (size_t)xt_string_length_value(value);
+  return xt_string_data(value);
+}
+
+/** Build a string value from bytes. */
+static inline xt_value xt_ext_string_value(const char *data, size_t length) {
+  return xt_string_new(data, length);
+}
+
+#ifdef __cplusplus
+} /* extern "C" */
+
+#include <string>
+
+/** Convenience overload for `std::string` / string literals in C++. */
+static inline xt_value xt_ext_string_from(const std::string &text) {
+  return xt_string_new(text.data(), text.size());
+}
+#endif /* __cplusplus */
+
+#endif /* XT_EXT_H */

package/runtime/xt_ext.rs

@@ -0,0 +1,173 @@
+// xbintsc native-extension bindings for Rust.
+//
+// Include this file from a Rust `staticlib`/`cdylib` that xbintsc links into a
+// generated binary:
+//
+//     // src/lib.rs
+//     include!("../../runtime/xt_ext.rs");
+//
+//     #[no_mangle]
+//     pub extern "C" fn mathx_add(argc: i32, argv: *const XtValue) -> XtValue {
+//         let a = arg_number(argc, argv, 0, 0.0);
+//         let b = arg_number(argc, argv, 1, 0.0);
+//         xt_number(a + b)
+//     }
+//
+// The exported functions use the runtime ABI, so a native manifest maps them
+// exactly like C or C++ symbols: `xt_value name(int32_t argc, xt_value *argv)`.
+//
+// Build with the runtime directory reachable and produce a static library:
+//
+//     cargo build --release      # crate-type = ["staticlib"]
+//     # -> target/release/libmathx.a
+
+/// A JavaScript value: a 64-bit NaN-boxed word (see `runtime/rt.h`).
+pub type XtValue = u64;
+
+pub const XT_TAG_MASK: XtValue = 0xFFFF_0000_0000_0000;
+pub const XT_NUMBER_MASK: XtValue = 0xFFF8_0000_0000_0000;
+
+pub const XT_UNDEFINED: XtValue = 0xFFF8_0000_0000_0000;
+pub const XT_NULL: XtValue = 0xFFF9_0000_0000_0000;
+pub const XT_FALSE: XtValue = 0xFFFA_0000_0000_0000;
+pub const XT_TAG_STRING: XtValue = 0xFFFC_0000_0000_0000;
+
+// Raw runtime entry points. They are wrapped in safe helpers below so that
+// extension authors never have to spell `unsafe` just to build a value.
+extern "C" {
+    #[link_name = "xt_number"]
+    fn raw_xt_number(d: f64) -> XtValue;
+    #[link_name = "xt_string_new"]
+    fn raw_xt_string_new(data: *const u8, len: usize) -> XtValue;
+    #[link_name = "xt_string_data"]
+    fn raw_xt_string_data(value: XtValue) -> *const u8;
+    #[link_name = "xt_string_length_value"]
+    fn raw_xt_string_length_value(value: XtValue) -> i32;
+    #[link_name = "xt_truthy"]
+    fn raw_xt_truthy(value: XtValue) -> i32;
+    #[link_name = "xt_to_number"]
+    fn raw_xt_to_number(value: XtValue) -> f64;
+    #[link_name = "xt_to_string"]
+    fn raw_xt_to_string(value: XtValue) -> XtValue;
+    #[link_name = "xt_array_new"]
+    fn raw_xt_array_new(count: i32, items: *mut XtValue) -> XtValue;
+}
+
+/// Box an `f64` into a JavaScript number value.
+#[inline]
+pub fn xt_number(d: f64) -> XtValue {
+    unsafe { raw_xt_number(d) }
+}
+
+/// Build a string value from a byte slice (assumed UTF-8).
+#[inline]
+pub fn xt_string_new(data: *const u8, len: usize) -> XtValue {
+    unsafe { raw_xt_string_new(data, len) }
+}
+
+/// Pointer to the first byte of a string value's payload.
+#[inline]
+pub fn xt_string_data(value: XtValue) -> *const u8 {
+    unsafe { raw_xt_string_data(value) }
+}
+
+/// Byte length of a string value.
+#[inline]
+pub fn xt_string_length_value(value: XtValue) -> i32 {
+    unsafe { raw_xt_string_length_value(value) }
+}
+
+/// JavaScript truthiness of a value (`0`/`1`).
+#[inline]
+pub fn xt_truthy(value: XtValue) -> i32 {
+    unsafe { raw_xt_truthy(value) }
+}
+
+/// Convert a value to a number, coercing non-numbers like the runtime does.
+#[inline]
+pub fn xt_to_number(value: XtValue) -> f64 {
+    unsafe { raw_xt_to_number(value) }
+}
+
+/// Convert a value to a string value.
+#[inline]
+pub fn xt_to_string(value: XtValue) -> XtValue {
+    unsafe { raw_xt_to_string(value) }
+}
+
+/// Build an array from `count` items.
+#[inline]
+pub fn xt_array_new(count: i32, items: *mut XtValue) -> XtValue {
+    unsafe { raw_xt_array_new(count, items) }
+}
+
+/// Whether a value carries the number (unboxed double) representation.
+#[inline]
+pub fn is_number(value: XtValue) -> bool {
+    (value & XT_NUMBER_MASK) != XT_NUMBER_MASK
+}
+
+/// Whether a value is a string.
+#[inline]
+pub fn is_string(value: XtValue) -> bool {
+    (value & XT_TAG_MASK) == XT_TAG_STRING
+}
+
+/// Reinterpret an unboxed number value as `f64`.
+#[inline]
+pub fn as_f64(value: XtValue) -> f64 {
+    f64::from_bits(value)
+}
+
+/// Read argument `index`, returning `undefined` when it was not supplied.
+///
+/// `argv` may be null when a function is called with no arguments.
+#[inline]
+pub fn arg(argc: i32, argv: *const XtValue, index: usize) -> XtValue {
+    if argv.is_null() || index >= argc as usize {
+        return XT_UNDEFINED;
+    }
+    unsafe { *argv.add(index) }
+}
+
+/// Read argument `index` coerced to a number, or `fallback` when absent.
+#[inline]
+pub fn arg_number(argc: i32, argv: *const XtValue, index: usize, fallback: f64) -> f64 {
+    let value = arg(argc, argv, index);
+    if value == XT_UNDEFINED {
+        return fallback;
+    }
+    xt_to_number(value)
+}
+
+/// Read argument `index` coerced to a boolean.
+#[inline]
+pub fn arg_bool(argc: i32, argv: *const XtValue, index: usize, fallback: bool) -> bool {
+    let value = arg(argc, argv, index);
+    if value == XT_UNDEFINED {
+        return fallback;
+    }
+    xt_truthy(value) != 0
+}
+
+/// Borrow argument `index` as a UTF-8 string slice, or `None` when it is not a
+/// string. The bytes live in the runtime arena and never move.
+#[inline]
+pub fn arg_str<'a>(argc: i32, argv: *const XtValue, index: usize) -> Option<&'a str> {
+    let value = arg(argc, argv, index);
+    if !is_string(value) {
+        return None;
+    }
+    let length = xt_string_length_value(value) as usize;
+    let data = xt_string_data(value);
+    if data.is_null() || length == 0 {
+        return Some("");
+    }
+    unsafe { Some(core::str::from_utf8_unchecked(core::slice::from_raw_parts(data, length))) }
+}
+
+/// Build a string value from a Rust string slice.
+#[inline]
+pub fn string_from(text: &str) -> XtValue {
+    xt_string_new(text.as_ptr(), text.len())
+}

package/runtime/xt_io.c

@@ -5,20 +5,21 @@
  * innermost frame when one is active and otherwise prints + exits. Also holds
  * `print`/`console` output and the Node-like value inspector.
  *
- * The generated IR calls `_setjmp` with two arguments — the jmp_buf and the
- * caller's frame address (`@llvm.frameaddress(0)`) — paired with `longjmp`
- * here. This is exactly what clang lowers a C `_setjmp(buf)` call to on MSVC:
- * on Windows the UCRT `_setjmp` stores that frame in `_JUMP_BUFFER.Frame` and
- * `longjmp` passes it to `RtlUnwind` to run the unwind, so omitting it makes
- * `longjmp` unwind to a bogus target (`STATUS_BAD_FUNCTION_TABLE`,
- * 0xC00000FF). Because the generated call is IR it must pass the frame
- * explicitly; the C runtime (see `xt_try_setjmp`) instead follows whatever
- * the active `<setjmp.h>` declares -- one argument on MSVC (clang injects the
- * frame) and two on MinGW-w64. `_setjmp` is used
- * rather than the exported `setjmp` symbol, whose Windows ABI is an
- * incompatible two-argument routine; on Linux/macOS `_setjmp` takes only the
- * buffer and pairs with `longjmp` (the XSI `_longjmp` does not exist on
- * Windows).
+ * The generated IR saves each frame with a `setjmp`-family call that passes
+ * the frame explicitly — the jmp_buf plus a frame pointer — because the call
+ * is already IR and clang will not rewrite it. On Linux/macOS that is
+ * `_setjmp(buf, frame)`; the extra argument is ignored. On Windows the UCRT
+ * `_setjmp` stores the frame in `_JUMP_BUFFER.Frame` and `longjmp` passes it
+ * to `RtlUnwind` to run the unwind, so omitting it makes `longjmp` unwind to a
+ * bogus target (`STATUS_BAD_FUNCTION_TABLE`, 0xC00000FF). Windows ARM64 has
+ * no `_setjmp` at all: the generated IR uses `_setjmpex(buf, entry-sp)` with
+ * the stack pointer on entry (`@llvm.sponentry`), exactly as clang lowers a C
+ * `setjmp` there. The C runtime (see `xt_try_setjmp`) calls whatever the
+ * active `<setjmp.h>` declares — one argument on MSVC (clang injects the
+ * frame) and two on MinGW-w64. `_setjmp`/`_setjmpex` are used rather than the
+ * exported `setjmp` symbol, whose Windows ABI is an incompatible two-argument
+ * routine; on Linux/macOS `_setjmp` takes only the buffer and pairs with
+ * `longjmp` (the XSI `_longjmp` does not exist on Windows).
  */
 
 #include "rt_internal.h"

package/src/cli/main.ts

@@ -5,6 +5,7 @@
  * available programmatically through the driver API:
  *
  *   xbintsc build <file> [-o out] [--emit ir|obj|exe] [-O0..3] [--ext node]
+ *                        [--ext-native manifest.json]
  *   xbintsc run   <file> [-- args...]
  *   xbintsc emit  <file>            # print LLVM IR to stdout
  *   xbintsc doctor                  # report the resolved toolchain
@@ -23,6 +24,7 @@ import { resolveToolchain } from "../driver/toolchain-provider.js";
 import { realRunner } from "../driver/toolchain.js";
 import { createDefaultRegistry, type ExtensionRegistry } from "../extensions/registry.js";
 import { nodeExtension } from "../extensions/node/index.js";
+import { nativeExtensionFromManifest } from "../extensions/native.js";
 
 export interface CliIo {
   readonly stdout: (text: string) => void;
@@ -41,7 +43,7 @@ interface ParsedArgs {
   readonly passthrough: string[];
 }
 
-const VALUE_FLAGS = new Set(["output", "out", "emit", "optimize", "ext"]);
+const VALUE_FLAGS = new Set(["output", "out", "emit", "optimize", "ext", "ext-native"]);
 
 function parseArgs(argv: readonly string[]): ParsedArgs {
   const positionals: string[] = [];
@@ -102,6 +104,14 @@ function buildRegistry(flags: Map<string, string | boolean>): ExtensionRegistry
       else throw new Error(`Unknown extension '${name}'`);
     }
   }
+  // 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));
+    }
+  }
   return registry;
 }
 
@@ -133,6 +143,8 @@ Options:
       --emit <kind>     exe | obj | ir (default: exe)
   -O0..-O3              Optimization level (default: -O2)
       --ext <names>     Comma separated extensions (e.g. node)
+      --ext-native <m>  Register a C++/Rust extension from a JSON manifest
+                        (comma separated for several)
       --force           Ignore the incremental cache
       --verbose         Print progress information
 `;

package/src/codegen/generator/context.ts

@@ -18,7 +18,7 @@ import type {
   ModuleExports,
 } from "../../extensions/registry.js";
 import type { CodegenOptions, FunctionState } from "./state.js";
-import { escapeBytes, isErrorFamily, kindName, utf8Bytes } from "./tables.js";
+import { escapeBytes, isErrorFamily, kindName, requiresSetjmpex, utf8Bytes } from "./tables.js";
 
 export class GeneratorContext {
   readonly binding: BindResult;
@@ -26,6 +26,8 @@ export class GeneratorContext {
   readonly diagnostics: DiagnosticBag;
   readonly builtins: Readonly<Record<string, BuiltinFunction>>;
   readonly modules: Readonly<Record<string, ExtensionModule>>;
+  /** Host the emitted IR targets (the process by default; see `CodegenOptions`). */
+  readonly target: { readonly platform: string; readonly arch: string };
   /** Imported symbol id -> the module binding it refers to. */
   readonly importExports = new Map<number, ModuleExport>();
   /** Imported symbol id -> the namespace it aliases (e.g. `path`). */
@@ -52,6 +54,7 @@ export class GeneratorContext {
     this.binding = bind(sourceFile);
     this.builtins = options.builtins ?? {};
     this.modules = options.modules ?? {};
+    this.target = options.target ?? { platform: process.platform, arch: process.arch };
     this.resolveImports();
   }
 
@@ -127,6 +130,31 @@ export class GeneratorContext {
     return `%r${this.current.reg++}`;
   }
 
+  /**
+   * Emit the `setjmp` that opens a `try` frame and return the register holding
+   * its result. The frame address is always passed explicitly because Windows
+   * `_setjmp` stores it in `_JUMP_BUFFER.Frame` for `longjmp` to unwind to; the
+   * extra argument is ignored by the one-argument `_setjmp` on Linux/macOS.
+   */
+  emitSetjmp(frame: string): string {
+    if (requiresSetjmpex(this.target.platform, this.target.arch)) {
+      // Windows ARM64 has no `_setjmp`; use `_setjmpex`, which expects the
+      // caller's stack pointer on entry (`llvm.sponentry`).
+      this.extraDeclarations.add("declare i8* @llvm.sponentry()");
+      this.extraDeclarations.add("declare i32 @_setjmpex(i8*, i8*) returns_twice");
+      const entry = this.reg();
+      this.emit(`  ${entry} = call i8* @llvm.sponentry()`);
+      const jump = this.reg();
+      this.emit(`  ${jump} = call i32 @_setjmpex(i8* ${frame}, i8* ${entry})`);
+      return jump;
+    }
+    const frameAddress = this.reg();
+    this.emit(`  ${frameAddress} = call i8* @llvm.frameaddress(i32 0)`);
+    const jump = this.reg();
+    this.emit(`  ${jump} = call i32 @_setjmp(i8* ${frame}, i8* ${frameAddress})`);
+    return jump;
+  }
+
   label(prefix: string): string {
     return `${prefix}.${this.current.label++}`;
   }

package/src/codegen/generator/state.ts

@@ -62,6 +62,11 @@ export interface CodegenOptions {
   readonly builtins?: Readonly<Record<string, BuiltinFunction>>;
   /** Importable modules supplied by registered extensions. */
   readonly modules?: Readonly<Record<string, ExtensionModule>>;
+  /**
+   * Host the IR is generated for. xbintsc builds for its own host, so this
+   * defaults to the running process; it is overridable for tests.
+   */
+  readonly target?: { readonly platform: string; readonly arch: string };
 }
 
 export const RUNTIME_DECLARATIONS: readonly string[] = [

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

@@ -166,14 +166,7 @@ export const controlFlowStatementMethods: ControlFlowStatementMethods = {
     this.emit(`  ${frame} = call i8* @xt_try_enter()`);
     this.emit(`  store i8* ${frame}, i8** ${frameSlot}`);
     this.emit(`  store i64 0, i64* ${flagSlot}`);
-    // MSVC's `_setjmp` takes the caller's frame address as a second argument
-    // (`_JUMP_BUFFER.Frame`); `longjmp` uses it to run the unwind. clang lowers
-    // a C call to `_setjmp` exactly like this. The extra argument is ignored by
-    // the one-argument `_setjmp` on Linux/macOS.
-    const frameAddress = this.reg();
-    this.emit(`  ${frameAddress} = call i8* @llvm.frameaddress(i32 0)`);
-    const jump = this.reg();
-    this.emit(`  ${jump} = call i32 @_setjmp(i8* ${frame}, i8* ${frameAddress})`);
+    const jump = this.emitSetjmp(frame);
     const isThrow = this.reg();
     this.emit(`  ${isThrow} = icmp ne i32 ${jump}, 0`);
     const exceptionTarget = hasCatch ? catchLabel : exceptionLabel;

package/src/codegen/generator/tables.ts

@@ -9,6 +9,20 @@ import {
   type Node,
 } from "../../ast/nodes.js";
 
+/**
+ * True when a `try` frame must be saved with `_setjmpex` rather than `_setjmp`.
+ *
+ * 64-bit Windows on ARM has no `_setjmp`: both the UCRT and MinGW-w64 declare
+ * `setjmp` as `_setjmpex(buf, sponentry)` there, so the linker expects
+ * `_setjmpex` (with the caller's stack pointer at entry, `llvm.sponentry`,
+ * instead of its frame pointer). clang lowers a C `setjmp` on this target to
+ * exactly that pair. Checked at code-generation time because xbintsc builds for
+ * its own host.
+ */
+export function requiresSetjmpex(platform: string, arch: string): boolean {
+  return platform === "win32" && arch === "arm64";
+}
+
 export const BINARY_RUNTIME: Record<string, string | undefined> = {
   [BinaryOperator.Add]: "xt_add",
   [BinaryOperator.Subtract]: "xt_sub",

package/src/driver/compiler.ts

@@ -160,7 +160,7 @@ export function build(entryPath: string, options: BuildOptions = {}): BuildResul
     emit,
     optimize,
     process.platform,
-    registry.all().map((e) => e.name).join(","),
+    registryFingerprint(registry),
     runtimeFingerprint(runtimeDir),
   ]);
 
@@ -209,7 +209,7 @@ export function build(entryPath: string, options: BuildOptions = {}): BuildResul
     return { outputPath, irPath, cached: false, diagnostics: [], ir };
   }
 
-  const { runtimeObjects, extensionObjects } = ensureRuntimeObjects(
+  const { runtimeObjects, extensionObjects, nativeObjects } = ensureRuntimeObjects(
     runner,
     clang,
     runtimeDir,
@@ -221,7 +221,7 @@ export function build(entryPath: string, options: BuildOptions = {}): BuildResul
 
   link(runner, {
     clang,
-    objectPaths: [objectPath, ...runtimeObjects, ...extensionObjects],
+    objectPaths: [objectPath, ...runtimeObjects, ...extensionObjects, ...nativeObjects],
     outputPath,
     linkerFlags: [
       ...toolchain.linkerArgs,
@@ -240,6 +240,8 @@ export function build(entryPath: string, options: BuildOptions = {}): BuildResul
 interface RuntimeObjects {
   readonly runtimeObjects: readonly string[];
   readonly extensionObjects: readonly string[];
+  /** Pre-built C++/Rust objects and archives contributed by native extensions. */
+  readonly nativeObjects: readonly string[];
 }
 
 /** Core runtime translation units (each compiled and cached independently). */
@@ -285,6 +287,24 @@ function runtimeFingerprint(runtimeDir: string): string {
   return hashParts(parts);
 }
 
+/**
+ * Fingerprint everything an extension contributes that can change the linked
+ * executable but does not live under `runtime/`: its name, linker flags and the
+ * contents of any pre-built C++/Rust objects. Keeps a cached binary fresh when
+ * a native extension is rebuilt, or when `--ext-native` flags change.
+ */
+function registryFingerprint(registry: ExtensionRegistry): string {
+  const parts: string[] = [];
+  for (const extension of registry.all()) {
+    parts.push(extension.name);
+    parts.push(...(extension.linkerFlags?.() ?? []));
+    for (const object of extension.nativeObjects?.() ?? []) {
+      parts.push(object, existsSync(object) ? readFileSync(object).toString("base64") : "");
+    }
+  }
+  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.
@@ -348,5 +368,6 @@ function ensureRuntimeObjects(
       extensionObjects.push(compileOne(sourcePath, `ext_${extensionObjects.length}_${basename(sourcePath, ".c")}`));
     }
   }
-  return { runtimeObjects, extensionObjects };
+  // A native archive may be shared by several manifests; link each once.
+  return { runtimeObjects, extensionObjects, nativeObjects: [...new Set(registry.nativeObjects())] };
 }

package/src/driver/toolchain-download.ts

@@ -65,6 +65,18 @@ export function toolchainDownload(
     };
   }
 
+  if (platform === "win32" && arch === "arm64") {
+    // The llvm-mingw `aarch64` package is the Windows-on-ARM host build; its
+    // clang targets aarch64 by default, so a native Windows ARM64 runner gets
+    // native MinGW-w64 binaries with no MSVC dependency.
+    return {
+      url: `https://github.com/mstorsjo/llvm-mingw/releases/download/${LLVM_MINGW_VERSION}/llvm-mingw-${LLVM_MINGW_VERSION}-ucrt-aarch64.zip`,
+      archive: `llvm-mingw-${LLVM_MINGW_VERSION}-ucrt-aarch64.zip`,
+      kind: "zip",
+      stripComponents: 1,
+    };
+  }
+
   // macOS (and any other host) uses the system SDK; nothing to bundle.
   return undefined;
 }
@@ -104,5 +116,20 @@ export function toolchainSupportLibraries(
       },
     ];
   }
+  if (platform === "linux" && arch === "arm64") {
+    // The aarch64 release build links the same removed `libtinfo.so.5` soname as
+    // the x86_64 one; arm64 packages live in the Ubuntu ports archive.
+    return [
+      {
+        urls: [
+          "https://ports.ubuntu.com/ubuntu-ports/pool/main/n/ncurses/libtinfo5_6.1-1ubuntu1.18.04.1_arm64.deb",
+          "http://ports.ubuntu.com/ubuntu-ports/pool/main/n/ncurses/libtinfo5_6.1-1ubuntu1.18.04.1_arm64.deb",
+        ],
+        archive: "libtinfo5.deb",
+        member: "lib/aarch64-linux-gnu/libtinfo.so.5.9",
+        dest: "libtinfo.so.5",
+      },
+    ];
+  }
   return [];
 }