xbintsc 0.3.35 → 0.3.49

package/runtime/ext_gui/renderer_text.cpp

@@ -187,22 +187,26 @@ void flushAtlas(SDL_GPUDevice *device) {
 }
 
 SDL_GPUGraphicsPipeline *createTextPipeline(SDL_GPUDevice *device, SDL_Window *reference) {
+  const ShaderSource text_vs = selectShader(device, ShaderProgram::Text, false);
+  const ShaderSource text_fs = selectShader(device, ShaderProgram::Text, true);
+  if (!text_vs.valid() || !text_fs.valid()) return nullptr;
+
   SDL_GPUShaderCreateInfo vs_info;
   memset(&vs_info, 0, sizeof(vs_info));
-  vs_info.code_size = strlen(kTextMSL);
-  vs_info.code = (const Uint8 *)kTextMSL;
-  vs_info.entrypoint = "vs_text";
-  vs_info.format = SDL_GPU_SHADERFORMAT_MSL;
+  vs_info.code_size = text_vs.size;
+  vs_info.code = text_vs.code;
+  vs_info.entrypoint = text_vs.entry;
+  vs_info.format = text_vs.format;
   vs_info.stage = SDL_GPU_SHADERSTAGE_VERTEX;
   vs_info.num_uniform_buffers = 1;
   SDL_GPUShader *vs = SDL_CreateGPUShader(device, &vs_info);
 
   SDL_GPUShaderCreateInfo fs_info;
   memset(&fs_info, 0, sizeof(fs_info));
-  fs_info.code_size = strlen(kTextMSL);
-  fs_info.code = (const Uint8 *)kTextMSL;
-  fs_info.entrypoint = "fs_text";
-  fs_info.format = SDL_GPU_SHADERFORMAT_MSL;
+  fs_info.code_size = text_fs.size;
+  fs_info.code = text_fs.code;
+  fs_info.entrypoint = text_fs.entry;
+  fs_info.format = text_fs.format;
   fs_info.stage = SDL_GPU_SHADERSTAGE_FRAGMENT;
   fs_info.num_samplers = 1;
   SDL_GPUShader *fs = SDL_CreateGPUShader(device, &fs_info);

package/runtime/ext_gui/shaders.hlsl

@@ -0,0 +1,98 @@
+/*
+ * xbintsc GUI engine — shader sources compiled ahead of time into the embedded
+ * blobs in `renderer_blobs.h`.
+ *
+ * Three programs, two entry points each:
+ *   - `vs_main` / `fs_main`   rounded-rectangle fills
+ *   - `vs_text` / `fs_text`   glyph quads (single-channel atlas)
+ *   - `vs_text` / `fs_image`  image quads (RGBA texture)
+ *
+ * `vs_main` and `vs_text` are identical in effect; they are kept separate so the
+ * Metal (MSL) path keeps its distinct entry-point names, and this file is the
+ * HLSL half of the pair. Vertex attribute semantics map 1:1 onto
+ * `SDL_GPUVertexAttribute.location`, and the push constant becomes `b0`.
+ *
+ * Compile with (Windows SDK `dxc`):
+ *   dxc -T vs_6_0 -E vs_main  -Fo fill_vs.dxil  shaders.hlsl
+ *   dxc -T ps_6_0 -E fs_main  -Fo fill_fs.dxil  shaders.hlsl
+ *   dxc -T vs_6_0 -E vs_text  -Fo text_vs.dxil  shaders.hlsl
+ *   dxc -T ps_6_0 -E fs_text  -Fo text_fs.dxil  shaders.hlsl
+ *   dxc -T ps_6_0 -E fs_image -Fo image_fs.dxil shaders.hlsl
+ */
+
+cbuffer Viewport : register(b0) { float2 viewport; };
+
+/* -- fills ---------------------------------------------------------------- */
+
+struct FillIn {
+    float2 position : TEXCOORD0;
+    float2 local    : TEXCOORD1;
+    float2 halfsize : TEXCOORD2;
+    float  radius   : TEXCOORD3;
+    float4 color    : TEXCOORD4;
+};
+
+struct FillOut {
+    float4 position : SV_Position;
+    float2 local    : TEXCOORD1;
+    float2 halfsize : TEXCOORD2;
+    float  radius   : TEXCOORD3;
+    float4 color    : TEXCOORD4;
+};
+
+FillOut vs_main(FillIn input) {
+    FillOut output;
+    float2 ndc = float2(input.position.x / viewport.x * 2.0 - 1.0,
+                        1.0 - input.position.y / viewport.y * 2.0);
+    output.position = float4(ndc, 0.0, 1.0);
+    output.local = input.local;
+    output.halfsize = input.halfsize;
+    output.radius = input.radius;
+    output.color = input.color;
+    return output;
+}
+
+float4 fs_main(FillOut input) : SV_Target {
+    float2 d = abs(input.local) - input.halfsize + input.radius;
+    float dist = min(max(d.x, d.y), 0.0) + length(max(d, 0.0)) - input.radius;
+    float aa = max(fwidth(dist), 0.0001);
+    float alpha = clamp(0.5 - dist / aa, 0.0, 1.0);
+    return float4(input.color.rgb, input.color.a * alpha);
+}
+
+/* -- text and images ------------------------------------------------------ */
+
+struct TextIn {
+    float2 position : TEXCOORD0;
+    float2 uv       : TEXCOORD1;
+    float4 color    : TEXCOORD2;
+};
+
+struct TextOut {
+    float4 position : SV_Position;
+    float2 uv       : TEXCOORD1;
+    float4 color    : TEXCOORD2;
+};
+
+Texture2D    atlas : register(t0);
+SamplerState samp  : register(s0);
+
+TextOut vs_text(TextIn input) {
+    TextOut output;
+    float2 ndc = float2(input.position.x / viewport.x * 2.0 - 1.0,
+                        1.0 - input.position.y / viewport.y * 2.0);
+    output.position = float4(ndc, 0.0, 1.0);
+    output.uv = input.uv;
+    output.color = input.color;
+    return output;
+}
+
+float4 fs_text(TextOut input) : SV_Target {
+    float coverage = atlas.Sample(samp, input.uv).r;
+    return float4(input.color.rgb, input.color.a * coverage);
+}
+
+float4 fs_image(TextOut input) : SV_Target {
+    float4 c = atlas.Sample(samp, input.uv);
+    return float4(c.rgb * input.color.rgb, c.a * input.color.a);
+}

package/runtime/ext_gui/spirv/fill.frag

@@ -0,0 +1,19 @@
+#version 450
+
+/* xbintsc GUI engine — rounded-rectangle fill fragment shader (Vulkan/SPIR-V).
+ * The distance field mirrors the MSL/DXIL fill shaders. */
+
+layout(location = 0) in vec2 v_local;
+layout(location = 1) in vec2 v_halfsize;
+layout(location = 2) in float v_radius;
+layout(location = 3) in vec4 v_color;
+
+layout(location = 0) out vec4 out_color;
+
+void main() {
+    vec2 d = abs(v_local) - v_halfsize + v_radius;
+    float dist = min(max(d.x, d.y), 0.0) + length(max(d, 0.0)) - v_radius;
+    float aa = max(fwidth(dist), 0.0001);
+    float alpha = clamp(0.5 - dist / aa, 0.0, 1.0);
+    out_color = vec4(v_color.rgb, v_color.a * alpha);
+}

package/runtime/ext_gui/spirv/fill.vert

@@ -0,0 +1,42 @@
+#version 450
+
+/* xbintsc GUI engine — rounded-rectangle fill, Vulkan/SPIR-V path.
+ *
+ * The descriptor layout matches what SDL_GPU's Vulkan backend builds
+ * (`SDL_gpu_vulkan.c`, `CreateDescriptorSetLayout`): uniforms at
+ * `set=1, binding=0`, and (in the text/image shaders) samplers at
+ * `set=2, binding=0` with textures at `set=2, binding=1`.
+ *
+ * Vertex attributes (matching SDL_GPUVertexAttribute.location):
+ *   0 -> position (pixels, viewport-relative)
+ *   1 -> local    (pixels, relative to the rectangle centre)
+ *   2 -> halfsize (rectangle half extents, pixels)
+ *   3 -> radius   (pixels)
+ *   4 -> colour
+ * The push constant is the viewport size in logical pixels.
+ */
+
+layout(location = 0) in vec2 in_position;
+layout(location = 1) in vec2 in_local;
+layout(location = 2) in vec2 in_halfsize;
+layout(location = 3) in float in_radius;
+layout(location = 4) in vec4 in_color;
+
+layout(location = 0) out vec2 v_local;
+layout(location = 1) out vec2 v_halfsize;
+layout(location = 2) out float v_radius;
+layout(location = 3) out vec4 v_color;
+
+layout(set = 1, binding = 0) uniform Viewport {
+    vec2 size;
+} viewport;
+
+void main() {
+    vec2 ndc = vec2(in_position.x / viewport.size.x * 2.0 - 1.0,
+                    1.0 - in_position.y / viewport.size.y * 2.0);
+    gl_Position = vec4(ndc, 0.0, 1.0);
+    v_local = in_local;
+    v_halfsize = in_halfsize;
+    v_radius = in_radius;
+    v_color = in_color;
+}

package/runtime/ext_gui/spirv/image.frag

@@ -0,0 +1,16 @@
+#version 450
+
+/* xbintsc GUI engine — image quads (Vulkan/SPIR-V): sample an RGBA texture and
+ * modulate it by the vertex colour. */
+
+layout(location = 0) in vec2 v_uv;
+layout(location = 1) in vec4 v_color;
+
+layout(location = 0) out vec4 out_color;
+
+layout(set = 2, binding = 0) uniform sampler2D image;
+
+void main() {
+    vec4 c = texture(image, v_uv);
+    out_color = vec4(c.rgb * v_color.rgb, c.a * v_color.a);
+}

package/runtime/ext_gui/spirv/quad.vert

@@ -0,0 +1,30 @@
+#version 450
+
+/* xbintsc GUI engine — glyph and image quads, Vulkan/SPIR-V path.
+ *
+ * The vertex stage is shared by both: the fragment stage differs only in how it
+ * uses the sampled texture (`fs_text` reads the atlas' red channel, `fs_image`
+ * modulates an RGBA texture). Attributes:
+ *   0 -> position (pixels, viewport-relative)
+ *   1 -> uv (atlas coordinates in [0,1])
+ *   2 -> colour
+ */
+
+layout(location = 0) in vec2 in_position;
+layout(location = 1) in vec2 in_uv;
+layout(location = 2) in vec4 in_color;
+
+layout(location = 0) out vec2 v_uv;
+layout(location = 1) out vec4 v_color;
+
+layout(set = 1, binding = 0) uniform Viewport {
+    vec2 size;
+} viewport;
+
+void main() {
+    vec2 ndc = vec2(in_position.x / viewport.size.x * 2.0 - 1.0,
+                    1.0 - in_position.y / viewport.size.y * 2.0);
+    gl_Position = vec4(ndc, 0.0, 1.0);
+    v_uv = in_uv;
+    v_color = in_color;
+}

package/runtime/ext_gui/spirv/text.frag

@@ -0,0 +1,16 @@
+#version 450
+
+/* xbintsc GUI engine — glyph quads (Vulkan/SPIR-V): sample the single-channel
+ * atlas and modulate alpha by its coverage. */
+
+layout(location = 0) in vec2 v_uv;
+layout(location = 1) in vec4 v_color;
+
+layout(location = 0) out vec4 out_color;
+
+layout(set = 2, binding = 0) uniform sampler2D atlas;
+
+void main() {
+    float coverage = texture(atlas, v_uv).r;
+    out_color = vec4(v_color.rgb, v_color.a * coverage);
+}

package/runtime/ext_gui/window.cpp

@@ -434,6 +434,7 @@ static void define_getter(xt_value proto, const char *name, void *fn) {
 }
 
 xt_value xt_gui_window_proto(void) {
+  xt_gc_add_root(&g_window_proto);
   if (XT_IS_OBJECT(g_window_proto)) return g_window_proto;
   xt_value proto = xt_object_new();
   define_method(proto, "setTitle", (void *)win_set_title);

package/runtime/ext_node/buffer/parts/prototype.inc

@@ -2,6 +2,7 @@
 
 static xt_value xt_buffer_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_define_method(proto, "toString", (void *)xt_buffer_method_to_string);

package/runtime/ext_node/dgram/dgram.c

@@ -316,6 +316,7 @@ xt_value xt_dgram_static(xt_value name, int32_t argc, xt_value *argv) {
 
 static xt_value xt_dgram_socket_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);

package/runtime/ext_node/events/events.c

@@ -267,6 +267,7 @@ xt_value xt_events_static(xt_value name, int32_t argc, xt_value *argv) {
 
 static xt_value xt_events_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);

package/runtime/ext_node/fs/fs_ops.c

@@ -59,27 +59,18 @@ xt_value xt_node_dirent_result(const char *dir, const char *name) {
   return object;
 }
 
-typedef struct {
-  xt_value *items;
-  size_t count;
-  size_t capacity;
-} xt_fs_list;
-
-static void xt_fs_list_push(xt_fs_list *list, xt_value value) {
-  if (list->count == list->capacity) {
-    list->capacity = list->capacity ? list->capacity * 2 : 16;
-    xt_value *grown = (xt_value *)realloc(list->items, sizeof(xt_value) * list->capacity);
-    if (!grown) return;
-    list->items = grown;
-  }
-  list->items[list->count++] = value;
-}
+/* Entries accumulate in an `xt_array`, not a raw `xt_value` buffer: the
+ * collector cannot see a plain malloc'd buffer, so a `Dirent` created earlier
+ * in the walk would be swept as soon as a later entry allocates (which is
+ * exactly the GC-stress failure "object has no callable method
+ * 'isDirectory'"). The array lives on the caller's stack, so the conservative
+ * stack scan keeps it, and every entry it holds, reachable. */
 
 /* Depth-first walk used by `readdirSync(path, { recursive: true })`. `prefix`
    is the directory path relative to `base` (empty for the root, otherwise
    ending in `/`). */
 static void xt_fs_readdir_into(const char *base, const char *prefix, int withFileTypes, int recursive,
-                               xt_fs_list *list) {
+                               xt_value list) {
   size_t baseLength = strlen(base);
   size_t prefixLength = strlen(prefix);
   size_t dirSize = baseLength + prefixLength + 2;
@@ -104,7 +95,7 @@ static void xt_fs_readdir_into(const char *base, const char *prefix, int withFil
     char *relative = (char *)malloc(relSize);
     if (!relative) continue;
     snprintf(relative, relSize, "%s%s", prefix, name);
-    xt_fs_list_push(list, withFileTypes ? xt_node_dirent_result(dirPath, name) : xt_string_from_cstr(relative));
+    xt_array_push(list, withFileTypes ? xt_node_dirent_result(dirPath, name) : xt_string_from_cstr(relative));
 
     if (recursive) {
       size_t fullSize = dirLength + nameLength + 2;
@@ -141,14 +132,8 @@ xt_value xt_node_read_dir(int32_t argc, xt_value *argv) {
   int withFileTypes = XT_IS_OBJECT(options) && xt_truthy(xt_object_get_cstr(options, "withFileTypes"));
   int recursive = XT_IS_OBJECT(options) && xt_truthy(xt_object_get_cstr(options, "recursive"));
 
-  xt_fs_list list;
-  list.items = NULL;
-  list.count = 0;
-  list.capacity = 0;
-  xt_fs_readdir_into(path, "", withFileTypes, recursive, &list);
-
-  xt_value result = xt_array_new((int32_t)list.count, list.items);
-  free(list.items);
+  xt_value result = xt_array_new(0, NULL);
+  xt_fs_readdir_into(path, "", withFileTypes, recursive, result);
   return result;
 }
 

package/runtime/ext_node/fs/glob.c

@@ -10,21 +10,9 @@
 #include "../node_common.h"
 #include "fs_common.h"
 
-typedef struct {
-  xt_value *items;
-  size_t count;
-  size_t capacity;
-} xt_glob_list;
-
-static void xt_glob_push(xt_glob_list *list, xt_value value) {
-  if (list->count == list->capacity) {
-    list->capacity = list->capacity ? list->capacity * 2 : 16;
-    xt_value *grown = (xt_value *)realloc(list->items, sizeof(xt_value) * list->capacity);
-    if (!grown) return;
-    list->items = grown;
-  }
-  list->items[list->count++] = value;
-}
+/* Matches accumulate in an `xt_array` rather than a raw buffer so the garbage
+ * collector can see the `Dirent`/string entries created earlier in the walk;
+ * see the same note in `fs_ops.c`. */
 
 static char *xt_glob_join(const char *dir, const char *name) {
   size_t dirLength = strlen(dir);
@@ -96,11 +84,11 @@ static int xt_glob_is_dir(const char *path, int follow) {
 }
 
 static void xt_glob_walk(const char *dirPath, const char *pattern, const char *resultPrefix, int withFileTypes,
-                         xt_glob_list *list);
+                         xt_value list);
 
 /* Recurse one directory level for the `**` segment. */
 static void xt_glob_descend(const char *dirPath, const char *pattern, const char *resultPrefix, int withFileTypes,
-                            xt_glob_list *list) {
+                            xt_value list) {
   xt_fs_dir dir;
   if (!xt_fs_dir_open(&dir, dirPath)) return;
   while (xt_fs_dir_next(&dir)) {
@@ -123,7 +111,7 @@ static void xt_glob_descend(const char *dirPath, const char *pattern, const char
 }
 
 static void xt_glob_walk(const char *dirPath, const char *pattern, const char *resultPrefix, int withFileTypes,
-                         xt_glob_list *list) {
+                         xt_value list) {
   if (pattern[0] == '\0') {
     if (resultPrefix[0] != '\0') {
       size_t length = strlen(resultPrefix);
@@ -131,7 +119,7 @@ static void xt_glob_walk(const char *dirPath, const char *pattern, const char *r
       if (!trimmed) return;
       memcpy(trimmed, resultPrefix, length + 1);
       while (length > 1 && trimmed[length - 1] == '/') trimmed[--length] = '\0';
-      xt_glob_push(list, xt_string_from_cstr(trimmed));
+      xt_array_push(list, xt_string_from_cstr(trimmed));
       free(trimmed);
     }
     return;
@@ -165,13 +153,13 @@ static void xt_glob_walk(const char *dirPath, const char *pattern, const char *r
     char *child = xt_glob_join(dirPath, name);
     if (!child) continue;
     if (rest[0] == '\0') {
-      if (withFileTypes) xt_glob_push(list, xt_node_dirent_result(dirPath, name));
+      if (withFileTypes) xt_array_push(list, xt_node_dirent_result(dirPath, name));
       else {
         size_t size = strlen(resultPrefix) + strlen(name) + 1;
         char *result = (char *)malloc(size);
         if (result) {
           snprintf(result, size, "%s%s", resultPrefix, name);
-          xt_glob_push(list, xt_string_from_cstr(result));
+          xt_array_push(list, xt_string_from_cstr(result));
           free(result);
         }
       }
@@ -189,7 +177,7 @@ static void xt_glob_walk(const char *dirPath, const char *pattern, const char *r
   xt_fs_dir_close(&dir);
 }
 
-static void xt_glob_run(const char *pattern, const char *cwd, int withFileTypes, xt_glob_list *list) {
+static void xt_glob_run(const char *pattern, const char *cwd, int withFileTypes, xt_value list) {
   if (!pattern) return;
   const char *base = cwd && cwd[0] ? cwd : ".";
   const char *prefix = "";
@@ -209,24 +197,19 @@ xt_value xt_node_glob(int32_t argc, xt_value *argv) {
   xt_value cwdValue = XT_IS_OBJECT(options) ? xt_object_get_cstr(options, "cwd") : XT_UNDEFINED;
   if (XT_IS_STRING(cwdValue)) cwd = xt_string_data(cwdValue);
 
-  xt_glob_list list;
-  list.items = NULL;
-  list.count = 0;
-  list.capacity = 0;
+  xt_value result = xt_array_new(0, NULL);
 
   xt_value patternValue = argv[0];
   if (XT_IS_ARRAY(patternValue)) {
     int32_t count = (int32_t)xt_to_number(xt_array_length(patternValue));
     for (int32_t i = 0; i < count; i++) {
       xt_value item = xt_array_get(patternValue, xt_number((double)i));
-      if (XT_IS_STRING(item)) xt_glob_run(xt_string_data(item), cwd, withFileTypes, &list);
+      if (XT_IS_STRING(item)) xt_glob_run(xt_string_data(item), cwd, withFileTypes, result);
     }
   } else {
     const char *pattern = xt_node_cstr(patternValue);
-    xt_glob_run(pattern, cwd, withFileTypes, &list);
+    xt_glob_run(pattern, cwd, withFileTypes, result);
   }
 
-  xt_value result = xt_array_new((int32_t)list.count, list.items);
-  free(list.items);
   return result;
 }

package/runtime/ext_node/fs/promises.c

@@ -242,6 +242,7 @@ XT_FS_PROMISES_FACADE(xt_node_p_open, _)
 
 xt_value xt_fs_promises(void) {
   static xt_value cached = 0;
+  xt_gc_add_root(&cached);
   if (XT_IS_OBJECT(cached)) return cached;
   xt_value object = xt_object_new();
 #define XT_FS_PROMISE_METHOD(jsName, name)                                                         \

package/runtime/ext_node/http/parts/prototypes.inc

@@ -2,6 +2,7 @@
 
 static xt_value xt_http_server_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);
@@ -13,6 +14,7 @@ static xt_value xt_http_server_proto(void) {
 
 static xt_value xt_http_response_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);
@@ -28,6 +30,7 @@ static xt_value xt_http_response_proto(void) {
 
 static xt_value xt_http_request_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);
@@ -37,6 +40,7 @@ static xt_value xt_http_request_proto(void) {
 
 static xt_value xt_http_client_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);
@@ -49,6 +53,7 @@ static xt_value xt_http_client_proto(void) {
 
 static xt_value xt_http_client_response_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);

package/runtime/ext_node/net/parts/prototypes.inc

@@ -2,6 +2,7 @@
 
 static xt_value xt_net_socket_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);
@@ -22,6 +23,7 @@ static xt_value xt_net_socket_proto(void) {
 
 static xt_value xt_net_server_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);

package/runtime/ext_node/process/process.c

@@ -70,16 +70,18 @@ static xt_value xt_process_env(void) {
 
 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);
+  /* Fill an `xt_array` element by element rather than a raw `xt_value` buffer:
+     the collector cannot see a plain malloc'd buffer, so strings created here
+     would be swept as soon as a later element allocates (demonstrated by
+     `process.argv` returning recycled strings under GC stress). The array is a
+     stack local, so the conservative scan keeps it and its elements alive. */
+  xt_value result = xt_array_new(0, NULL);
+  if (count <= 0 || !xt_program_argv) return result;
   /* Node semantics: `[execPath, scriptPath, ...args]`. A standalone binary is
      both the executable and the script, so the executable path is repeated;
      user arguments therefore start at index 2, matching `node script.js a b`. */
-  xt_value *items = (xt_value *)malloc(sizeof(xt_value) * (size_t)(count + 1));
-  if (!items) return xt_array_new(0, NULL);
-  items[0] = xt_string_from_cstr(xt_program_argv[0]);
-  for (int32_t i = 0; i < count; i++) items[i + 1] = xt_string_from_cstr(xt_program_argv[i]);
-  xt_value result = xt_array_new(count + 1, items);
-  free(items);
+  xt_array_push(result, xt_string_from_cstr(xt_program_argv[0]));
+  for (int32_t i = 0; i < count; i++) xt_array_push(result, xt_string_from_cstr(xt_program_argv[i]));
   return result;
 }
 

package/runtime/ext_node/stream/stream.c

@@ -363,6 +363,7 @@ xt_value xt_stream_static(xt_value name, int32_t argc, xt_value *argv) {
 
 static xt_value xt_stream_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);

package/runtime/ext_node/util/util.c

@@ -363,13 +363,13 @@ static xt_value util_promisify_executor(xt_value thisValue, xt_value env, int32_
   xt_value resolve = xt_arg(argc, argv, 0);
   xt_value reject = xt_arg(argc, argv, 1);
   int32_t count = (int32_t)xt_to_number(xt_array_length(args));
-  xt_value *callArgs = (xt_value *)malloc(sizeof(xt_value) * (size_t)(count + 1));
-  if (!callArgs) return xt_undefined();
-  for (int32_t i = 0; i < count; i++) callArgs[i] = xt_array_get(args, xt_number((double)i));
+  /* An `xt_array` keeps the arguments, and the freshly created callback
+     closure, reachable if the call below triggers a collection. */
+  xt_value argArray = xt_array_new(0, NULL);
+  for (int32_t i = 0; i < count; i++) xt_array_push(argArray, xt_array_get(args, xt_number((double)i)));
   xt_value callbackEnv[2] = {resolve, reject};
-  callArgs[count] = xt_closure_new((void *)util_promisify_callback, 2, callbackEnv);
-  if (XT_IS_FUNCTION(fn)) xt_closure_call(fn, count + 1, callArgs);
-  free(callArgs);
+  xt_array_push(argArray, xt_closure_new((void *)util_promisify_callback, 2, callbackEnv));
+  if (XT_IS_FUNCTION(fn)) xt_closure_call(fn, count + 1, xt_as_array(argArray)->items);
   return xt_undefined();
 }
 

package/runtime/rt.h

@@ -362,6 +362,16 @@ void xt_println(xt_value v);
 size_t xt_heap_bytes(void);
 size_t xt_heap_allocations(void);
 
+/* -- garbage collector ---------------------------------------------------- */
+/**
+ * Register `slot` as a GC root: a static prototype cache or any value cell
+ * that lives outside the heap graph. The slot may be registered before it
+ * holds a value; it is marked on every collection and registration is
+ * idempotent. `xt_gc_add_root_range` registers `count` consecutive cells.
+ */
+void xt_gc_add_root(xt_value *slot);
+void xt_gc_add_root_range(xt_value *base, size_t count);
+
 #ifdef __cplusplus
 }
 #endif