xbintsc 0.1.9 → 0.1.10

package/runtime/ext_node/os/os.c

@@ -0,0 +1,165 @@
+/*
+ * Node.js `os` module for xbintsc.
+ *
+ * Exposed through namespace dispatch: `os.<name>()` lowers to
+ * `xt_os_static(<name>, argc, argv)`. Implemented: platform, arch, type,
+ * release, endianness, homedir, tmpdir, hostname, totalmem, freemem.
+ */
+
+#include "rt.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(_WIN32)
+#include <windows.h>
+#else
+#include <sys/utsname.h>
+#include <unistd.h>
+#endif
+
+static const char *xt_os_platform(void) {
+#if defined(_WIN32)
+  return "win32";
+#elif defined(__APPLE__)
+  return "darwin";
+#elif defined(__linux__)
+  return "linux";
+#elif defined(__FreeBSD__)
+  return "freebsd";
+#else
+  return "unknown";
+#endif
+}
+
+static const char *xt_os_type(void) {
+#if defined(_WIN32)
+  return "Windows_NT";
+#elif defined(__APPLE__)
+  return "Darwin";
+#elif defined(__linux__)
+  return "Linux";
+#elif defined(__FreeBSD__)
+  return "FreeBSD";
+#else
+  return "Unknown";
+#endif
+}
+
+static const char *xt_os_arch(void) {
+#if defined(__x86_64__) || defined(_M_X64)
+  return "x64";
+#elif defined(__aarch64__) || defined(_M_ARM64)
+  return "arm64";
+#elif defined(__i386__) || defined(_M_IX86)
+  return "ia32";
+#elif defined(__arm__)
+  return "arm";
+#else
+  return "unknown";
+#endif
+}
+
+static xt_value xt_os_string(const char *value) {
+  return value ? xt_string_from_cstr(value) : xt_undefined();
+}
+
+static xt_value xt_os_totalmem(void) {
+#if defined(_WIN32)
+  MEMORYSTATUSEX status;
+  status.dwLength = sizeof(status);
+  if (GlobalMemoryStatusEx(&status)) return xt_number((double)status.ullTotalPhys);
+  return xt_number(0);
+#else
+  long pages = sysconf(_SC_PHYS_PAGES);
+  long pageSize = sysconf(_SC_PAGESIZE);
+  if (pages <= 0 || pageSize <= 0) return xt_number(0);
+  return xt_number((double)pages * (double)pageSize);
+#endif
+}
+
+static xt_value xt_os_freemem(void) {
+#if defined(_WIN32)
+  MEMORYSTATUSEX status;
+  status.dwLength = sizeof(status);
+  if (GlobalMemoryStatusEx(&status)) return xt_number((double)status.ullAvailPhys);
+  return xt_number(0);
+#elif defined(_SC_AVPHYS_PAGES)
+  long pages = sysconf(_SC_AVPHYS_PAGES);
+  long pageSize = sysconf(_SC_PAGESIZE);
+  if (pages <= 0 || pageSize <= 0) return xt_number(0);
+  return xt_number((double)pages * (double)pageSize);
+#else
+  /* macOS exposes free memory through Mach APIs only; report total memory. */
+  return xt_os_totalmem();
+#endif
+}
+
+xt_value xt_os_static(xt_value name, int32_t argc, xt_value *argv) {
+  const char *method = xt_string_data(name);
+  if (!method) return xt_undefined();
+  (void)argc;
+  (void)argv;
+
+  if (strcmp(method, "platform") == 0) return xt_string_from_cstr(xt_os_platform());
+  if (strcmp(method, "type") == 0) return xt_string_from_cstr(xt_os_type());
+  if (strcmp(method, "arch") == 0) return xt_string_from_cstr(xt_os_arch());
+  if (strcmp(method, "endianness") == 0) {
+#if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+    return xt_string_from_cstr("BE");
+#else
+    return xt_string_from_cstr("LE");
+#endif
+  }
+  if (strcmp(method, "homedir") == 0) {
+#if defined(_WIN32)
+    return xt_os_string(getenv("USERPROFILE"));
+#else
+    return xt_os_string(getenv("HOME"));
+#endif
+  }
+  if (strcmp(method, "tmpdir") == 0) {
+#if defined(_WIN32)
+    const char *temp = getenv("TEMP");
+    return xt_os_string(temp ? temp : "C:\\Windows\\Temp");
+#else
+    const char *temp = getenv("TMPDIR");
+    return xt_os_string(temp ? temp : "/tmp");
+#endif
+  }
+  if (strcmp(method, "hostname") == 0) {
+    char buffer[256];
+    if (gethostname(buffer, sizeof(buffer)) != 0) return xt_undefined();
+    buffer[sizeof(buffer) - 1] = '\0';
+    return xt_string_from_cstr(buffer);
+  }
+  if (strcmp(method, "release") == 0) {
+#if defined(_WIN32)
+    return xt_string_from_cstr("0.0.0");
+#else
+    struct utsname info;
+    if (uname(&info) != 0) return xt_undefined();
+    return xt_string_from_cstr(info.release);
+#endif
+  }
+  if (strcmp(method, "totalmem") == 0) return xt_os_totalmem();
+  if (strcmp(method, "freemem") == 0) return xt_os_freemem();
+  if (strcmp(method, "cpus") == 0) {
+    /* No per-core details yet; report the logical processor count as length. */
+    long processors = sysconf(_SC_NPROCESSORS_ONLN);
+    if (processors <= 0) processors = 1;
+    xt_value *items = (xt_value *)malloc(sizeof(xt_value) * (size_t)processors);
+    if (!items) return xt_array_new(0, NULL);
+    for (long i = 0; i < processors; i++) {
+      xt_value info = xt_object_new();
+      xt_object_set(info, xt_string_from_cstr("model"), xt_string_from_cstr("unknown"));
+      xt_object_set(info, xt_string_from_cstr("speed"), xt_number(0));
+      items[i] = info;
+    }
+    xt_value result = xt_array_new((int32_t)processors, items);
+    free(items);
+    return result;
+  }
+  return xt_undefined();
+}

package/runtime/ext_node/path/path.c

@@ -0,0 +1,324 @@
+/*
+ * Node.js `path` module for xbintsc.
+ *
+ * Exposed through namespace dispatch: the compiler lowers `path.<name>(...)`
+ * to `xt_path_static(<name>, argc, argv)`. Paths are handled with POSIX
+ * semantics (`/` separator), matching Node's `path.posix` on every platform.
+ *
+ * Implemented: join, resolve, normalize, dirname, basename, extname,
+ *              isAbsolute, relative.
+ */
+
+#include "rt.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#define XT_PATH_MAX 4096
+
+static int xt_path_is_absolute(const char *path) { return path && path[0] == '/'; }
+
+static void xt_path_normalize(const char *input, char *out, size_t size) {
+  int absolute = input[0] == '/';
+  size_t length = strlen(input);
+  char *copy = (char *)malloc(length + 1);
+  if (!copy) {
+    out[0] = '\0';
+    return;
+  }
+  memcpy(copy, input, length + 1);
+
+  size_t capacity = 8;
+  size_t count = 0;
+  char **segments = (char **)malloc(sizeof(char *) * capacity);
+  if (!segments) {
+    free(copy);
+    out[0] = '\0';
+    return;
+  }
+
+  size_t i = 0;
+  while (i < length) {
+    while (i < length && copy[i] == '/') i++;
+    if (i >= length) break;
+    size_t start = i;
+    while (i < length && copy[i] != '/') i++;
+    if (i < length) {
+      copy[i] = '\0';
+      i++;
+    } else {
+      copy[i] = '\0';
+    }
+    char *segment = copy + start;
+    if (strcmp(segment, ".") == 0) continue;
+    if (strcmp(segment, "..") == 0) {
+      if (count > 0 && strcmp(segments[count - 1], "..") != 0) {
+        count--;
+      } else if (!absolute) {
+        if (count == capacity) {
+          capacity *= 2;
+          segments = (char **)realloc(segments, sizeof(char *) * capacity);
+        }
+        segments[count++] = segment;
+      }
+      continue;
+    }
+    if (count == capacity) {
+      capacity *= 2;
+      segments = (char **)realloc(segments, sizeof(char *) * capacity);
+    }
+    segments[count++] = segment;
+  }
+
+  size_t position = 0;
+  if (absolute && position < size) out[position++] = '/';
+  for (size_t s = 0; s < count; s++) {
+    size_t segmentLength = strlen(segments[s]);
+    if (position + segmentLength + 2 > size) break;
+    if (s > 0) out[position++] = '/';
+    memcpy(out + position, segments[s], segmentLength);
+    position += segmentLength;
+  }
+  out[position] = '\0';
+  if (position == 0) {
+    out[0] = '.';
+    out[1] = '\0';
+  }
+  free(segments);
+  free(copy);
+}
+
+static void xt_path_absolute(const char *path, char *out, size_t size) {
+  if (xt_path_is_absolute(path)) {
+    snprintf(out, size, "%s", path);
+  } else {
+    char cwd[XT_PATH_MAX];
+    if (!getcwd(cwd, sizeof(cwd))) cwd[0] = '\0';
+    snprintf(out, size, "%s/%s", cwd, path);
+  }
+  char normalized[XT_PATH_MAX];
+  xt_path_normalize(out, normalized, sizeof(normalized));
+  snprintf(out, size, "%s", normalized);
+}
+
+typedef struct {
+  char *storage;
+  char **segments;
+  size_t count;
+} xt_path_parts;
+
+static void xt_path_split(const char *path, xt_path_parts *parts) {
+  size_t length = strlen(path);
+  parts->storage = (char *)malloc(length + 1);
+  parts->count = 0;
+  parts->segments = NULL;
+  if (!parts->storage) return;
+  memcpy(parts->storage, path, length + 1);
+
+  size_t capacity = 8;
+  parts->segments = (char **)malloc(sizeof(char *) * capacity);
+  if (!parts->segments) return;
+
+  size_t i = 0;
+  while (i < length) {
+    while (i < length && parts->storage[i] == '/') i++;
+    if (i >= length) break;
+    size_t start = i;
+    while (i < length && parts->storage[i] != '/') i++;
+    if (i < length) {
+      parts->storage[i] = '\0';
+      i++;
+    } else {
+      parts->storage[i] = '\0';
+    }
+    if (parts->count == capacity) {
+      capacity *= 2;
+      parts->segments = (char **)realloc(parts->segments, sizeof(char *) * capacity);
+    }
+    parts->segments[parts->count++] = parts->storage + start;
+  }
+}
+
+static void xt_path_parts_free(xt_path_parts *parts) {
+  free(parts->segments);
+  free(parts->storage);
+}
+
+/* ------------------------------------------------------------------------- */
+/* Individual operations                                                     */
+/* ------------------------------------------------------------------------- */
+
+static xt_value xt_path_join(int32_t argc, xt_value *argv) {
+  size_t total = 1;
+  for (int32_t i = 0; i < argc; i++) {
+    const char *part = xt_string_data(xt_to_string(argv[i]));
+    if (part) total += strlen(part) + 1;
+  }
+  char *joined = (char *)malloc(total);
+  if (!joined) return xt_undefined();
+  joined[0] = '\0';
+  for (int32_t i = 0; i < argc; i++) {
+    const char *part = xt_string_data(xt_to_string(argv[i]));
+    if (!part || part[0] == '\0') continue;
+    if (joined[0] != '\0') strcat(joined, "/");
+    strcat(joined, part);
+  }
+  char normalized[XT_PATH_MAX];
+  xt_path_normalize(joined, normalized, sizeof(normalized));
+  free(joined);
+  return xt_string_from_cstr(normalized);
+}
+
+static xt_value xt_path_resolve(int32_t argc, xt_value *argv) {
+  char result[XT_PATH_MAX];
+  result[0] = '\0';
+  for (int32_t i = 0; i < argc; i++) {
+    const char *part = xt_string_data(xt_to_string(argv[i]));
+    if (!part || part[0] == '\0') continue;
+    if (xt_path_is_absolute(part)) {
+      snprintf(result, sizeof(result), "%s", part);
+    } else if (result[0] == '\0') {
+      snprintf(result, sizeof(result), "%s", part);
+    } else {
+      size_t used = strlen(result);
+      snprintf(result + used, sizeof(result) - used, "/%s", part);
+    }
+  }
+  if (result[0] == '\0') {
+    if (!getcwd(result, sizeof(result))) result[0] = '\0';
+  } else if (!xt_path_is_absolute(result)) {
+    char cwd[XT_PATH_MAX];
+    if (!getcwd(cwd, sizeof(cwd))) cwd[0] = '\0';
+    char combined[XT_PATH_MAX];
+    snprintf(combined, sizeof(combined), "%s/%s", cwd, result);
+    snprintf(result, sizeof(result), "%s", combined);
+  }
+  char normalized[XT_PATH_MAX];
+  xt_path_normalize(result, normalized, sizeof(normalized));
+  return xt_string_from_cstr(normalized);
+}
+
+static xt_value xt_path_dirname(const char *path) {
+  size_t length = strlen(path);
+  while (length > 1 && path[length - 1] == '/') length--;
+  size_t i = length;
+  while (i > 0 && path[i - 1] != '/') i--;
+  if (i == 0) return xt_string_from_cstr(".");
+  size_t end = i - 1;
+  if (end == 0) return xt_string_from_cstr("/");
+  while (end > 1 && path[end - 1] == '/') end--;
+  return xt_string_new(path, end);
+}
+
+static xt_value xt_path_basename(const char *path, const char *extension) {
+  size_t length = strlen(path);
+  while (length > 0 && path[length - 1] == '/') length--;
+  if (length == 0) return xt_string_from_cstr("");
+  size_t start = length;
+  while (start > 0 && path[start - 1] != '/') start--;
+  size_t end = length;
+  if (extension && extension[0] != '\0') {
+    size_t extensionLength = strlen(extension);
+    if (end - start > extensionLength &&
+        strncmp(path + end - extensionLength, extension, extensionLength) == 0) {
+      end -= extensionLength;
+    }
+  }
+  return xt_string_new(path + start, end - start);
+}
+
+static xt_value xt_path_extname(const char *path) {
+  size_t length = strlen(path);
+  size_t start = 0;
+  for (size_t i = 0; i < length; i++) {
+    if (path[i] == '/') start = i + 1;
+  }
+  size_t dot = length;
+  for (size_t i = start; i < length; i++) {
+    if (path[i] == '.') dot = i;
+  }
+  if (dot == length || dot == start) return xt_string_from_cstr("");
+  return xt_string_new(path + dot, length - dot);
+}
+
+static xt_value xt_path_relative(const char *from, const char *to) {
+  char fromAbsolute[XT_PATH_MAX];
+  char toAbsolute[XT_PATH_MAX];
+  xt_path_absolute(from, fromAbsolute, sizeof(fromAbsolute));
+  xt_path_absolute(to, toAbsolute, sizeof(toAbsolute));
+
+  xt_path_parts fromParts;
+  xt_path_parts toParts;
+  xt_path_split(fromAbsolute, &fromParts);
+  xt_path_split(toAbsolute, &toParts);
+
+  size_t common = 0;
+  while (common < fromParts.count && common < toParts.count &&
+         strcmp(fromParts.segments[common], toParts.segments[common]) == 0) {
+    common++;
+  }
+
+  char result[XT_PATH_MAX];
+  result[0] = '\0';
+  size_t position = 0;
+  for (size_t i = common; i < fromParts.count && position + 3 < sizeof(result); i++) {
+    if (position > 0) result[position++] = '/';
+    result[position++] = '.';
+    result[position++] = '.';
+  }
+  for (size_t i = common; i < toParts.count; i++) {
+    size_t segmentLength = strlen(toParts.segments[i]);
+    if (position + segmentLength + 2 > sizeof(result)) break;
+    if (position > 0) result[position++] = '/';
+    memcpy(result + position, toParts.segments[i], segmentLength);
+    position += segmentLength;
+  }
+  result[position] = '\0';
+
+  xt_path_parts_free(&fromParts);
+  xt_path_parts_free(&toParts);
+  return xt_string_from_cstr(result);
+}
+
+/* ------------------------------------------------------------------------- */
+/* Dispatch                                                                  */
+/* ------------------------------------------------------------------------- */
+
+xt_value xt_path_static(xt_value name, int32_t argc, xt_value *argv) {
+  const char *method = xt_string_data(name);
+  if (!method) return xt_undefined();
+
+  if (strcmp(method, "join") == 0) return xt_path_join(argc, argv);
+  if (strcmp(method, "resolve") == 0) return xt_path_resolve(argc, argv);
+  if (strcmp(method, "isAbsolute") == 0) {
+    const char *path = argc > 0 ? xt_string_data(xt_to_string(argv[0])) : NULL;
+    return xt_bool(xt_path_is_absolute(path));
+  }
+  if (strcmp(method, "normalize") == 0) {
+    const char *path = argc > 0 ? xt_string_data(xt_to_string(argv[0])) : "";
+    char normalized[XT_PATH_MAX];
+    xt_path_normalize(path ? path : "", normalized, sizeof(normalized));
+    return xt_string_from_cstr(normalized);
+  }
+  if (strcmp(method, "dirname") == 0) {
+    const char *path = argc > 0 ? xt_string_data(xt_to_string(argv[0])) : "";
+    return xt_path_dirname(path ? path : "");
+  }
+  if (strcmp(method, "basename") == 0) {
+    const char *path = argc > 0 ? xt_string_data(xt_to_string(argv[0])) : "";
+    const char *extension = argc > 1 ? xt_string_data(xt_to_string(argv[1])) : NULL;
+    return xt_path_basename(path ? path : "", extension);
+  }
+  if (strcmp(method, "extname") == 0) {
+    const char *path = argc > 0 ? xt_string_data(xt_to_string(argv[0])) : "";
+    return xt_path_extname(path ? path : "");
+  }
+  if (strcmp(method, "relative") == 0) {
+    const char *from = argc > 0 ? xt_string_data(xt_to_string(argv[0])) : "";
+    const char *to = argc > 1 ? xt_string_data(xt_to_string(argv[1])) : "";
+    return xt_path_relative(from ? from : "", to ? to : "");
+  }
+  return xt_undefined();
+}

package/runtime/ext_node/process/process.c

@@ -0,0 +1,137 @@
+/*
+ * Node.js `process` object for xbintsc.
+ *
+ * The compiler lowers `process.<method>(...)` to
+ * `xt_process_call(<method>, argc, argv)` and `process.<property>` to
+ * `xt_process_get(<property>)`. Provided: cwd, exit, uptime, hrtime and the
+ * platform/arch/pid/argv/env properties.
+ */
+
+#include "rt.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#if defined(_WIN32)
+extern char **_environ;
+#define XT_ENVIRON _environ
+#include <process.h>
+#define xt_getpid _getpid
+#else
+extern char **environ;
+#define XT_ENVIRON environ
+#include <unistd.h>
+#define xt_getpid getpid
+#endif
+
+static const char *xt_process_platform(void) {
+#if defined(_WIN32)
+  return "win32";
+#elif defined(__APPLE__)
+  return "darwin";
+#elif defined(__linux__)
+  return "linux";
+#else
+  return "unknown";
+#endif
+}
+
+static const char *xt_process_arch(void) {
+#if defined(__x86_64__) || defined(_M_X64)
+  return "x64";
+#elif defined(__aarch64__) || defined(_M_ARM64)
+  return "arm64";
+#elif defined(__i386__) || defined(_M_IX86)
+  return "ia32";
+#elif defined(__arm__)
+  return "arm";
+#else
+  return "unknown";
+#endif
+}
+
+static xt_value xt_process_env(void) {
+  xt_value object = xt_object_new();
+  if (!XT_ENVIRON) return object;
+  for (char **entry = XT_ENVIRON; *entry; entry++) {
+    const char *equals = strchr(*entry, '=');
+    if (!equals) continue;
+    xt_value key = xt_string_new(*entry, (size_t)(equals - *entry));
+    xt_object_set(object, key, xt_string_from_cstr(equals + 1));
+  }
+  return object;
+}
+
+static xt_value xt_process_argv(void) {
+  int32_t count = xt_program_argc;
+  if (count <= 0 || !xt_program_argv) return xt_array_new(0, NULL);
+  xt_value *items = (xt_value *)malloc(sizeof(xt_value) * (size_t)count);
+  if (!items) return xt_array_new(0, NULL);
+  for (int32_t i = 0; i < count; i++) items[i] = xt_string_from_cstr(xt_program_argv[i]);
+  xt_value result = xt_array_new(count, items);
+  free(items);
+  return result;
+}
+
+xt_value xt_process_call(xt_value name, int32_t argc, xt_value *argv) {
+  const char *method = xt_string_data(name);
+  if (!method) return xt_undefined();
+
+  if (strcmp(method, "cwd") == 0) {
+    char buffer[4096];
+    if (!getcwd(buffer, sizeof(buffer))) return xt_undefined();
+    return xt_string_from_cstr(buffer);
+  }
+  if (strcmp(method, "exit") == 0) {
+    int code = argc > 0 ? (int)xt_to_number(argv[0]) : 0;
+    exit(code);
+    return xt_undefined();
+  }
+  if (strcmp(method, "uptime") == 0) {
+    return xt_number((double)clock() / (double)CLOCKS_PER_SEC);
+  }
+  if (strcmp(method, "hrtime") == 0) {
+    struct timespec now;
+#if defined(CLOCK_MONOTONIC)
+    clock_gettime(CLOCK_MONOTONIC, &now);
+#else
+    now.tv_sec = (long)time(NULL);
+    now.tv_nsec = 0;
+#endif
+    xt_value items[2];
+    items[0] = xt_number((double)now.tv_sec);
+    items[1] = xt_number((double)now.tv_nsec);
+    return xt_array_new(2, items);
+  }
+  if (strcmp(method, "getuid") == 0) {
+#if defined(_WIN32)
+    return xt_number(0);
+#else
+    return xt_number((double)getuid());
+#endif
+  }
+  return xt_undefined();
+}
+
+xt_value xt_process_get(xt_value name) {
+  const char *key = xt_string_data(name);
+  if (!key) return xt_undefined();
+
+  if (strcmp(key, "platform") == 0) return xt_string_from_cstr(xt_process_platform());
+  if (strcmp(key, "arch") == 0) return xt_string_from_cstr(xt_process_arch());
+  if (strcmp(key, "pid") == 0) return xt_number((double)xt_getpid());
+  if (strcmp(key, "ppid") == 0) {
+#if defined(_WIN32)
+    return xt_number(0);
+#else
+    return xt_number((double)getppid());
+#endif
+  }
+  if (strcmp(key, "version") == 0) return xt_string_from_cstr("v0.0.0");
+  if (strcmp(key, "argv") == 0) return xt_process_argv();
+  if (strcmp(key, "env") == 0) return xt_process_env();
+  if (strcmp(key, "title") == 0) return xt_string_from_cstr("xbintsc");
+  return xt_undefined();
+}

package/runtime/rt.h

@@ -207,6 +207,12 @@ xt_value xt_delete(xt_value obj, xt_value key);
 /** Collect `argv[start..argc)` into a new array (rest parameters). */
 xt_value xt_rest_args(int32_t argc, xt_value *argv, int32_t start);
 
+/* -- program arguments ---------------------------------------------------- */
+/* Captured from `main` so host extensions can expose `process.argv`. */
+void xt_set_program_args(int32_t argc, char **argv);
+extern int32_t xt_program_argc;
+extern char **xt_program_argv;
+
 /* -- arrays --------------------------------------------------------------- */
 xt_value xt_array_new(int32_t count, xt_value *items);
 xt_value xt_array_get(xt_value arr, xt_value index);

package/runtime/xt_io.c

@@ -32,6 +32,15 @@ typedef struct xt_try_frame {
 
 static xt_try_frame *g_try_top = NULL;
 
+/* Program arguments, captured once by `xt_set_program_args` from `main`. */
+int32_t xt_program_argc = 0;
+char **xt_program_argv = NULL;
+
+void xt_set_program_args(int32_t argc, char **argv) {
+  xt_program_argc = argc;
+  xt_program_argv = argv;
+}
+
 void *xt_try_enter(void) {
   xt_try_frame *frame = (xt_try_frame *)calloc(1, sizeof(xt_try_frame));
   if (!frame) abort();

package/scripts/build-runtime.mjs

@@ -27,6 +27,11 @@ const sources = [
   ["xt_io.c", "xt_io.o"],
   // Node extension sources.
   ["ext_node/fs/read_file.c", "ext_node_fs_read_file.o"],
+  ["ext_node/fs/write_file.c", "ext_node_fs_write_file.o"],
+  ["ext_node/fs/fs_ops.c", "ext_node_fs_fs_ops.o"],
+  ["ext_node/path/path.c", "ext_node_path_path.o"],
+  ["ext_node/os/os.c", "ext_node_os_os.o"],
+  ["ext_node/process/process.c", "ext_node_process_process.o"],
 ];
 
 for (const [source, object] of sources) {

package/src/codegen/generator/calls.ts

@@ -24,6 +24,7 @@ import {
   GLOBAL_FUNCTIONS,
   MATH_CONSTANTS,
   MATH_FUNCTIONS,
+  NAMESPACE_PROPERTIES,
   NAMESPACE_STATICS,
   propertyNameText,
 } from "./tables.js";
@@ -259,6 +260,18 @@ export const callMethods: CallMethods = {
     ) {
       return numberLiteral(MATH_CONSTANTS[node.name.text]!);
     }
+    if (
+      node.expression.kind === SyntaxKind.Identifier &&
+      !this.binding.symbolOfIdentifier.get(node.expression as Identifier)
+    ) {
+      const getter = NAMESPACE_PROPERTIES[(node.expression as Identifier).text];
+      if (getter) {
+        const key = this.stringValue(node.name.text);
+        const result = this.reg();
+        this.emit(`  ${result} = call i64 @${getter}(i64 ${key})`);
+        return result;
+      }
+    }
     const object = this.emitExpression(node.expression);
     const access = (): string => {
       if (node.name.text === "length") {

package/src/codegen/generator/module.ts

@@ -155,6 +155,7 @@ export const moduleMethods: ModuleMethods = {
     this.functions.push(
       [
         "define i32 @main(i32 %argc, i8** %argv) {",
+        "  call void @xt_set_program_args(i32 %argc, i8** %argv)",
         `  %result = call i64 @${moduleName}(i64 ${i64(XT_UNDEFINED)}, i64 ${i64(XT_UNDEFINED)}, i32 0, i64* null)`,
         "  call void @xt_drain_microtasks()",
         "  ret i32 0",