xbintsc 0.3.8 → 0.3.10

package/src/extensions/node/index.ts

@@ -19,6 +19,9 @@ import { osModule } from "./os/index.js";
 import { processModule } from "./process/index.js";
 import { bufferModule } from "./buffer/index.js";
 import { streamModule } from "./stream/index.js";
+import { streamPromisesModule } from "./stream-promises/index.js";
+import { zlibModule } from "./zlib/index.js";
+import { workerThreadsModule } from "./worker_threads/index.js";
 import { netModule } from "./net/index.js";
 import { dgramModule } from "./dgram/index.js";
 import { httpModule } from "./http/index.js";
@@ -28,6 +31,8 @@ import { childProcessModule } from "./child_process/index.js";
 import { eventsModule } from "./events/index.js";
 import { utilModule } from "./util/index.js";
 import { querystringModule } from "./querystring/index.js";
+import { assertModule } from "./assert/index.js";
+import { testModule } from "./test/index.js";
 
 /** Every Node module the extension currently provides. */
 const modules: readonly NodeModule[] = [
@@ -38,6 +43,9 @@ const modules: readonly NodeModule[] = [
   processModule,
   bufferModule,
   streamModule,
+  streamPromisesModule,
+  zlibModule,
+  workerThreadsModule,
   netModule,
   dgramModule,
   httpModule,
@@ -47,6 +55,8 @@ const modules: readonly NodeModule[] = [
   eventsModule,
   utilModule,
   querystringModule,
+  assertModule,
+  testModule,
 ];
 
 export const nodeExtension: Extension = {

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

@@ -8,10 +8,20 @@
 
 import type { NodeModule } from "../module.js";
 import { resolveFrom } from "../module.js";
+import type { ModuleExports } from "../../registry.js";
+
+const methods = ["createServer", "connect", "createConnection", "isIP", "isIPv4", "isIPv6"] as const;
+
+const exports: ModuleExports = {
+  ...Object.fromEntries(methods.map((method) => [method, { namespace: "net", method }])),
+  Server: { symbol: "xt_net_server_ctor", isConstructor: true },
+  Socket: { symbol: "xt_net_socket_ctor", isConstructor: true },
+};
 
 export const netModule: NodeModule = {
   name: "net",
   namespace: "net",
   runtimeSources: () => [resolveFrom(import.meta.url, "../../../../runtime/ext_node/net/net.c")],
   builtins: () => ({}),
+  exports: () => exports,
 };

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

@@ -9,10 +9,20 @@
 
 import type { NodeModule } from "../module.js";
 import { resolveFrom } from "../module.js";
+import type { ModuleExports } from "../../registry.js";
+
+const exports: ModuleExports = {
+  Readable: { symbol: "xt_readable_ctor", isConstructor: true },
+  Writable: { symbol: "xt_writable_ctor", isConstructor: true },
+  Duplex: { symbol: "xt_duplex_ctor", isConstructor: true },
+  Transform: { symbol: "xt_transform_ctor", isConstructor: true },
+  PassThrough: { symbol: "xt_pass_through_ctor", isConstructor: true },
+};
 
 export const streamModule: NodeModule = {
   name: "stream",
   namespace: "stream",
   runtimeSources: () => [resolveFrom(import.meta.url, "../../../../runtime/ext_node/stream/stream.c")],
   builtins: () => ({}),
+  exports: () => exports,
 };

package/src/extensions/node/stream-promises/index.ts

@@ -0,0 +1,18 @@
+/**
+ * Node's `stream/promises` module.
+ *
+ * Provides `pipeline`, implemented synchronously in
+ * `runtime/ext_node/stream/pipeline.c` and returned as an already-resolved
+ * promise so `await pipeline(...)` works.
+ */
+
+import type { NodeModule } from "../module.js";
+import { resolveFrom } from "../module.js";
+
+export const streamPromisesModule: NodeModule = {
+  name: "stream/promises",
+  runtimeSources: () => [resolveFrom(import.meta.url, "../../../../runtime/ext_node/stream/pipeline.c")],
+  builtins: () => ({
+    pipeline: { symbol: "xt_node_stream_pipeline" },
+  }),
+};

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

@@ -0,0 +1,35 @@
+/**
+ * Node's `test` module (`node:test`).
+ *
+ * A minimal synchronous test runner: `test(name, fn)` executes `fn` immediately,
+ * catching assertion failures and reporting TAP output. `import test from
+ * "node:test"` binds the callable default export; `import { test }` and
+ * `test.skip` / `test.todo` / `test.only` are also provided.
+ */
+
+import type { NodeModule } from "../module.js";
+import { resolveFrom } from "../module.js";
+import type { ModuleExports } from "../../registry.js";
+
+const runTest = { symbol: "xt_node_test" } as const;
+
+const exports: ModuleExports = {
+  default: runTest,
+  test: runTest,
+  it: runTest,
+  describe: runTest,
+  skip: { symbol: "xt_node_test_skip" },
+  todo: { symbol: "xt_node_test_todo" },
+  only: { symbol: "xt_node_test" },
+  before: { symbol: "xt_node_test_hook" },
+  after: { symbol: "xt_node_test_hook" },
+  beforeEach: { symbol: "xt_node_test_hook" },
+  afterEach: { symbol: "xt_node_test_hook" },
+};
+
+export const testModule: NodeModule = {
+  name: "test",
+  runtimeSources: () => [resolveFrom(import.meta.url, "../../../../runtime/ext_node/test/test.c")],
+  builtins: () => ({}),
+  exports: () => exports,
+};

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

@@ -0,0 +1,26 @@
+/**
+ * Node's `worker_threads` module.
+ *
+ * xbintsc emulates a worker by re-running the current executable as a child
+ * process; `isMainThread`, `workerData` and `parentPort` become value bindings
+ * (nullary runtime getters) and `Worker` is a constructor. See
+ * `runtime/ext_node/worker_threads/worker_threads.c`.
+ */
+
+import type { NodeModule } from "../module.js";
+import { resolveFrom } from "../module.js";
+import type { ModuleExports } from "../../registry.js";
+
+const exports: ModuleExports = {
+  Worker: { symbol: "xt_worker_ctor", isConstructor: true },
+  isMainThread: { valueSymbol: "xt_worker_is_main_thread" },
+  workerData: { valueSymbol: "xt_worker_data" },
+  parentPort: { valueSymbol: "xt_worker_parent_port" },
+};
+
+export const workerThreadsModule: NodeModule = {
+  name: "worker_threads",
+  runtimeSources: () => [resolveFrom(import.meta.url, "../../../../runtime/ext_node/worker_threads/worker_threads.c")],
+  builtins: () => ({}),
+  exports: () => exports,
+};

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

@@ -0,0 +1,17 @@
+/**
+ * Node's `zlib` module.
+ *
+ * Only `createGzip()` is implemented. It returns a descriptor consumed by
+ * `stream/promises`' `pipeline`; see `runtime/ext_node/zlib/zlib.c`.
+ */
+
+import type { NodeModule } from "../module.js";
+import { resolveFrom } from "../module.js";
+
+export const zlibModule: NodeModule = {
+  name: "zlib",
+  runtimeSources: () => [resolveFrom(import.meta.url, "../../../../runtime/ext_node/zlib/zlib.c")],
+  builtins: () => ({
+    createGzip: { symbol: "xt_node_create_gzip" },
+  }),
+};

package/src/extensions/registry.ts

@@ -28,6 +28,12 @@ export interface ModuleExport {
   readonly returnVoid?: boolean;
   readonly namespace?: string;
   readonly method?: string;
+  /**
+   * Runtime getter used when the binding is read as a *value* rather than
+   * called (e.g. `import { isMainThread } from "worker_threads"`). The symbol
+   * has the uniform `(i32, i64*)` ABI and is invoked with no arguments.
+   */
+  readonly valueSymbol?: string;
   /**
    * Marks a runtime symbol as a constructor callable with `new` (it has the
    * `(i32, i64*)` signature). Lets `import { EventEmitter } from "events"` be