@scriptc/cli-darwin-x64 0.2.5 → 0.2.6

package/dist/lib/runtime-sources/src/scr_util_style.c

@@ -148,7 +148,7 @@ static ScrStr *util_style_replace(const ScrStr *text, const char *close,
 }
 
 static bool util_style_env_nonempty(const char *name) {
-  const char *value = getenv(name);
+  const char *value = scr_getenv(name);
   return value && *value;
 }
 
@@ -174,7 +174,7 @@ done:
 /* styleText only needs the color/no-color distinction, rather than the
  * full 4/8/24-bit depth. Follow the ordering of Node 24 internal/tty. */
 static bool util_style_terminal_colors(void) {
-  const char *force = getenv("FORCE_COLOR");
+  const char *force = scr_getenv("FORCE_COLOR");
   if (force) {
     bool enabled = !strcmp(force, "") || !strcmp(force, "true") ||
       !strcmp(force, "1") || !strcmp(force, "2") || !strcmp(force, "3");
@@ -192,21 +192,21 @@ static bool util_style_terminal_colors(void) {
     }
     return enabled;
   }
-  const char *term = getenv("TERM");
+  const char *term = scr_getenv("TERM");
   if (util_style_env_nonempty("NO_COLOR") || util_style_env_nonempty("NODE_DISABLE_COLORS") ||
       (term && !strcmp(term, "dumb"))) return false;
 #ifdef _WIN32
   return true;
 #endif
   if (util_style_env_nonempty("TMUX")) return true;
-  if (getenv("TF_BUILD") && getenv("AGENT_NAME")) return true;
-  if (getenv("CI")) {
+  if (scr_getenv("TF_BUILD") && scr_getenv("AGENT_NAME")) return true;
+  if (scr_getenv("CI")) {
     static const char *const ci[] = { "APPVEYOR", "BUILDKITE", "CIRCLECI", "DRONE", "GITEA_ACTIONS", "GITHUB_ACTIONS", "GITLAB_CI", "TRAVIS" };
-    for (size_t i = 0; i < sizeof ci / sizeof ci[0]; i++) if (getenv(ci[i])) return true;
-    const char *name = getenv("CI_NAME");
+    for (size_t i = 0; i < sizeof ci / sizeof ci[0]; i++) if (scr_getenv(ci[i])) return true;
+    const char *name = scr_getenv("CI_NAME");
     return name && !strcmp(name, "codeship");
   }
-  const char *teamcity = getenv("TEAMCITY_VERSION");
+  const char *teamcity = scr_getenv("TEAMCITY_VERSION");
   if (teamcity) {
     const char *p = teamcity;
     if (!strncmp(p, "9.", 2)) {
@@ -218,10 +218,10 @@ static bool util_style_terminal_colors(void) {
     while (*p >= '0' && *p <= '9') p++;
     return p - teamcity >= 2 && *p == '.';
   }
-  const char *program = getenv("TERM_PROGRAM");
+  const char *program = scr_getenv("TERM_PROGRAM");
   if (program && (!strcmp(program, "iTerm.app") || !strcmp(program, "HyperTerm") ||
                   !strcmp(program, "MacTerm") || !strcmp(program, "Apple_Terminal"))) return true;
-  const char *colorterm = getenv("COLORTERM");
+  const char *colorterm = scr_getenv("COLORTERM");
   if (colorterm && (!strcmp(colorterm, "truecolor") || !strcmp(colorterm, "24bit"))) return true;
   if (term) {
     if (strstr(term, "truecolor") || !strncmp(term, "xterm-256", 9)) return true;
@@ -294,7 +294,7 @@ ScrStr *scr_util_style_text(const ScrDyn *format, const ScrDyn *text, const ScrD
           scr_dyn_arg_type_fail("stream", "an instance of ReadableStream, WritableStream, or Stream", stream); goto done;
         }
       }
-      colorize = getenv("FORCE_COLOR") ? util_style_terminal_colors() :
+      colorize = scr_getenv("FORCE_COLOR") ? util_style_terminal_colors() :
         scr_process_is_tty(fd) && util_style_terminal_colors();
     }
   }

package/dist/lib/runtime-sources/src/scr_watch.c

@@ -121,11 +121,11 @@ struct ScrWatcher {
   struct ScrWatcher *next; /* the open-watcher registry (+1 each) */
 };
 
-static ScrWatcher *scr_watchers = NULL;
-static size_t scr_watchers_open = 0; /* liveness: open (unclosed) watchers */
+static SCR_TL ScrWatcher *scr_watchers = NULL;
+static SCR_TL size_t scr_watchers_open = 0; /* liveness: open (unclosed) watchers */
 
 #ifdef SCR_HAVE_KQUEUE
-static int scr_watch_kq = -1; /* created with the first watch; lives forever */
+static SCR_TL int scr_watch_kq = -1; /* created with the first watch; lives forever */
 
 /* Arms the vnode filter for a watcher's current fd. EV_CLEAR: state resets
  * at delivery, so an unserviced event never busy-spins the idle poll (the
@@ -145,7 +145,7 @@ static bool scr_watch_arm(ScrWatcher *w) {
 #endif
 
 #ifdef SCR_HAVE_INOTIFY
-static int scr_watch_ino = -1; /* created with the first watch; lives forever */
+static SCR_TL int scr_watch_ino = -1; /* created with the first watch */
 
 /* libuv's subscription mask: name-level events for directory watches,
  * self events for the file case, IN_IGNORED arriving for free. */
@@ -557,12 +557,22 @@ static void scr_watch_cleanup_atexit(void) {
     scr_watcher_drop_listeners(w);
     scr_watcher_release(w);
   }
+#ifdef SCR_WORKERS
+#ifdef SCR_HAVE_KQUEUE
+  if (scr_watch_kq >= 0) close(scr_watch_kq);
+  scr_watch_kq = -1;
+#endif
+#ifdef SCR_HAVE_INOTIFY
+  if (scr_watch_ino >= 0) close(scr_watch_ino);
+  scr_watch_ino = -1;
+#endif
+#endif
 }
 
 void scr_watch_install(void) {
-  static bool installed = false;
+  static SCR_TL bool installed = false;
   if (installed) return;
   installed = true;
-  atexit(scr_watch_cleanup_atexit);
+  scr_atexit(scr_watch_cleanup_atexit);
   scr_loop_set_watch(&scr_watch_pending, &scr_watch_dispatch, &scr_watch_pollfd);
 }

package/dist/lib/runtime-sources/src/scr_worker.c

@@ -0,0 +1,232 @@
+#include "scr_worker.h"
+
+#ifdef SCR_WORKERS
+#include <stdatomic.h>
+#include <stdlib.h>
+#include <limits.h>
+#ifdef _WIN32
+#include <process.h>
+#include <windows.h>
+#else
+#include <pthread.h>
+#endif
+
+struct ScrWorkerThread {
+  atomic_size_t references;
+  atomic_bool cancel;
+  atomic_bool port_closed;
+  uint64_t id;
+  uint32_t root;
+  ScrWorkerEntry entry;
+  ScrMailbox *inbox;
+  ScrMailbox *parent;
+  ScrMessage *data;
+  ScrContextEnv *environment;
+  int argc;
+  char **argv;
+  bool joined;
+#ifdef _WIN32
+  HANDLE thread;
+#else
+  pthread_t thread;
+#endif
+};
+
+static atomic_uint_fast64_t scr_worker_next_id = 1;
+static SCR_TL ScrWorkerThread *scr_worker_current;
+static SCR_TL ScrDyn *scr_worker_local_data;
+
+static ScrMailEvent *scr_worker_event(unsigned kind, uint64_t source,
+                                     int code, ScrMessage *message) {
+  ScrMailEvent *event = calloc(1, sizeof(*event));
+  if (!event) scr_trap("scriptc: out of memory\n");
+  *event = (ScrMailEvent){.kind = kind, .source = source, .code = code, .message = message};
+  return event;
+}
+
+ScrWorkerThread *scr_worker_thread_retain(ScrWorkerThread *worker) {
+  atomic_fetch_add_explicit(&worker->references, 1, memory_order_relaxed);
+  return worker;
+}
+
+void scr_worker_thread_release(ScrWorkerThread *worker) {
+  if (!worker || atomic_fetch_sub_explicit(&worker->references, 1, memory_order_acq_rel) != 1) return;
+#ifdef _WIN32
+  if (worker->thread) CloseHandle(worker->thread);
+#else
+  if (!worker->joined) (void)pthread_detach(worker->thread);
+#endif
+  scr_mailbox_release(worker->inbox);
+  scr_mailbox_release(worker->parent);
+  scr_message_free(worker->data);
+  scr_context_env_free(worker->environment);
+  for (int i = 0; i < worker->argc; i++) free(worker->argv[i]);
+  free(worker->argv);
+  free(worker);
+}
+
+static void scr_worker_data_cleanup(void) {
+  ScrDyn *data = scr_worker_local_data;
+  scr_worker_local_data = NULL;
+  scr_dyn_release(data);
+}
+
+ScrDyn *scr_worker_data(void) {
+  if (!scr_worker_current) return scr_dyn_new_null();
+  if (!scr_worker_local_data) {
+    ScrDyn *data = scr_message_decode(scr_worker_current->data);
+    if (!data) return NULL;
+    scr_worker_local_data = data;
+    if (scr_context_atexit(scr_worker_data_cleanup) != 0) scr_trap("scriptc: out of memory\n");
+    scr_message_free(scr_worker_current->data);
+    scr_worker_current->data = NULL;
+  }
+  return scr_dyn_retain(scr_worker_local_data);
+}
+
+ScrMailbox *scr_worker_inbox(void) {
+  return scr_worker_current ? scr_worker_current->inbox : NULL;
+}
+
+double scr_worker_root(void) { return scr_worker_current ? (double)scr_worker_current->root : -1; }
+int scr_worker_argc(void) { return scr_worker_current ? scr_worker_current->argc : 0; }
+char **scr_worker_argv(void) { return scr_worker_current ? scr_worker_current->argv : NULL; }
+
+uint64_t scr_worker_thread_id(const ScrWorkerThread *worker) { return worker->id; }
+
+void scr_worker_thread_terminate(ScrWorkerThread *worker) {
+  atomic_store_explicit(&worker->cancel, true, memory_order_relaxed);
+  scr_mailbox_post(worker->inbox, scr_worker_event(SCR_WORKER_WAKE, 0, 0, NULL));
+}
+
+bool scr_worker_thread_post(ScrWorkerThread *worker, ScrMessage *message) {
+  if (atomic_load_explicit(&worker->port_closed, memory_order_relaxed)) {
+    scr_message_free(message);
+    return false;
+  }
+  return scr_mailbox_post(worker->inbox, scr_worker_event(SCR_WORKER_MESSAGE, 0, 0, message));
+}
+
+void scr_worker_port_close(void) {
+  if (scr_worker_current)
+    atomic_store_explicit(&scr_worker_current->port_closed, true, memory_order_relaxed);
+}
+
+bool scr_worker_post_parent(ScrMessage *message) {
+  if (!scr_worker_current) { scr_message_free(message); return false; }
+  return scr_mailbox_post(scr_worker_current->parent,
+    scr_worker_event(SCR_WORKER_MESSAGE, scr_worker_current->id, 0, message));
+}
+
+static void scr_worker_report_error(void) {
+  ScrCaught *caught = scr_exc_take();
+  ScrDyn *value = scr_caught_to_dyn(caught);
+  ScrMessage *message = scr_message_encode(value);
+  scr_dyn_release(value);
+  scr_caught_release(caught);
+  if (!message) {
+    scr_exc_clear();
+    static const char text[] = "Serializing an uncaught exception failed";
+    scr_throw_error_msg_code(SCR_ERR_ERROR, text, sizeof text - 1, "ERR_WORKER_UNSERIALIZABLE_ERROR");
+    caught = scr_exc_take();
+    value = scr_caught_to_dyn(caught);
+    message = scr_message_encode(value);
+    scr_dyn_release(value);
+    scr_caught_release(caught);
+  }
+  scr_mailbox_post(scr_worker_current->parent,
+    scr_worker_event(SCR_WORKER_ERROR, scr_worker_current->id, 0, message));
+}
+
+static void scr_worker_thread_run(ScrWorkerThread *worker) {
+  scr_context_enter(worker->id);
+  scr_context_stop_flag(&worker->cancel);
+  scr_context_env_enter(worker->environment);
+  worker->environment = NULL;
+  scr_worker_current = worker;
+  scr_context_report_error = scr_worker_report_error;
+  scr_mailbox_post(worker->parent, scr_worker_event(SCR_WORKER_ONLINE, worker->id, 0, NULL));
+  int code = worker->entry(worker->root);
+  scr_mailbox_close(worker->inbox);
+  scr_context_cleanup();
+  scr_worker_current = NULL;
+  /* Cleanup may itself finish owner-bound native operations. Publish exit
+   * only once none of those operations can touch the worker's script heap. */
+  scr_mailbox_post(worker->parent, scr_worker_event(SCR_WORKER_EXIT, worker->id, code, NULL));
+  scr_worker_thread_release(worker);
+}
+
+#ifdef _WIN32
+static unsigned __stdcall scr_worker_thread_main(void *data) {
+  scr_worker_thread_run(data);
+  return 0;
+}
+#else
+static void *scr_worker_thread_main(void *data) {
+  scr_worker_thread_run(data);
+  return NULL;
+}
+#endif
+
+ScrWorkerThread *scr_worker_thread_start(ScrWorkerEntry entry, uint32_t root,
+                                        ScrMessage *data, ScrMailbox *parent,
+                                        ScrArr *arguments) {
+  ScrWorkerThread *worker = calloc(1, sizeof(*worker));
+  if (!worker) scr_trap("scriptc: out of memory\n");
+  atomic_init(&worker->references, 2); /* owner and native thread */
+  atomic_init(&worker->cancel, false);
+  atomic_init(&worker->port_closed, false);
+  worker->id = atomic_fetch_add_explicit(&scr_worker_next_id, 1, memory_order_relaxed);
+  worker->entry = entry;
+  worker->root = root;
+  worker->data = data;
+  worker->environment = scr_context_env_capture();
+  worker->parent = scr_mailbox_retain(parent);
+  if (arguments) {
+    if (arguments->len > INT_MAX) scr_trap("scriptc: too many worker arguments\n");
+    worker->argc = (int)arguments->len;
+    worker->argv = calloc(arguments->len + 1, sizeof(*worker->argv));
+    if (!worker->argv) scr_trap("scriptc: out of memory\n");
+    for (size_t i = 0; i < arguments->len; i++) {
+      ScrStr *text = scr_arr_get_ref(arguments, (double)i);
+      worker->argv[i] = malloc(text->len + 1);
+      if (!worker->argv[i]) scr_trap("scriptc: out of memory\n");
+      memcpy(worker->argv[i], text->data, text->len + 1);
+      scr_str_release(text);
+    }
+  }
+  worker->inbox = scr_mailbox_new();
+  if (!worker->inbox) goto failed;
+#ifdef _WIN32
+  worker->thread = (HANDLE)_beginthreadex(NULL, 0, scr_worker_thread_main, worker, 0, NULL);
+  if (!worker->thread) goto failed;
+#else
+  if (pthread_create(&worker->thread, NULL, scr_worker_thread_main, worker) != 0) goto failed;
+#endif
+  return worker;
+failed:
+  for (int i = 0; i < worker->argc; i++) free(worker->argv[i]);
+  free(worker->argv);
+  scr_context_env_free(worker->environment);
+  scr_mailbox_release(worker->inbox);
+  scr_mailbox_release(worker->parent);
+  scr_message_free(worker->data);
+  free(worker);
+  if (!scr_exc_pending()) {
+    static const char message[] = "Could not start worker thread";
+    scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "ERR_WORKER_INIT_FAILED");
+  }
+  return NULL;
+}
+
+void scr_worker_thread_join(ScrWorkerThread *worker) {
+  if (worker->joined) return;
+#ifdef _WIN32
+  if (WaitForSingleObject(worker->thread, INFINITE) != WAIT_OBJECT_0)
+    scr_trap("scriptc: worker join failed\n");
+#else
+  if (pthread_join(worker->thread, NULL) != 0) scr_trap("scriptc: worker join failed\n");
+#endif
+  worker->joined = true;
+}
+#endif

package/dist/lib/runtime-sources/src/scr_worker.h

@@ -0,0 +1,42 @@
+#ifndef SCR_WORKER_H
+#define SCR_WORKER_H
+
+#include "scr_mailbox.h"
+
+/* A thread carries only neutral transport state and an immutable compiled
+ * entry point. Script-visible handles and listeners stay in their owner's
+ * runtime heap. The entry initializes that thread's runtime before user code;
+ * the thread wrapper drains its context before publishing the exit event. */
+typedef struct ScrWorkerThread ScrWorkerThread;
+typedef int (*ScrWorkerEntry)(uint32_t root);
+
+enum {
+  SCR_WORKER_ONLINE = 1,
+  SCR_WORKER_MESSAGE,
+  SCR_WORKER_ERROR,
+  SCR_WORKER_EXIT,
+  SCR_WORKER_WAKE,
+  SCR_WORKER_STDOUT,
+  SCR_WORKER_STDERR,
+};
+
+/* Consumes data, including on failure. Borrows the parent's mailbox. */
+ScrWorkerThread *scr_worker_thread_start(ScrWorkerEntry entry, uint32_t root,
+                                        ScrMessage *data, ScrMailbox *parent,
+                                        ScrArr *arguments);
+ScrWorkerThread *scr_worker_thread_retain(ScrWorkerThread *worker);
+void scr_worker_thread_release(ScrWorkerThread *worker);
+/* Join is owner-only and idempotent. The caller holds a reference. */
+void scr_worker_thread_join(ScrWorkerThread *worker);
+void scr_worker_thread_terminate(ScrWorkerThread *worker);
+uint64_t scr_worker_thread_id(const ScrWorkerThread *worker);
+/* Posting consumes the message even after the destination has closed. */
+bool scr_worker_thread_post(ScrWorkerThread *worker, ScrMessage *message);
+bool scr_worker_post_parent(ScrMessage *message);
+void scr_worker_port_close(void);
+/* Current-thread access: inbox is borrowed, data is a retained local value. */
+ScrMailbox *scr_worker_inbox(void);
+void scr_loop_set_workers(bool (*pending)(void), bool (*ready)(void), void (*dispatch)(void),
+                          int (*pollfd)(void), void (*wait)(double));
+
+#endif

package/dist/lib/runtime-sources/src/scr_worker.test.c

@@ -0,0 +1,115 @@
+#undef NDEBUG
+#include "scr_worker.h"
+#include <assert.h>
+#include <sched.h>
+#include <stdatomic.h>
+#include <stdio.h>
+
+enum { WORKERS = 4, MESSAGES = 16 };
+static atomic_bool start;
+static SCR_TL unsigned timer_calls;
+static SCR_TL unsigned cleanup_calls;
+
+static void check_cleanup(void) { cleanup_calls++; }
+
+static void timer(ScrClosure *closure) {
+  (void)closure;
+  assert(!scr_context_is_main());
+  timer_calls++;
+}
+
+static int entry(uint32_t root_id) {
+  scr_init();
+  scr_lib_init(0, NULL);
+  assert(!scr_context_is_main());
+  assert(timer_calls == 0 && cleanup_calls == 0);
+  assert(scr_context_atexit(check_cleanup) == 0);
+  while (!atomic_load_explicit(&start, memory_order_acquire)) sched_yield();
+  ScrDyn *input = scr_worker_data();
+  assert(input && !scr_exc_pending());
+  assert(scr_dyn_obj_get(input, "root", 4)->v.num == root_id);
+  assert(scr_dyn_obj_get(input, "self", 4) == input);
+  ScrDyn *again = scr_worker_data();
+  assert(input == again);
+  scr_dyn_release(again);
+  scr_dyn_release(input);
+
+  for (unsigned i = 0; i < MESSAGES; i++) {
+    ScrDyn *value = scr_dyn_new_num(root_id * 100 + i);
+    ScrMessage *wire = scr_message_encode(value);
+    scr_dyn_release(value);
+    assert(wire && scr_worker_post_parent(wire));
+    ScrMailEvent *reply = NULL;
+    while (!(reply = scr_mailbox_take(scr_worker_inbox())))
+      scr_mailbox_wait(scr_worker_inbox(), 1000);
+    assert(reply->kind == SCR_WORKER_MESSAGE && reply->source == 0);
+    value = scr_message_decode(reply->message);
+    assert(value && value->kind == SCR_DYN_NUM && value->v.num == root_id * 100 + i);
+    scr_dyn_release(value);
+    scr_mail_event_free(reply);
+  }
+  scr_set_timeout(scr_closure_new((void *)timer, 0), 1);
+  assert(!scr_loop_run(NULL) && !scr_exc_pending());
+  assert(timer_calls == 1 && cleanup_calls == 0);
+  return (int)root_id;
+}
+
+int main(void) {
+  scr_init();
+  scr_lib_init(0, NULL);
+  ScrMailbox *mailbox = scr_mailbox_new();
+  assert(mailbox);
+  ScrWorkerThread *workers[WORKERS];
+  unsigned messages[WORKERS] = {0};
+  bool online[WORKERS] = {false};
+  bool exited[WORKERS] = {false};
+  for (unsigned i = 0; i < WORKERS; i++) {
+    ScrDyn *input = scr_dyn_new_obj();
+    scr_dyn_obj_set(input, "root", 4, scr_dyn_new_num(i));
+    scr_dyn_obj_set(input, "self", 4, scr_dyn_retain(input));
+    ScrMessage *wire = scr_message_encode(input);
+    scr_dyn_release(input);
+    assert(wire && !scr_exc_pending());
+    workers[i] = scr_worker_thread_start(entry, i, wire, mailbox, NULL);
+    assert(workers[i] && !scr_exc_pending());
+    assert(scr_worker_thread_id(workers[i]) != 0);
+  }
+  /* No sender heap survives into the workerData decode. */
+  scr_collect_cycles();
+  atomic_store_explicit(&start, true, memory_order_release);
+  unsigned exit_count = 0;
+  while (exit_count != WORKERS) {
+    ScrMailEvent *event = scr_mailbox_take(mailbox);
+    if (!event) { scr_mailbox_wait(mailbox, 1000); continue; }
+    unsigned i = 0;
+    while (i < WORKERS && scr_worker_thread_id(workers[i]) != event->source) i++;
+    assert(i < WORKERS && !exited[i]);
+    if (event->kind == SCR_WORKER_ONLINE) {
+      assert(!online[i]);
+      online[i] = true;
+    } else if (event->kind == SCR_WORKER_MESSAGE) {
+      assert(online[i] && messages[i] < MESSAGES);
+      ScrDyn *value = scr_message_decode(event->message);
+      assert(value && value->kind == SCR_DYN_NUM && value->v.num == i * 100 + messages[i]);
+      messages[i]++;
+      ScrMessage *reply = scr_message_encode(value);
+      scr_dyn_release(value);
+      assert(reply && scr_worker_thread_post(workers[i], reply));
+    } else {
+      assert(event->kind == SCR_WORKER_EXIT && event->code == (int)i);
+      assert(online[i] && messages[i] == MESSAGES);
+      exited[i] = true;
+      exit_count++;
+      scr_worker_thread_join(workers[i]);
+      scr_worker_thread_join(workers[i]);
+      ScrMessage *late = scr_message_encode(scr_dyn_undefined());
+      assert(late && !scr_worker_thread_post(workers[i], late));
+    }
+    scr_mail_event_free(event);
+  }
+  for (unsigned i = 0; i < WORKERS; i++) scr_worker_thread_release(workers[i]);
+  scr_mailbox_release(mailbox);
+  assert(timer_calls == 0 && cleanup_calls == 0 && scr_context_is_main());
+  scr_context_cleanup();
+  puts("worker threads isolate heaps, exchange messages and publish ordered exits");
+}

package/dist/lib/runtime-sources/src/scr_worker.test.ts

@@ -0,0 +1,49 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { expect, test } from "vitest";
+import { EXECUTABLE_RUNTIME_SOURCES } from "../../compiler/src/backend/native-toolchain.js";
+
+const exec = promisify(execFile);
+
+test.skipIf(process.platform === "win32")(
+  "native workers own their data and finish all message exchanges before exit",
+  async () => {
+    const dir = await mkdtemp(join(tmpdir(), "scriptc-workers-"));
+    try {
+      const bin = join(dir, "workers");
+      await exec("clang", [
+        "-std=c11",
+        "-O1",
+        "-pthread",
+        "-DSCR_WORKERS",
+        "-DSCR_RC_AUDIT",
+        "-fsanitize=address,undefined",
+        "-Wno-deprecated-declarations",
+        ...(process.platform === "linux" ? ["-D_GNU_SOURCE"] : []),
+        ...[
+          "scr_worker.test.c",
+          "scr_worker.c",
+          "scr_mailbox.c",
+          "scr_message.c",
+          ...EXECUTABLE_RUNTIME_SOURCES,
+        ].map((name) => join(import.meta.dirname, name)),
+        ...(process.platform === "linux" ? ["-lm"] : []),
+        "-o",
+        bin,
+      ]);
+      const result = await exec(bin, [], {
+        timeout: 10000,
+        env: { ...process.env, UBSAN_OPTIONS: "halt_on_error=1" },
+      });
+      expect(result.stdout).toBe(
+        "worker threads isolate heaps, exchange messages and publish ordered exits\n",
+      );
+      expect(result.stderr).toBe("");
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  },
+);