xbintsc 0.1.8 → 0.1.10

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

@@ -89,16 +89,23 @@ int32_t xt_string_length_value(xt_value value);
 
 /* -- function calling convention ----------------------------------------- */
 /* Every compiled function has the signature:
- *     xt_value fn(xt_value env, int32_t argc, xt_value *argv);
- * `env` carries captured values for closures (XT_UNDEFINED when there are
- * none) and `argv` carries the actual arguments. */
-typedef xt_value (*xt_code_fn)(xt_value env, int32_t argc, xt_value *argv);
+ *     xt_value fn(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv);
+ * `thisValue` is the JavaScript `this` binding (XT_UNDEFINED for plain calls),
+ * `env` is the closure value carrying captured variables, and `argv` carries
+ * the actual arguments. */
+typedef xt_value (*xt_code_fn)(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv);
 
 xt_value xt_arg(int32_t argc, xt_value *argv, int32_t index);
 xt_value xt_closure_new(void *fn, int32_t env_count, xt_value *env);
 xt_value xt_closure_call(xt_value fn, int32_t argc, xt_value *argv);
+xt_value xt_call_with_this(xt_value fn, xt_value thisValue, int32_t argc, xt_value *argv);
 xt_value xt_closure_env(xt_value fn, int32_t index);
 int32_t xt_closure_arity(xt_value fn);
+xt_value xt_this(void);
+xt_value xt_new(xt_value ctor, int32_t argc, xt_value *argv);
+xt_value xt_instance_of(xt_value value, xt_value ctor);
+xt_value xt_function_set_prototype(xt_value fn, xt_value proto);
+xt_value xt_function_get_prototype(xt_value fn);
 
 /* -- conversions ---------------------------------------------------------- */
 int xt_truthy(xt_value v);
@@ -136,7 +143,14 @@ xt_value xt_not(xt_value a);
 
 /* -- objects -------------------------------------------------------------- */
 xt_value xt_object_new(void);
+xt_value xt_object_new_with_proto(xt_value proto);
 xt_value xt_object_get(xt_value obj, xt_value key);
+xt_value xt_object_get_prototype(xt_value obj);
+xt_value xt_object_set_prototype(xt_value obj, xt_value proto);
+xt_value xt_object_freeze(xt_value obj);
+int xt_object_is_frozen(xt_value obj);
+xt_value xt_object_from_entries(xt_value entries);
+xt_value xt_object_has_own(xt_value obj, xt_value key);
 xt_value xt_object_get_cstr(xt_value obj, const char *key);
 xt_value xt_object_set(xt_value obj, xt_value key, xt_value value);
 xt_value xt_object_has(xt_value obj, xt_value key);
@@ -151,6 +165,32 @@ xt_value xt_object_spread(xt_value target, xt_value source);
 xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *argv);
 /** Implements `Math.<name>(...)`; the name is interned by the compiler. */
 xt_value xt_math_call(xt_value name, int32_t argc, xt_value *argv);
+/** Implements `JSON.parse` / `JSON.stringify`. */
+xt_value xt_json_parse(int32_t argc, xt_value *argv);
+xt_value xt_json_stringify(int32_t argc, xt_value *argv);
+/** Implements `Array.<name>(...)` statics and the `Array(...)` constructor. */
+xt_value xt_array_static(xt_value name, int32_t argc, xt_value *argv);
+/** Implements `Object.<name>(...)` statics. */
+xt_value xt_object_static(xt_value name, int32_t argc, xt_value *argv);
+/** Implements `Number.<name>(...)` / `String.<name>(...)` statics. */
+xt_value xt_number_static(xt_value name, int32_t argc, xt_value *argv);
+xt_value xt_string_static(xt_value name, int32_t argc, xt_value *argv);
+/** Map / Set constructors and dispatch. */
+xt_value xt_map_ctor(int32_t argc, xt_value *argv);
+xt_value xt_set_ctor(int32_t argc, xt_value *argv);
+xt_value xt_date_ctor(int32_t argc, xt_value *argv);
+xt_value xt_date_static(xt_value name, int32_t argc, xt_value *argv);
+xt_value xt_regexp_ctor(int32_t argc, xt_value *argv);
+
+/* -- promises / async ----------------------------------------------------- */
+xt_value xt_promise_resolve(xt_value value);
+xt_value xt_promise_reject(xt_value value);
+xt_value xt_promise_ctor(int32_t argc, xt_value *argv);
+xt_value xt_promise_static(xt_value name, int32_t argc, xt_value *argv);
+/** Unwrap an awaited value: promises yield their value, everything else is itself. */
+xt_value xt_await(xt_value value);
+/** Run queued promise reactions; called once the program body finishes. */
+void xt_drain_microtasks(void);
 
 /* -- global functions ------------------------------------------------------ */
 xt_value xt_parse_int(int32_t argc, xt_value *argv);
@@ -167,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);
@@ -195,6 +241,17 @@ void xt_console_log(int32_t argc, xt_value *argv);
 void xt_console_info(int32_t argc, xt_value *argv);
 void xt_console_warn(int32_t argc, xt_value *argv);
 void xt_console_error(int32_t argc, xt_value *argv);
+xt_value xt_console_dir(int32_t argc, xt_value *argv);
+xt_value xt_console_trace(int32_t argc, xt_value *argv);
+xt_value xt_console_assert(int32_t argc, xt_value *argv);
+xt_value xt_console_count(int32_t argc, xt_value *argv);
+xt_value xt_console_count_reset(int32_t argc, xt_value *argv);
+xt_value xt_console_group(int32_t argc, xt_value *argv);
+xt_value xt_console_group_end(int32_t argc, xt_value *argv);
+xt_value xt_console_table(int32_t argc, xt_value *argv);
+xt_value xt_console_time(int32_t argc, xt_value *argv);
+xt_value xt_console_time_end(int32_t argc, xt_value *argv);
+xt_value xt_console_time_log(int32_t argc, xt_value *argv);
 void xt_print(xt_value v);
 void xt_println(xt_value v);
 

package/runtime/rt_internal.h

@@ -40,6 +40,12 @@
 #define XT_OBJECT_KIND_OBJECT 2
 #define XT_OBJECT_KIND_ARRAY 3
 #define XT_OBJECT_KIND_FUNCTION 4
+#define XT_OBJECT_KIND_PROMISE 5
+#define XT_OBJECT_KIND_MAP 6
+#define XT_OBJECT_KIND_SET 7
+#define XT_OBJECT_KIND_DATE 8
+#define XT_OBJECT_KIND_REGEXP 9
+#define XT_OBJECT_KIND_SYMBOL 10
 
 /* Common header for every heap object. */
 typedef struct xt_header {
@@ -67,6 +73,10 @@ typedef struct {
   uint32_t count;
   uint32_t capacity;
   xt_property *properties;
+  xt_value prototype;
+  uint8_t frozen;
+  uint8_t is_array_base;
+  uint16_t reserved2;
 } xt_object;
 
 typedef struct {
@@ -84,6 +94,7 @@ typedef struct {
   int32_t arity;
   xt_string *name;
   xt_object *properties;
+  xt_value prototype;
 } xt_function;
 
 /* Allocation (xt_alloc.c). */
@@ -99,6 +110,58 @@ int32_t xt_to_int32(xt_value v);
 /* Container helper (xt_containers.c). */
 void xt_array_reserve(xt_array *array, uint32_t needed);
 
+/* Object helpers used by the standard library. */
+xt_object *xt_as_object(xt_value value);
+xt_property *xt_object_find_property(xt_object *obj, xt_string *key);
+
+/* Map / Set / Promise / Date / RegExp live in xt_stdlib.c and xt_promise.c. */
+int xt_is_promise(xt_value value);
+int xt_is_map(xt_value value);
+int xt_is_set(xt_value value);
+int xt_is_date(xt_value value);
+int xt_is_regexp(xt_value value);
+int32_t xt_map_size(xt_value value);
+int32_t xt_set_size(xt_value value);
+
+/* -- collection / date / regexp representations --------------------------- */
+typedef struct {
+  xt_header header;
+  xt_value *keys;
+  xt_value *values;
+  uint32_t count;
+  uint32_t capacity;
+} xt_map;
+
+typedef struct {
+  xt_header header;
+  xt_value *values;
+  uint32_t count;
+  uint32_t capacity;
+} xt_set_object;
+
+typedef struct {
+  xt_header header;
+  double time;
+} xt_date;
+
+typedef struct {
+  xt_header header;
+  xt_value source;
+  xt_value flags;
+} xt_regexp;
+
+/* Extended method dispatch (xt_stdlib2.c). `*handled` is set when the method
+ * was recognised, allowing an intentional `undefined` result to be returned. */
+xt_value xt_ext_array_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled);
+xt_value xt_ext_string_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled);
+xt_value xt_ext_number_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled);
+xt_value xt_ext_object_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled);
+xt_value xt_ext_container_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled);
+xt_value xt_promise_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled);
+
+/* JSON helpers used by Promise / Map immutability checks. */
+int xt_value_equals(xt_value a, xt_value b);
+
 /* Standard-library helpers (xt_stdlib.c). */
 xt_array *xt_as_array(xt_value value);
 xt_value xt_arg_at(int32_t argc, xt_value *argv, int32_t index);