xbintsc 0.3.8 → 0.3.10

package/runtime/ext_node/worker_threads/worker_threads.c

@@ -0,0 +1,206 @@
+/*
+ * Node.js `worker_threads` module for xbintsc.
+ *
+ * xbintsc has no threads, so a worker is emulated by re-running the current
+ * executable as a child process. `isMainThread`/`workerData` read the
+ * `XBINTSC_WORKER`/`XBINTSC_WORKER_DATA` environment variables the parent sets,
+ * and `parentPort.postMessage(x)` writes `x` to the child's stdout, which the
+ * parent captures and re-emits as a `"message"` event on the `Worker` object.
+ * Because the event emitter buffers events until a listener is attached,
+ * `new Worker(...)` can run the child synchronously and still deliver the
+ * message to a later `worker.on("message", ...)`.
+ */
+
+#include "../node_common.h"
+
+#include <string.h>
+
+#if defined(_WIN32)
+#include <direct.h>
+#include <io.h>
+#include <process.h>
+#else
+#include <sys/wait.h>
+#include <unistd.h>
+#endif
+
+/* -- environment ---------------------------------------------------------- */
+
+static int xt_worker_is_worker(void) {
+  return getenv("XBINTSC_WORKER") != NULL;
+}
+
+static void xt_worker_set_env(const char *key, const char *value) {
+#if defined(_WIN32)
+  _putenv_s(key, value ? value : "");
+#else
+  if (value) setenv(key, value, 1);
+  else unsetenv(key);
+#endif
+}
+
+/* -- value bindings ------------------------------------------------------- */
+
+xt_value xt_worker_is_main_thread(int32_t argc, xt_value *argv) {
+  (void)argc;
+  (void)argv;
+  return xt_bool(!xt_worker_is_worker());
+}
+
+xt_value xt_worker_data(int32_t argc, xt_value *argv) {
+  (void)argc;
+  (void)argv;
+  const char *json = getenv("XBINTSC_WORKER_DATA");
+  if (!json) return xt_undefined();
+  xt_value text = xt_string_from_cstr(json);
+  return xt_json_parse(1, &text);
+}
+
+static xt_value xt_worker_port_post(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)thisValue;
+  (void)env;
+  xt_value message = xt_arg(argc, argv, 0);
+  xt_value text = xt_to_string(message);
+  const char *data = xt_string_data(text);
+  if (data) {
+    fwrite(data, 1, strlen(data), stdout);
+  }
+  fputc('\n', stdout);
+  fflush(stdout);
+  return xt_undefined();
+}
+
+xt_value xt_worker_parent_port(int32_t argc, xt_value *argv) {
+  (void)argc;
+  (void)argv;
+  xt_value port = xt_object_new();
+  xt_node_set(port, "_kind", xt_string_from_cstr("parentPort"));
+  xt_node_set(port, "postMessage", xt_closure_new((void *)xt_worker_port_post, 0, NULL));
+  return port;
+}
+
+/* -- child process -------------------------------------------------------- */
+
+/* Run `path` as a worker and capture its stdout. Returns a heap string (caller
+ * frees) or NULL on failure. */
+static char *xt_worker_spawn(const char *path, const char *workerDataJson, int *exitCode) {
+  *exitCode = -1;
+#if defined(_WIN32)
+  char previous[4096];
+  int had_cwd = _getcwd(previous, sizeof(previous)) != NULL;
+  (void)had_cwd;
+  FILE *capture = tmpfile();
+  if (!capture) return NULL;
+  int saved = _dup(1);
+  if (saved < 0) {
+    fclose(capture);
+    return NULL;
+  }
+  fflush(stdout);
+  _dup2(_fileno(capture), 1);
+  xt_worker_set_env("XBINTSC_WORKER", "1");
+  if (workerDataJson) xt_worker_set_env("XBINTSC_WORKER_DATA", workerDataJson);
+  intptr_t rc = _spawnlp(_P_WAIT, path, path, (char *)NULL);
+  fflush(stdout);
+  _dup2(saved, 1);
+  _close(saved);
+  xt_worker_set_env("XBINTSC_WORKER", NULL);
+  xt_worker_set_env("XBINTSC_WORKER_DATA", NULL);
+  if (rc < 0) {
+    fclose(capture);
+    return NULL;
+  }
+  *exitCode = (int)rc;
+  if (_fseeki64(capture, 0, SEEK_END) != 0) {
+    fclose(capture);
+    return NULL;
+  }
+  long long size = _ftelli64(capture);
+  _fseeki64(capture, 0, SEEK_SET);
+  char *buffer = (char *)malloc((size_t)size + 1);
+  if (!buffer) {
+    fclose(capture);
+    return NULL;
+  }
+  size_t got = fread(buffer, 1, (size_t)size, capture);
+  buffer[got] = 0;
+  fclose(capture);
+  return buffer;
+#else
+  if (workerDataJson) xt_worker_set_env("XBINTSC_WORKER_DATA", workerDataJson);
+  xt_worker_set_env("XBINTSC_WORKER", "1");
+  int fds[2];
+  if (pipe(fds) != 0) return NULL;
+  pid_t pid = fork();
+  if (pid == 0) {
+    dup2(fds[1], STDOUT_FILENO);
+    close(fds[0]);
+    close(fds[1]);
+    char *childArgv[2];
+    childArgv[0] = (char *)path;
+    childArgv[1] = NULL;
+    execv(path, childArgv);
+    _exit(127);
+  }
+  close(fds[1]);
+  char *buffer = NULL;
+  size_t length = 0;
+  size_t capacity = 0;
+  char chunk[4096];
+  ssize_t got;
+  while ((got = read(fds[0], chunk, sizeof(chunk))) > 0) {
+    char *grown = (char *)realloc(buffer, length + (size_t)got + 1);
+    if (!grown) break;
+    buffer = grown;
+    memcpy(buffer + length, chunk, (size_t)got);
+    length += (size_t)got;
+    buffer[length] = 0;
+  }
+  close(fds[0]);
+  int status = 0;
+  waitpid(pid, &status, 0);
+  *exitCode = WIFEXITED(status) ? WEXITSTATUS(status) : -1;
+  xt_worker_set_env("XBINTSC_WORKER", NULL);
+  xt_worker_set_env("XBINTSC_WORKER_DATA", NULL);
+  if (!buffer) buffer = (char *)calloc(1, 1);
+  (void)capacity;
+  return buffer;
+#endif
+}
+
+xt_value xt_worker_ctor(int32_t argc, xt_value *argv) {
+  xt_value options = argc > 1 ? argv[1] : XT_UNDEFINED;
+  xt_value data = XT_IS_OBJECT(options) ? xt_object_get_cstr(options, "workerData") : XT_UNDEFINED;
+
+  const char *path = (xt_program_argv && xt_program_argv[0]) ? xt_program_argv[0] : NULL;
+  char *workerDataJson = NULL;
+  if (data != XT_UNDEFINED) {
+    xt_value json = xt_json_stringify(1, &data);
+    const char *text = xt_string_data(json);
+    if (text) {
+      size_t size = strlen(text);
+      workerDataJson = (char *)malloc(size + 1);
+      if (workerDataJson) memcpy(workerDataJson, text, size + 1);
+    }
+  }
+
+  xt_value worker = xt_object_new();
+  xt_node_set(worker, "_kind", xt_string_from_cstr("worker"));
+  xt_node_install_emitter(worker);
+  xt_node_set(worker, "postMessage", xt_closure_new((void *)xt_worker_port_post, 0, NULL));
+
+  int exitCode = -1;
+  char *output = path ? xt_worker_spawn(path, workerDataJson, &exitCode) : NULL;
+  free(workerDataJson);
+
+  if (output) {
+    size_t length = strlen(output);
+    while (length > 0 && (output[length - 1] == '\n' || output[length - 1] == '\r')) output[--length] = 0;
+    xt_node_emit1(worker, "message", xt_string_new(output, length));
+    free(output);
+  } else {
+    xt_node_emit1(worker, "error", xt_string_from_cstr("failed to start worker"));
+  }
+  xt_node_emit1(worker, "exit", xt_number((double)exitCode));
+  return worker;
+}

package/runtime/ext_node/zlib/zlib.c

@@ -0,0 +1,19 @@
+/*
+ * Node.js `zlib` module for xbintsc.
+ *
+ * Only `createGzip` is implemented, and the "compression" uses DEFLATE stored
+ * (uncompressed) blocks: the output is a fully valid gzip stream
+ * (`zlib.gunzipSync`/`gunzip`/HTTP clients all accept it) even though it does
+ * not shrink the payload. The descriptor is consumed by the `stream/promises`
+ * `pipeline` implementation.
+ */
+
+#include "../node_common.h"
+
+xt_value xt_node_create_gzip(int32_t argc, xt_value *argv) {
+  (void)argc;
+  (void)argv;
+  xt_value stream = xt_object_new();
+  xt_node_set(stream, "_kind", xt_string_from_cstr("gzip"));
+  return stream;
+}

package/runtime/xt_io.c

@@ -482,3 +482,89 @@ xt_value xt_console_time_end(int32_t argc, xt_value *argv) {
   if (index >= 0) xt_console_timers[index] = 0;
   return XT_UNDEFINED;
 }
+
+/* -- base64 globals (btoa/atob) ------------------------------------------- */
+
+static const char xt_base64_alphabet[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+xt_value xt_btoa(int32_t argc, xt_value *argv) {
+  const char *input = argc > 0 ? xt_string_data(xt_to_string(argv[0])) : "";
+  if (!input) input = "";
+  size_t length = strlen(input);
+  size_t outLength = ((length + 2) / 3) * 4;
+  char *buffer = (char *)malloc(outLength + 1);
+  if (!buffer) return xt_string_from_cstr("");
+  size_t i = 0, j = 0;
+  while (i + 2 < length) {
+    unsigned int n = ((unsigned char)input[i] << 16) | ((unsigned char)input[i + 1] << 8) |
+                     (unsigned char)input[i + 2];
+    buffer[j++] = xt_base64_alphabet[(n >> 18) & 63];
+    buffer[j++] = xt_base64_alphabet[(n >> 12) & 63];
+    buffer[j++] = xt_base64_alphabet[(n >> 6) & 63];
+    buffer[j++] = xt_base64_alphabet[n & 63];
+    i += 3;
+  }
+  if (length - i == 1) {
+    unsigned int n = (unsigned char)input[i] << 16;
+    buffer[j++] = xt_base64_alphabet[(n >> 18) & 63];
+    buffer[j++] = xt_base64_alphabet[(n >> 12) & 63];
+    buffer[j++] = '=';
+    buffer[j++] = '=';
+  } else if (length - i == 2) {
+    unsigned int n = ((unsigned char)input[i] << 16) | ((unsigned char)input[i + 1] << 8);
+    buffer[j++] = xt_base64_alphabet[(n >> 18) & 63];
+    buffer[j++] = xt_base64_alphabet[(n >> 12) & 63];
+    buffer[j++] = xt_base64_alphabet[(n >> 6) & 63];
+    buffer[j++] = '=';
+  }
+  buffer[j] = 0;
+  xt_value result = xt_string_new(buffer, j);
+  free(buffer);
+  return result;
+}
+
+static int xt_base64_value(char c) {
+  if (c >= 'A' && c <= 'Z') return c - 'A';
+  if (c >= 'a' && c <= 'z') return c - 'a' + 26;
+  if (c >= '0' && c <= '9') return c - '0' + 52;
+  if (c == '+') return 62;
+  if (c == '/') return 63;
+  return -1;
+}
+
+xt_value xt_atob(int32_t argc, xt_value *argv) {
+  const char *input = argc > 0 ? xt_string_data(xt_to_string(argv[0])) : "";
+  if (!input) input = "";
+  size_t length = strlen(input);
+  char *buffer = (char *)malloc(length / 4 * 3 + 1);
+  if (!buffer) return xt_string_from_cstr("");
+  size_t out = 0;
+  int values[4];
+  int count = 0;
+  for (size_t i = 0; i < length; i++) {
+    char c = input[i];
+    if (c == '=' || c == '\n' || c == '\r' || c == ' ' || c == '\t') {
+      if (c == '=') break;
+      continue;
+    }
+    int value = xt_base64_value(c);
+    if (value < 0) continue;
+    values[count++] = value;
+    if (count == 4) {
+      buffer[out++] = (char)((values[0] << 2) | (values[1] >> 4));
+      buffer[out++] = (char)(((values[1] & 15) << 4) | (values[2] >> 2));
+      buffer[out++] = (char)(((values[2] & 3) << 6) | values[3]);
+      count = 0;
+    }
+  }
+  if (count == 2) {
+    buffer[out++] = (char)((values[0] << 2) | (values[1] >> 4));
+  } else if (count == 3) {
+    buffer[out++] = (char)((values[0] << 2) | (values[1] >> 4));
+    buffer[out++] = (char)(((values[1] & 15) << 4) | (values[2] >> 2));
+  }
+  xt_value result = xt_string_new(buffer, out);
+  free(buffer);
+  return result;
+}

package/runtime/xt_stdlib/dispatch.inc

@@ -246,7 +246,15 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
     return XT_UNDEFINED;
   }
   const char *method = xt_string_data(name);
-  if (!method) return XT_UNDEFINED;
+  if (!method) {
+    /* A computed non-string key (`arr[0]()`, `table[someKey]()` where the key
+     * is not a string) resolves like a property read followed by a call with
+     * `target` as `this`, instead of silently returning undefined. */
+    xt_value fn = xt_get(target, name);
+    if (XT_IS_FUNCTION(fn)) return xt_call_with_this(fn, target, argc, argv);
+    xt_throw(xt_string_from_cstr("TypeError: value at computed index is not a function"));
+    return XT_UNDEFINED;
+  }
   if (target == XT_UNDEFINED || target == XT_NULL) {
     const char *base = target == XT_NULL ? "null" : "undefined";
     char message[256];

package/scripts/package-release.ts

@@ -2,8 +2,11 @@
 /**
  * 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
+ *   dist/release/xbintsc-<version>-<os>-<arch>.tar.gz        (or .tar.zst)
+ *   dist/release/xbintsc-<version>-<os>-<arch>.tar.gz.sha256
+ *
+ * The version comes from package.json, so release assets from different
+ * versions do not collide in a download folder.
  *
  * The unpacked staging tree is built under `build/release-stage/`, never under
  * `dist/release/`, so an upload glob over `dist/release/*` cannot accidentally
@@ -49,11 +52,16 @@ import {
   platformSlug,
   releaseArchiveBase,
   releaseArchiveExtension,
+  releaseArchiveFileName,
 } from "../src/driver/paths.js";
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const slug = platformSlug();
 const base = releaseArchiveBase();
+const version = (
+  JSON.parse(readFileSync(join(root, "package.json"), "utf8")) as { version: string }
+).version;
+const archiveBase = releaseArchiveFileName(version);
 const exeSuffix = process.platform === "win32" ? ".exe" : "";
 
 function fail(message: string): never {
@@ -177,7 +185,7 @@ for (const name of ["README.md", "LICENSE"]) {
 // 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}`);
+const archive = join(releaseRoot, `${archiveBase}${extension}`);
 rmSync(archive, { force: true });
 const tarArgs = ["-c", hasZstd ? "--zstd" : "-z", "-f", archive, "-C", stageRoot, base];
 const tar = spawnSync("tar", tarArgs, { stdio: "inherit" });

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

@@ -96,6 +96,8 @@ export const invocationCallMethods: InvocationCallMethods = {
       if (symbol && symbol.kind === SymbolKind.Import) {
         const exported = this.importExports.get(symbol.id);
         if (exported) return this.emitModuleExport(node, exported);
+        const defaultExport = this.importDefaults.get(symbol.id);
+        if (defaultExport) return this.emitModuleExport(node, defaultExport);
       }
       if (symbol && symbol.kind === SymbolKind.Function) {
         const declaration = symbol.declarations[0];

package/src/codegen/generator/context.ts

@@ -39,6 +39,11 @@ export class GeneratorContext {
    * `fs.readFileSync(...)` straight to the module's runtime symbol.
    */
   readonly importModuleExports = new Map<number, ModuleExports>();
+  /**
+   * Imported symbol id -> the module's `default` export, for callable default
+   * imports such as `import test from "node:test"`.
+   */
+  readonly importDefaults = new Map<number, ModuleExport>();
   readonly globals: string[] = [];
   readonly functions: string[] = [];
   readonly strings = new Map<string, { label: string; length: number }>();
@@ -74,7 +79,11 @@ export class GeneratorContext {
       if (!clause) continue;
       if (clause.name) {
         const symbol = this.binding.symbolOfDeclaration.get(clause.name);
-        if (symbol) this.bindModuleAlias(symbol, module);
+        if (symbol) {
+          this.bindModuleAlias(symbol, module);
+          const defaultExport = module.exports?.["default"];
+          if (defaultExport) this.importDefaults.set(symbol.id, defaultExport);
+        }
       }
       const bindings = clause.namedBindings;
       if (bindings && bindings.kind === SyntaxKind.NamedImports) {
@@ -82,7 +91,15 @@ export class GeneratorContext {
           const importedName = specifier.propertyName?.text ?? specifier.name.text;
           const exported = module.exports?.[importedName];
           const symbol = this.binding.symbolOfDeclaration.get(specifier.name);
-          if (symbol && exported) this.importExports.set(symbol.id, exported);
+          if (symbol && exported) {
+            this.importExports.set(symbol.id, exported);
+            // A named constructor (`import { Buffer } from "buffer"`) also
+            // inherits its module's static dispatcher, so `Buffer.from(...)`
+            // lowers like `buffer.from(...)`.
+            if (exported.isConstructor && module.namespace) {
+              this.importNamespaces.set(symbol.id, module.namespace);
+            }
+          }
         }
       } else if (bindings && bindings.kind === SyntaxKind.NamespaceImport) {
         const symbol = this.binding.symbolOfDeclaration.get(bindings.name);

package/src/codegen/generator/expressions/primary.ts

@@ -166,6 +166,23 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
         return this.emitFunctionValue(symbol);
       }
       if (symbol.kind === SymbolKind.Import) {
+        // Some module bindings are plain values rather than functions
+        // (`isMainThread`, `workerData`, ...). They resolve through a nullary
+        // runtime getter instead of being called or namespaced.
+        const exported = this.importExports.get(symbol.id);
+        if (exported?.valueSymbol) {
+          this.extraDeclarations.add(`declare i64 @${exported.valueSymbol}(i32, i64*)`);
+          const result = this.reg();
+          this.emit(`  ${result} = call i64 @${exported.valueSymbol}(i32 0, i64* null)`);
+          return result;
+        }
+        const defaultExport = this.importDefaults.get(symbol.id);
+        if (defaultExport?.valueSymbol) {
+          this.extraDeclarations.add(`declare i64 @${defaultExport.valueSymbol}(i32, i64*)`);
+          const result = this.reg();
+          this.emit(`  ${result} = call i64 @${defaultExport.valueSymbol}(i32 0, i64* null)`);
+          return result;
+        }
         // Imported runtime bindings have no first-class value: they are meant
         // to be called (`readFileSync(...)`) or used as a namespace
         // (`path.join(...)`), both handled before identifier lowering.

package/src/codegen/generator/state.ts

@@ -124,6 +124,7 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_events_static(i64, i32, i64*)",
   "declare i64 @xt_util_static(i64, i32, i64*)",
   "declare i64 @xt_querystring_static(i64, i32, i64*)",
+  "declare i64 @xt_assert_static(i64, i32, i64*)",
   "declare i64 @xt_process_call(i64, i32, i64*)",
   "declare i64 @xt_process_get(i64)",
   "declare i64 @xt_map_ctor(i32, i64*)",
@@ -205,6 +206,8 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_encode_uri(i32, i64*)",
   "declare i64 @xt_decode_uri_component(i32, i64*)",
   "declare i64 @xt_decode_uri(i32, i64*)",
+  "declare i64 @xt_btoa(i32, i64*)",
+  "declare i64 @xt_atob(i32, i64*)",
   "declare i64 @xt_number_ctor(i32, i64*)",
   "declare i64 @xt_bigint_ctor(i32, i64*)",
   "declare i64 @xt_bigint_static(i64, i32, i64*)",

package/src/codegen/generator/tables.ts

@@ -122,6 +122,8 @@ export const GLOBAL_FUNCTIONS: Record<string, string> = {
   encodeURI: "xt_encode_uri",
   decodeURIComponent: "xt_decode_uri_component",
   decodeURI: "xt_decode_uri",
+  btoa: "xt_btoa",
+  atob: "xt_atob",
   Number: "xt_number_ctor",
   String: "xt_string_ctor",
   Boolean: "xt_boolean_ctor",
@@ -176,6 +178,7 @@ export const NAMESPACE_STATICS: Record<string, string> = {
   events: "xt_events_static",
   util: "xt_util_static",
   querystring: "xt_querystring_static",
+  assert: "xt_assert_static",
 };
 
 /** Namespace identifiers whose property access maps to a runtime getter. */

package/src/driver/index.ts

@@ -1,6 +1,6 @@
 export { build, compileString, COMPILER_VERSION, type BuildOptions, type BuildResult, type EmitKind } from "./compiler.js";
 export { BuildCache, hashParts, hashString } from "./cache.js";
-export { findRuntimeDir, findPackageRoot, findVendorDir, vendorRootDir, platformSlug, releaseArchiveBase, releaseArchiveExtension } from "./paths.js";
+export { findRuntimeDir, findPackageRoot, findVendorDir, vendorRootDir, platformSlug, releaseArchiveBase, releaseArchiveFileName, releaseArchiveExtension } from "./paths.js";
 export {
   toolchainDownload,
   toolchainSupportLibraries,

package/src/driver/paths.ts

@@ -47,6 +47,20 @@ export function releaseArchiveBase(
   return `xbintsc-${platform}-${arch}`;
 }
 
+/**
+ * Base name (no extension) of the published release archive, e.g.
+ * `xbintsc-0.3.8-linux-x64`. The version is embedded so downloads from
+ * different releases can coexist and users can tell them apart. The top-level
+ * directory inside the archive still uses {@link releaseArchiveBase}.
+ */
+export function releaseArchiveFileName(
+  version: string,
+  platform: string = process.platform,
+  arch: string = process.arch,
+): string {
+  return `xbintsc-${version}-${platform}-${arch}`;
+}
+
 /**
  * Extension for a release archive. `.tar.zst` when a `zstd` binary is available
  * (smaller, faster), otherwise the universally supported `.tar.gz`.

package/src/extensions/node/assert/index.ts

@@ -0,0 +1,44 @@
+/**
+ * Node's `assert` module.
+ *
+ * All assertions dispatch through `runtime/ext_node/assert` via the `assert`
+ * namespace (`xt_assert_static`). `import assert from "node:assert"` binds the
+ * namespace, so `assert.strictEqual(...)` works, and named imports such as
+ * `import { strictEqual } from "assert"` lower to the same dispatcher.
+ */
+
+import type { NodeModule } from "../module.js";
+import { resolveFrom } from "../module.js";
+import type { ModuleExports } from "../../registry.js";
+
+const methods = [
+  "ok",
+  "fail",
+  "equal",
+  "notEqual",
+  "strictEqual",
+  "notStrictEqual",
+  "deepEqual",
+  "notDeepEqual",
+  "deepStrictEqual",
+  "notDeepStrictEqual",
+  "throws",
+  "doesNotThrow",
+  "rejects",
+  "doesNotReject",
+  "match",
+  "doesNotMatch",
+  "ifError",
+] as const;
+
+const exports: ModuleExports = Object.fromEntries(
+  methods.map((method) => [method, { namespace: "assert", method }]),
+);
+
+export const assertModule: NodeModule = {
+  name: "assert",
+  namespace: "assert",
+  runtimeSources: () => [resolveFrom(import.meta.url, "../../../../runtime/ext_node/assert/assert.c")],
+  builtins: () => ({}),
+  exports: () => exports,
+};

package/src/extensions/node/buffer/index.ts

@@ -9,10 +9,29 @@
 
 import type { NodeModule } from "../module.js";
 import { resolveFrom } from "../module.js";
+import type { ModuleExports } from "../../registry.js";
+
+const statics = [
+  "from",
+  "of",
+  "alloc",
+  "allocUnsafe",
+  "allocUnsafeSlow",
+  "isBuffer",
+  "byteLength",
+  "concat",
+  "compare",
+] as const;
+
+const exports: ModuleExports = {
+  Buffer: { symbol: "xt_buffer_ctor", isConstructor: true },
+  ...Object.fromEntries(statics.map((method) => [method, { namespace: "Buffer", method }])),
+};
 
 export const bufferModule: NodeModule = {
   name: "buffer",
   namespace: "Buffer",
   runtimeSources: () => [resolveFrom(import.meta.url, "../../../../runtime/ext_node/buffer/buffer.c")],
   builtins: () => ({}),
+  exports: () => exports,
 };

package/src/extensions/node/dgram/index.ts

@@ -7,10 +7,16 @@
 
 import type { NodeModule } from "../module.js";
 import { resolveFrom } from "../module.js";
+import type { ModuleExports } from "../../registry.js";
+
+const exports: ModuleExports = {
+  createSocket: { namespace: "dgram", method: "createSocket" },
+};
 
 export const dgramModule: NodeModule = {
   name: "dgram",
   namespace: "dgram",
   runtimeSources: () => [resolveFrom(import.meta.url, "../../../../runtime/ext_node/dgram/dgram.c")],
   builtins: () => ({}),
+  exports: () => exports,
 };

package/src/extensions/node/events/index.ts

@@ -11,7 +11,7 @@ import type { NodeModule } from "../module.js";
 import { resolveFrom } from "../module.js";
 import type { ModuleExports } from "../../registry.js";
 
-const methods = ["listenerCount", "getEventListeners", "getMaxListeners", "setMaxListeners", "once"] as const;
+const methods = ["listenerCount", "getEventListeners", "getMaxListeners", "setMaxListeners", "once", "addAbortListener"] as const;
 
 const exports: ModuleExports = {
   EventEmitter: { symbol: "xt_event_emitter_ctor", isConstructor: true },

package/src/extensions/node/fs/index.ts

@@ -10,6 +10,7 @@ import { resolveFrom } from "../module.js";
 import { readFileBuiltins } from "./read-file.js";
 import { writeFileBuiltins } from "./write-file.js";
 import { fsOpsBuiltins } from "./fs-ops.js";
+import { fsStreamBuiltins } from "./streams.js";
 
 export const fsModule: NodeModule = {
   name: "fs",
@@ -17,6 +18,7 @@ export const fsModule: NodeModule = {
     resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/read_file.c"),
     resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/write_file.c"),
     resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/fs_ops.c"),
+    resolveFrom(import.meta.url, "../../../../runtime/ext_node/fs/streams.c"),
   ],
-  builtins: () => ({ ...readFileBuiltins, ...writeFileBuiltins, ...fsOpsBuiltins }),
+  builtins: () => ({ ...readFileBuiltins, ...writeFileBuiltins, ...fsOpsBuiltins, ...fsStreamBuiltins }),
 };

package/src/extensions/node/fs/streams.ts

@@ -0,0 +1,11 @@
+/**
+ * Builtins for Node's `fs` streaming factories. xbintsc has no asynchronous
+ * streaming, so these return descriptor objects consumed by `stream/promises`.
+ */
+
+import type { BuiltinFunction } from "../../registry.js";
+
+export const fsStreamBuiltins: Readonly<Record<string, BuiltinFunction>> = {
+  createReadStream: { symbol: "xt_node_create_read_stream" },
+  createWriteStream: { symbol: "xt_node_create_write_stream" },
+};

package/src/extensions/node/http/index.ts

@@ -9,6 +9,13 @@
 
 import type { NodeModule } from "../module.js";
 import { resolveFrom } from "../module.js";
+import type { ModuleExports } from "../../registry.js";
+
+const methods = ["createServer", "request", "get"] as const;
+
+const exports: ModuleExports = Object.fromEntries(
+  methods.map((method) => [method, { namespace: "http", method }]),
+);
 
 export const httpModule: NodeModule = {
   name: "http",
@@ -18,4 +25,5 @@ export const httpModule: NodeModule = {
     resolveFrom(import.meta.url, "../../../../runtime/ext_node/http/http.c"),
   ],
   builtins: () => ({}),
+  exports: () => exports,
 };