xbintsc 0.3.6 → 0.3.7

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/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/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/extensions/native.ts

@@ -0,0 +1,270 @@
+/**
+ * Native (C++ / Rust) extensions.
+ *
+ * xbintsc can consume code that was compiled outside the TypeScript pipeline,
+ * as long as it exposes `extern "C"` entry points with the runtime calling
+ * convention:
+ *
+ *     xt_value my_fn(int32_t argc, xt_value *argv);
+ *
+ * A C++ or Rust project is built into an object file or static archive, and a
+ * small JSON manifest describes how those symbols map onto global functions
+ * (`builtins`) and importable modules (`modules`). The driver links the
+ * artifacts verbatim and the code generator wires the bindings exactly like it
+ * does for the built-in `node` extension — the core compiler never needs to
+ * know the extension was written in C++ or Rust.
+ *
+ * ```jsonc
+ * {
+ *   "name": "mathx",
+ *   "description": "C++ math helpers",
+ *   "objects": ["build/libmathx.a"],
+ *   "linkerFlags": ["-lm"],
+ *   "linkerFlagsByPlatform": { "linux": ["-lstdc++"], "darwin": ["-lc++"] },
+ *   "builtins": { "fastAdd": { "symbol": "mathx_add" } },
+ *   "modules": {
+ *     "mathx": {
+ *       "exports": {
+ *         "add": { "symbol": "mathx_add" },
+ *         "reverse": { "symbol": "mathx_reverse" }
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * `objects` paths are resolved relative to the manifest file, so a manifest can
+ * live next to the project it describes.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import type { Extension, ExtensionModule, ModuleExport, ModuleExports } from "./registry.js";
+
+/** A global function an extension provides (callable without an import). */
+export interface NativeBuiltin {
+  /** Exported C symbol, called as `xt_value symbol(int32_t argc, xt_value *argv)`. */
+  readonly symbol: string;
+  readonly returnVoid?: boolean;
+}
+
+/** One binding inside a `modules` entry; mirrors the core `ModuleExport`. */
+export type NativeModuleExport = ModuleExport;
+
+/** An importable module supplied by the native library. */
+export interface NativeModule {
+  /** Named exports for `import { x } from "..."`. */
+  readonly exports?: Readonly<Record<string, NativeModuleExport>>;
+  /** Namespace name for `import * as ns` / `import ns from`. */
+  readonly namespace?: string;
+}
+
+/** The on-disk schema of a native extension manifest. */
+export interface NativeManifest {
+  /** Unique extension name (used by `--ext`/diagnostics). */
+  readonly name: string;
+  readonly description?: string;
+  /**
+   * Object files (`.o`) or static archives (`.a`/`.lib`) to link. Resolved
+   * relative to the manifest unless absolute.
+   */
+  readonly objects?: readonly string[];
+  /** Linker flags appended verbatim, e.g. `["-lm"]`. */
+  readonly linkerFlags?: readonly string[];
+  /**
+   * Linker flags added only on the given platform (`darwin`, `linux`, `win32`),
+   * for C++ standard libraries or Rust's native dependencies that differ per OS.
+   */
+  readonly linkerFlagsByPlatform?: Readonly<Record<string, readonly string[]>>;
+  /** Global functions the extension binds. */
+  readonly builtins?: Readonly<Record<string, NativeBuiltin>>;
+  /** Modules importable as `import ... from "<specifier>"`. */
+  readonly modules?: Readonly<Record<string, NativeModule>>;
+}
+
+/** Raised for a malformed manifest or a missing build artifact. */
+export class NativeExtensionError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "NativeExtensionError";
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function stringArray(value: unknown, field: string): readonly string[] {
+  if (value === undefined) return [];
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new NativeExtensionError(`Native manifest field '${field}' must be an array of strings`);
+  }
+  return value as readonly string[];
+}
+
+function parseBuiltins(value: unknown): Readonly<Record<string, NativeBuiltin>> | undefined {
+  if (value === undefined) return undefined;
+  if (!isRecord(value)) throw new NativeExtensionError("Native manifest field 'builtins' must be an object");
+  const builtins: Record<string, NativeBuiltin> = {};
+  for (const [name, entry] of Object.entries(value)) {
+    if (!isRecord(entry) || typeof entry.symbol !== "string" || entry.symbol.length === 0) {
+      throw new NativeExtensionError(`Native manifest builtin '${name}' needs a non-empty 'symbol'`);
+    }
+    builtins[name] = {
+      symbol: entry.symbol,
+      ...(entry.returnVoid === true ? { returnVoid: true } : {}),
+    };
+  }
+  return builtins;
+}
+
+function parseExports(value: unknown, moduleName: string): ModuleExports | undefined {
+  if (value === undefined) return undefined;
+  if (!isRecord(value)) {
+    throw new NativeExtensionError(`Native manifest module '${moduleName}'.exports must be an object`);
+  }
+  const exports: Record<string, ModuleExport> = {};
+  for (const [name, entry] of Object.entries(value)) {
+    if (!isRecord(entry)) {
+      throw new NativeExtensionError(`Native manifest export '${moduleName}.${name}' must be an object`);
+    }
+    const symbol = entry.symbol;
+    const namespace = entry.namespace;
+    const method = entry.method;
+    if (symbol !== undefined && typeof symbol !== "string") {
+      throw new NativeExtensionError(`Native manifest export '${moduleName}.${name}'.symbol must be a string`);
+    }
+    if (namespace !== undefined && typeof namespace !== "string") {
+      throw new NativeExtensionError(`Native manifest export '${moduleName}.${name}'.namespace must be a string`);
+    }
+    if (method !== undefined && typeof method !== "string") {
+      throw new NativeExtensionError(`Native manifest export '${moduleName}.${name}'.method must be a string`);
+    }
+    if (symbol === undefined && namespace === undefined) {
+      throw new NativeExtensionError(
+        `Native manifest export '${moduleName}.${name}' needs a 'symbol' or a 'namespace'`,
+      );
+    }
+    exports[name] = {
+      ...(symbol !== undefined ? { symbol } : {}),
+      ...(namespace !== undefined ? { namespace } : {}),
+      ...(method !== undefined ? { method } : {}),
+      ...(entry.returnVoid === true ? { returnVoid: true } : {}),
+      ...(entry.isConstructor === true ? { isConstructor: true } : {}),
+    };
+  }
+  return exports;
+}
+
+function parseModules(value: unknown): Readonly<Record<string, ExtensionModule>> | undefined {
+  if (value === undefined) return undefined;
+  if (!isRecord(value)) throw new NativeExtensionError("Native manifest field 'modules' must be an object");
+  const modules: Record<string, ExtensionModule> = {};
+  for (const [specifier, entry] of Object.entries(value)) {
+    if (!isRecord(entry)) {
+      throw new NativeExtensionError(`Native manifest module '${specifier}' must be an object`);
+    }
+    if (entry.namespace !== undefined && typeof entry.namespace !== "string") {
+      throw new NativeExtensionError(`Native manifest module '${specifier}'.namespace must be a string`);
+    }
+    modules[specifier] = {
+      ...(entry.namespace !== undefined ? { namespace: entry.namespace } : {}),
+      ...(entry.exports !== undefined ? { exports: parseExports(entry.exports, specifier) } : {}),
+    };
+  }
+  return modules;
+}
+
+/** Validate parsed JSON and normalise it into a {@link NativeManifest}. */
+export function parseNativeManifest(value: unknown, source = "<manifest>"): NativeManifest {
+  if (!isRecord(value)) throw new NativeExtensionError(`Native manifest ${source} must contain a JSON object`);
+  if (typeof value.name !== "string" || value.name.trim().length === 0) {
+    throw new NativeExtensionError(`Native manifest ${source} needs a non-empty 'name'`);
+  }
+  if (value.description !== undefined && typeof value.description !== "string") {
+    throw new NativeExtensionError(`Native manifest '${value.name}'.description must be a string`);
+  }
+
+  let linkerFlagsByPlatform: Record<string, readonly string[]> | undefined;
+  if (value.linkerFlagsByPlatform !== undefined) {
+    if (!isRecord(value.linkerFlagsByPlatform)) {
+      throw new NativeExtensionError("Native manifest field 'linkerFlagsByPlatform' must be an object");
+    }
+    linkerFlagsByPlatform = {};
+    for (const [platform, flags] of Object.entries(value.linkerFlagsByPlatform)) {
+      linkerFlagsByPlatform[platform] = stringArray(flags, `linkerFlagsByPlatform.${platform}`);
+    }
+  }
+
+  const builtins = parseBuiltins(value.builtins);
+  const modules = parseModules(value.modules);
+
+  return {
+    name: value.name,
+    ...(value.description !== undefined ? { description: value.description } : {}),
+    objects: stringArray(value.objects, "objects"),
+    linkerFlags: stringArray(value.linkerFlags, "linkerFlags"),
+    ...(linkerFlagsByPlatform ? { linkerFlagsByPlatform } : {}),
+    ...(builtins ? { builtins } : {}),
+    ...(modules ? { modules } : {}),
+  };
+}
+
+/** Read and validate a manifest from disk. */
+export function loadNativeManifest(manifestPath: string): NativeManifest {
+  const absolute = resolve(manifestPath);
+  let text: string;
+  try {
+    text = readFileSync(absolute, "utf8");
+  } catch (error) {
+    throw new NativeExtensionError(`Unable to read native extension manifest '${absolute}': ${String(error)}`);
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    throw new NativeExtensionError(`Native extension manifest '${absolute}' is not valid JSON: ${String(error)}`);
+  }
+  return parseNativeManifest(parsed, absolute);
+}
+
+function resolveArtifact(baseDir: string, path: string): string {
+  return isAbsolute(path) ? path : resolve(baseDir, path);
+}
+
+/**
+ * Turn a manifest into an {@link Extension}: resolve and verify every native
+ * object, then expose the manifest's builtins/modules to the code generator.
+ *
+ * The manifest is read eagerly so a typo surfaces at registration time rather
+ * than at link time.
+ */
+export function nativeExtensionFromManifest(manifestPath: string): Extension {
+  const absolute = resolve(manifestPath);
+  const manifest = loadNativeManifest(absolute);
+  const baseDir = dirname(absolute);
+
+  const objects = (manifest.objects ?? []).map((object) => resolveArtifact(baseDir, object));
+  for (const object of objects) {
+    if (!existsSync(object)) {
+      throw new NativeExtensionError(
+        `Native extension '${manifest.name}' references missing object '${object}'.\n` +
+          `Build the C++/Rust library first (see the project next to ${absolute}).`,
+      );
+    }
+  }
+
+  const linkerFlags = () => [
+    ...(manifest.linkerFlags ?? []),
+    ...(manifest.linkerFlagsByPlatform?.[process.platform] ?? []),
+  ];
+
+  return {
+    name: manifest.name,
+    description: manifest.description ?? `Native extension from ${absolute}`,
+    nativeObjects: () => objects,
+    linkerFlags,
+    ...(manifest.builtins ? { builtins: () => manifest.builtins! } : {}),
+    ...(manifest.modules ? { modules: () => manifest.modules! } : {}),
+  };
+}

package/src/extensions/registry.ts

@@ -52,6 +52,17 @@ export interface Extension {
   readonly description?: string;
   /** C/asm sources compiled and linked alongside the generated module. */
   runtimeSources?(): readonly string[];
+  /**
+   * Pre-built object files or static archives linked alongside the generated
+   * module. This is the hook for native extensions written in C++ or Rust:
+   * compile them to `extern "C"` objects (or a static library) that use the
+   * `xt_value` ABI, then hand the artifacts to the driver through an
+   * `Extension` such as the one built by `src/extensions/native.ts`.
+   *
+   * The paths must already exist; the driver passes them straight to the
+   * linker and never recompiles them.
+   */
+  nativeObjects?(): readonly string[];
   /** Extra linker flags (e.g. `["-lm"]`, `["-framework", "CoreFoundation"]`). */
   linkerFlags?(): readonly string[];
   /** Global identifiers that resolve to runtime symbols when called. */
@@ -123,6 +134,16 @@ export class ExtensionRegistry {
     return sources;
   }
 
+  /** Flatten every registered extension's pre-built native objects. */
+  nativeObjects(): readonly string[] {
+    const objects: string[] = [];
+    for (const extension of this.extensions.values()) {
+      const extra = extension.nativeObjects?.();
+      if (extra) objects.push(...extra);
+    }
+    return objects;
+  }
+
   linkerFlags(): readonly string[] {
     const flags: string[] = [];
     for (const extension of this.extensions.values()) {

package/src/index.ts

@@ -32,4 +32,14 @@ export {
 export { ExtensionRegistry, createDefaultRegistry, coreExtension, type Extension, type ExtensionModule, type ModuleExport, type ModuleExports } from "./extensions/registry.js";
 export { nodeExtension } from "./extensions/node/index.js";
 export type { NodeModule } from "./extensions/node/module.js";
+export {
+  NativeExtensionError,
+  loadNativeManifest,
+  nativeExtensionFromManifest,
+  parseNativeManifest,
+  type NativeManifest,
+  type NativeBuiltin,
+  type NativeModule,
+  type NativeModuleExport,
+} from "./extensions/native.js";
 export * from "./driver/index.js";