@scriptc/runtime 0.0.25 → 0.0.27

package/src/scr_net.c

@@ -389,6 +389,16 @@ struct ScrNetServer {
   bool closing;       /* close() called; 'close' fires when conns drain */
   bool close_emitted; /* settled: off the registry, listeners dropped */
   bool emit_listening;
+  /* The writable http.Server timeout property values. Kept on the shared
+   * server handle because http/https servers retain that handle identity;
+   * plain net servers never expose these fields through the static type
+   * surface. Indices match lower-server.ts's selector ABI. */
+  double http_timeouts[5];
+  /* A dynamic write may store any JS value on these ordinary writable
+   * properties. Numeric writes stay in http_timeouts; every other value
+   * is retained here so dynamic reads preserve kind and identity. */
+  ScrDyn *http_timeout_dyn[5];
+  bool http_timeout_surface; /* true only for HTTP/1 and HTTPS servers */
   bool defer_conn; /* TLS: 'connection' fires post-handshake, not at accept */
   bool bound_v6;       /* the bound family (address()'s 'IPv6'/'IPv4' split) */
   ScrStr *bound_host;  /* the explicit bind host (NULL = the host-less any:
@@ -556,6 +566,7 @@ void scr_net_server_release(ScrNetServer *s) {
     scr_net_ls_drop(&s->close_ls);
     scr_net_ls_drop(&s->listening_cbs);
     scr_closure_release(s->close_override);
+    for (size_t i = 0; i < 5; i++) scr_dyn_release(s->http_timeout_dyn[i]);
     scr_str_release(s->bound_host);
     scr_str_release(s->pending_err);
     if (s->fd >= 0) scr_net_close_fd_raw(s->fd);
@@ -1200,6 +1211,11 @@ static ScrNetServer *scr_net_server_new(void) {
   s->kind = SCR_NET_K_SERVER;
   s->rc = 1;
   s->fd = -1;
+  s->http_timeouts[0] = 0;      /* timeout */
+  s->http_timeouts[1] = 5000;   /* keepAliveTimeout */
+  s->http_timeouts[2] = 60000;  /* headersTimeout */
+  s->http_timeouts[3] = 300000; /* requestTimeout */
+  s->http_timeouts[4] = 1000;   /* keepAliveTimeoutBuffer */
 #ifdef SCR_RC_AUDIT
   scr_net_live++;
 #endif
@@ -1378,6 +1394,79 @@ void scr_net_listen_opts(ScrNetServer *s, double port, ScrStr *host /*borrowed*/
 
 double scr_net_server_port(ScrNetServer *s) { return (double)s->port; }
 
+double scr_net_server_timeout_get(ScrNetServer *s, double field) {
+  static const char *const names[] = {
+    "timeout", "keepAliveTimeout", "headersTimeout", "requestTimeout",
+    "keepAliveTimeoutBuffer",
+  };
+  int i = (int)field;
+  if (i < 0 || i >= 5) abort(); /* compiler/runtime ABI violation */
+  if (s->http_timeout_dyn[i] != NULL) {
+    scr_dyn_arg_type_fail(names[i], "of type number", s->http_timeout_dyn[i]);
+    return 0; /* pending exception; typed reads validate an any-written value */
+  }
+  return s->http_timeouts[i];
+}
+
+void scr_net_server_timeout_set(ScrNetServer *s, double field, double value) {
+  int i = (int)field;
+  if (i < 0 || i >= 5) abort(); /* compiler/runtime ABI violation */
+  scr_dyn_release(s->http_timeout_dyn[i]);
+  s->http_timeout_dyn[i] = NULL;
+  s->http_timeouts[i] = value;
+}
+
+void scr_net_server_enable_http_timeout_surface(ScrNetServer *s) {
+  s->http_timeout_surface = true;
+}
+
+/* Constructor-option validation is intentionally separate from the plain
+ * writable-property setter above. Node validates these option values as
+ * non-negative safe integers, while later property assignments store the
+ * number directly. */
+bool scr_net_server_timeout_option_check(double field, double value) {
+  static const char *const names[] = {
+    "timeout", "keepAliveTimeout", "headersTimeout", "requestTimeout",
+    "keepAliveTimeoutBuffer",
+  };
+  int i = (int)field;
+  if (i < 0 || i >= 5) abort(); /* compiler/runtime ABI violation */
+  char recv[48], msg[224];
+  if (!(isfinite(value) && trunc(value) == value)) {
+    scr_num_received(value, recv);
+    int len = snprintf(msg, sizeof msg,
+                       "The value of \"%s\" is out of range. It must be an integer. Received %s",
+                       names[i], recv);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)len, "ERR_OUT_OF_RANGE");
+    return false;
+  }
+  if (value < 0 || value > 9007199254740991.0) {
+    scr_num_received(value, recv);
+    int len = snprintf(msg, sizeof msg,
+                       "The value of \"%s\" is out of range. It must be >= 0 && <= 9007199254740991. Received %s",
+                       names[i], recv);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)len, "ERR_OUT_OF_RANGE");
+    return false;
+  }
+  return true;
+}
+
+void scr_net_server_timeout_option_set(ScrNetServer *s, double field, const ScrDyn *value) {
+  int i = (int)field;
+  if (i < 0 || i >= 5) abort(); /* compiler/runtime ABI violation */
+  if (value->kind == SCR_DYN_UNDEF) return; /* optional field is absent */
+  if (value->kind != SCR_DYN_NUM) {
+    static const char *const names[] = {
+      "timeout", "keepAliveTimeout", "headersTimeout", "requestTimeout",
+      "keepAliveTimeoutBuffer",
+    };
+    scr_dyn_arg_type_fail(names[i], "of type number", value);
+    return;
+  }
+  if (!scr_net_server_timeout_option_check(field, value->v.num)) return;
+  scr_net_server_timeout_set(s, field, value->v.num);
+}
+
 /* address()'s other two fields — the bound host ('::'/'0.0.0.0' for the
  * host-less any, the normalized explicit host otherwise) and the family
  * string. Answer the any-form defaults before listen (Node answers null
@@ -3299,13 +3388,28 @@ static ScrDyn *scr_net_dynh_srv_invoke(void *h, ScrDyn *self, const char *method
   return NULL;
 }
 
+static int scr_net_dynh_srv_timeout_field(const char *key) {
+  if (strcmp(key, "timeout") == 0) return 0;
+  if (strcmp(key, "keepAliveTimeout") == 0) return 1;
+  if (strcmp(key, "headersTimeout") == 0) return 2;
+  if (strcmp(key, "requestTimeout") == 0) return 3;
+  if (strcmp(key, "keepAliveTimeoutBuffer") == 0) return 4;
+  return -1;
+}
+
 static ScrDyn *scr_net_dynh_srv_get(void *h, const char *key, size_t key_len) {
   ScrNetServer *s = (ScrNetServer *)h;
   (void)key_len;
   if (strcmp(key, "listening") == 0) return scr_dyn_new_bool(s->listening);
+  int timeout_field = scr_net_dynh_srv_timeout_field(key);
+  if (timeout_field >= 0 && s->http_timeout_surface) {
+    if (s->http_timeout_dyn[timeout_field] != NULL) {
+      return scr_dyn_retain(s->http_timeout_dyn[timeout_field]);
+    }
+    return scr_dyn_new_num(scr_net_server_timeout_get(s, (double)timeout_field));
+  }
   {
-    static const char *const known[] = { "maxConnections", "connections", "maxHeadersCount",
-      "timeout", "keepAliveTimeout", "headersTimeout", "requestTimeout", NULL };
+    static const char *const known[] = { "maxConnections", "connections", "maxHeadersCount", NULL };
     for (size_t i = 0; known[i]; i++) {
       if (strcmp(key, known[i]) == 0) {
         scr_net_dynh_srv_unsupported(key, NULL);
@@ -3317,7 +3421,18 @@ static ScrDyn *scr_net_dynh_srv_get(void *h, const char *key, size_t key_len) {
 }
 
 static bool scr_net_dynh_srv_set(void *h, const char *key, size_t key_len, const ScrDyn *value) {
-  (void)h; (void)key; (void)key_len; (void)value;
+  ScrNetServer *s = (ScrNetServer *)h;
+  (void)key_len;
+  int timeout_field = scr_net_dynh_srv_timeout_field(key);
+  if (timeout_field >= 0 && s->http_timeout_surface) {
+    if (value->kind == SCR_DYN_NUM) {
+      scr_net_server_timeout_set(s, (double)timeout_field, value->v.num);
+    } else {
+      scr_dyn_release(s->http_timeout_dyn[timeout_field]);
+      s->http_timeout_dyn[timeout_field] = scr_dyn_retain((ScrDyn *)value);
+    }
+    return true;
+  }
   return false;
 }
 

package/src/scr_object.c

@@ -33,7 +33,7 @@ void scr_record_key_miss(ScrStr *k) {
 }
 
 #ifdef SCR_RC_AUDIT
-static long scr_live_objects = 0;
+static SCR_TL long scr_live_objects = 0;
 long scr_obj_live_count(void) { return scr_live_objects; }
 void scr_obj_alloc_note(void) { scr_live_objects++; }
 void scr_obj_free_note(void) { scr_live_objects--; }

package/src/scr_regex.c

@@ -82,8 +82,8 @@ void *lre_realloc(void *opaque, void *ptr, size_t size) {
  * allocation audit sees the bytecode gone).
  */
 
-static ScrRegex **scr_compiled = NULL;
-static size_t scr_compiled_len = 0, scr_compiled_cap = 0;
+static SCR_TL ScrRegex **scr_compiled = NULL;
+static SCR_TL size_t scr_compiled_len = 0, scr_compiled_cap = 0;
 
 static void scr_regex_free_bytecodes(void) {
   for (size_t i = 0; i < scr_compiled_len; i++) {

package/src/scr_runtime.h

@@ -15,22 +15,36 @@
 #include <string.h>    /* memcpy in the inline slot accessors */
 #include <sys/types.h> /* ssize_t in the transport ops table */
 
-/* ── win32 libc shims (scr_win.c; see the windows portability inventory) ──
- * The POSIX/BSD functions the runtime calls that mingw-w64's CRT does not
- * provide: stpcpy (POSIX.1-2008; scr_number.c's digit writer), the
- * arc4random_buf CSPRNG (Math.random and node:crypto; RtlGenRandom
- * underneath), gmtime_r (scr_http.c's Date header; the CRT's gmtime is
- * already per-thread), and strcasestr (scr_http.c's token scan).
- * scr_win.c — compiled into win32-target builds only (cc.ts) —
- * implements all of them. Declared here so every TU that calls them
- * through scr_runtime.h compiles unchanged; POSIX hosts never see
- * these. */
+/* ── libc shims ─────────────────────────────────────────────────────────
+ * Win32's missing POSIX/BSD functions live in scr_win.c. Zig's musl sysroot
+ * additionally lacks arc4random_buf; scr_musl.c supplies it from Linux's
+ * getrandom syscall. Both files are selected by cc.ts only for their target. */
 #ifdef _WIN32
 #include <time.h> /* time_t / struct tm for the gmtime_r shim */
 char *stpcpy(char *dst, const char *src);
 void arc4random_buf(void *buf, size_t n);
 struct tm *gmtime_r(const time_t *t, struct tm *out);
 char *strcasestr(const char *hay, const char *needle);
+#elif defined(SCR_MUSL)
+void arc4random_buf(void *buf, size_t n);
+#endif
+
+/* ── thread-instanced library state ─────────────────────────────────────
+ * Archives built under the profile's abi.instance_per_thread compile every
+ * TU with -DSCR_THREAD_INSTANCES, and SCR_TL moves each unit's mutable
+ * state — and the emitted program's globals — into thread-local storage.
+ * A thread that calls the profile's init entry then owns a complete,
+ * independent instance: its own collector, result arena, panic-sink
+ * registration, poison flag, and program state. The instance's lifetime is
+ * the thread's; the one-thread-per-instance contract (an instance is never
+ * entered from two threads) is unchanged — this mode adds instances, not
+ * thread awareness. Expands to nothing everywhere else, so executable
+ * builds and classic library builds carry the exact bytes they always
+ * carried. Truly immutable tables (static const data) stay shared. */
+#if defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES)
+#define SCR_TL _Thread_local
+#else
+#define SCR_TL
 #endif
 
 /* ── process ──────────────────────────────────────────────────────────── */
@@ -241,16 +255,22 @@ typedef struct ScrCycHdr {
   size_t buf_index;  /* position there (O(1) removal when rc hits 0) */
 } ScrCycHdr;
 
-/* This layout is an ABI, not an implementation detail: the LLVM backend
- * inlines scr_cyc_mark_live as a raw `store i32 0` at obj-16 (it is a
- * static inline here, so there is no symbol to call) and reaches the header
- * at obj-32. Three sites emit it — llvm/shapes.ts, llvm/classes.ts,
- * llvm/emitter.ts. Nothing but `color` may share those four bytes: a field
- * placed in them is silently zeroed by every retain, which is invisible to
- * the type system and to the C compiler. Hence the assertions. */
-_Static_assert(sizeof(ScrCycHdr) == 32, "LLVM backend reads the header at obj-32");
+/* This layout is an ABI, not an implementation detail. The LLVM backend
+ * inlines scr_cyc_mark_live as a raw `store i32 0`: color is at obj-16 on
+ * 64-bit targets and obj-12 on wasm32. Three sites emit it —
+ * llvm/shapes.ts, llvm/classes.ts, and llvm/emitter.ts. Nothing but `color`
+ * may share those four bytes: a field placed in them is silently zeroed by
+ * every retain, which is invisible to the type system and to the C
+ * compiler. Hence the target-width assertions. */
+#if UINTPTR_MAX == UINT64_MAX
+_Static_assert(sizeof(ScrCycHdr) == 32, "LLVM backend expects a 32-byte cycle header");
 _Static_assert(offsetof(ScrCycHdr, color) == 16,
                "LLVM backend's inlined mark-live stores i32 0 at obj-16");
+#elif UINTPTR_MAX == UINT32_MAX
+_Static_assert(sizeof(ScrCycHdr) == 20, "LLVM backend expects a 20-byte cycle header");
+_Static_assert(offsetof(ScrCycHdr, color) == 8,
+               "LLVM backend's inlined mark-live stores i32 0 at obj-12");
+#endif
 _Static_assert(sizeof(((ScrCycHdr *)0)->color) == 4,
                "mark-live is an i32 store: color must own all four bytes");
 _Static_assert(SCR_CYC_BLACK == 0,
@@ -443,7 +463,7 @@ enum {
   SCR_ERR_DOMEX = 4, /* DOMException — ScrDomException, the wider layout */
 };
 
-extern ScrVt scr_error_vts[5]; /* indexed by SCR_ERR_*; main() stamps pre/post */
+extern SCR_TL ScrVt scr_error_vts[5]; /* indexed by SCR_ERR_*; main() stamps pre/post */
 
 struct ScrDyn; /* full declaration below (the checked-dynamic tree section) */
 
@@ -1371,8 +1391,8 @@ typedef struct ScrEmitter {
   const char *cls; /* display name for the leak warning ("EventEmitter") */
 } ScrEmitter;
 
-extern ScrVt scr_emitter_vt; /* main() stamps pre/post */
-extern double scr_emitter_default_max;
+extern SCR_TL ScrVt scr_emitter_vt; /* main() stamps pre/post */
+extern SCR_TL double scr_emitter_default_max;
 
 ScrEmitter *scr_emitter_new(void); /* +1, collector-headered */
 void scr_emitter_init(void *obj);  /* super() into the prefix (no-op today) */
@@ -1421,9 +1441,10 @@ ScrEmitter *scr_emitter_on_via(ScrEmitter *em, ScrStr *name, ScrClosure *orig /*
  * slots off the emit tuple and calls cb->fn behind the fixed signature
  * `void (ScrClosure *, void * ×k)` — the fixed-signature adapter the
  * backend provides. Such backends pass every user tuple argument
- * pointer-classed at the emit site (f64 as its i64 bit pattern, bool
- * zero-extended); the runtime's own emits (data/error/pipe/meta) carry
- * pointers only, so the shims read every tuple either lane produces.
+ * pointer-classed at the emit site: scalar values point at call-lived
+ * typed stack slots and reference values ride directly. The runtime's own
+ * emits (data/error/pipe/meta) carry pointers only, so the shims read every
+ * tuple either lane produces on 32- and 64-bit targets.
  * SCR_EE_FIXED_MAX is the registry's audited arity ceiling — backends
  * refuse listeners past it rather than guess. */
 #define SCR_EE_FIXED_MAX 4
@@ -1973,7 +1994,7 @@ bool scr_process_kill_named(double pid, const ScrStr *signal);
 void scr_process_exit(double code);
 /* process._exiting: true once the exit sequence began (process.exit or
  * the exit-listener runner set the flag). Never throws. */
-extern bool scr_process_in_exit;
+extern SCR_TL bool scr_process_in_exit;
 bool scr_process_exiting(void);
 /* umask(2): mask < 0 reads without setting; otherwise sets and answers
  * the previous mask. Never throws. */
@@ -3548,6 +3569,28 @@ void scr_promise_release_v(void *p);
 typedef struct ScrFiber ScrFiber;
 /* Spawn + run eagerly to the first suspension; returns the promise, +1. */
 ScrPromise *scr_async_spawn(void (*entry)(ScrFiber *, void *), void *argpack);
+/* Runtime-authored C waiters cannot themselves become LLVM switched
+ * coroutines on wasm32. Spawn after `dependency` settles so their first
+ * (and only) await is extraction from an already-settled promise, while
+ * retaining the ordinary promise-job hop on every target. +1. */
+ScrPromise *scr_async_spawn_after(ScrPromise *dependency,
+                                  void (*entry)(ScrFiber *, void *),
+                                  void *argpack);
+
+/* wasm32-wasi lowers async functions and generators through LLVM switched
+ * coroutines instead of the native stack-switching implementations. The
+ * first two adapters are emitted into the program module; the remaining
+ * helpers let scr_async.c register, queue, and finish those coroutine
+ * frames through the same ScrFiber scheduler. These declarations are part
+ * of the LLVM/runtime ABI even though native targets never call them. */
+void scr_wasi_coro_resume(void *handle);
+void scr_wasi_coro_destroy(void *handle);
+void scr_wasi_coro_started(void *handle);
+void scr_wasi_await_prepare(ScrFiber *self, ScrPromise *p);
+void scr_wasi_await_hop_prepare(ScrFiber *self);
+bool scr_wasi_module_await_prepare(ScrFiber *self, ScrPromise *p);
+void scr_wasi_async_finish(ScrFiber *self);
+void scr_wasi_gen_finish(ScrFiber *self);
 
 double scr_await_f64(ScrPromise *p); /* rejected promises re-throw */
 bool scr_await_bool(ScrPromise *p);
@@ -5113,6 +5156,20 @@ void scr_net_listen(ScrNetServer *s, double port, ScrClosure *cb /*moves, nullab
 void scr_net_listen_opts(ScrNetServer *s, double port, ScrStr *host /*borrowed*/,
                           bool ipv6_only, ScrClosure *cb /*moves, nullable*/);
 double scr_net_server_port(ScrNetServer *s); /* address().port */
+/* Writable http.Server timeout property storage. `field` is the compiler
+ * ABI selector: timeout, keepAliveTimeout, headersTimeout, requestTimeout,
+ * keepAliveTimeoutBuffer. Typed reads validate that no dynamic write left
+ * a non-number in the ordinary JS property slot. */
+double scr_net_server_timeout_get(ScrNetServer *s, double field);
+void scr_net_server_timeout_set(ScrNetServer *s, double field, double value);
+/* Marks the shared net-server handle as an HTTP/1 or HTTPS server. The
+ * dynamic handle uses this to keep HTTP-only fields off net/TLS/H2. */
+void scr_net_server_enable_http_timeout_surface(ScrNetServer *s);
+/* Constructor-option twin: undefined is absent; otherwise validates type
+ * and a non-negative safe integer before storing, matching Node's option
+ * ladder (plain property writes do not validate). */
+bool scr_net_server_timeout_option_check(double field, double value);
+void scr_net_server_timeout_option_set(ScrNetServer *s, double field, const struct ScrDyn *value);
 ScrStr *scr_net_server_addr_ip(ScrNetServer *s);     /* +1 — address().address */
 ScrStr *scr_net_server_addr_family(ScrNetServer *s); /* +1 — address().family */
 void scr_net_server_close(ScrNetServer *s, ScrClosure *cb /*moves, nullable*/);

package/src/scr_string.c

@@ -10,7 +10,7 @@
  * leaks nothing and frees nothing twice (double-free shows up as ASan
  * use-after-free on the rc field or a negative count here). */
 #ifdef SCR_RC_AUDIT
-static long scr_live_strings = 0;
+static SCR_TL long scr_live_strings = 0;
 long scr_str_live_count(void) { return scr_live_strings; }
 #endif
 
@@ -41,8 +41,8 @@ typedef struct {
   size_t u16len;   /* SCR_U16_UNKNOWN until computed */
   size_t cu, cb;   /* cursor: byte offset cb starts the char at unit cu */
 } ScrSidx;
-static ScrSidx scr_sidx_tab[SCR_SIDX_N];
-static unsigned scr_sidx_clock;
+static SCR_TL ScrSidx scr_sidx_tab[SCR_SIDX_N];
+static SCR_TL unsigned scr_sidx_clock;
 
 static void scr_sidx_purge(const ScrStr *s) {
   for (int i = 0; i < SCR_SIDX_N; i++) {
@@ -90,7 +90,7 @@ ScrStr *scr_str_new(const char *bytes, size_t len) {
  * blocks instead of paging in fresh zero-filled memory 40k times. Disabled
  * in the audit lane so ASan sees every logical free as a real free. */
 #ifndef SCR_RC_AUDIT
-static ScrStr *scr_str_spare;
+static SCR_TL ScrStr *scr_str_spare;
 #endif
 
 /* A spare-block reuse must not waste grossly (cap <= 4x the need) and only

package/src/scr_symbol.c

@@ -55,7 +55,7 @@ ScrSym *scr_sym_new(ScrStr *desc) {
 
 /* ── the Symbol.for global registry ──────────────────────────────────── */
 
-static ScrSym *g_sym_registry = NULL;
+static SCR_TL ScrSym *g_sym_registry = NULL;
 
 static void scr_sym_registry_cleanup(void) {
   ScrSym *s = g_sym_registry;

package/src/scr_tls.c

@@ -1415,6 +1415,27 @@ ScrNetServer *scr_tls_create_server_dyn(const ScrDyn *opts /*borrowed*/,
 ScrNetServer *scr_https_create_server_dyn(const ScrDyn *opts /*borrowed*/,
                                            ScrClosure *handler /*moves, nullable*/,
                                            ScrHttpReqFn fn) {
+  /* HTTPS ServerOptions extends http.ServerOptions. Consume the one HTTP
+   * constructor field this runtime models before the shared TLS walker;
+   * that walker deliberately owns only the TLS-side option surface. */
+  bool has_timeout_buffer = false;
+  double timeout_buffer = 0;
+  if (opts != NULL && opts->kind == SCR_DYN_OBJ) {
+    const ScrDyn *v = scr_dyn_obj_get(opts, "keepAliveTimeoutBuffer", 22);
+    if (v != NULL && v->kind != SCR_DYN_UNDEF) {
+      if (v->kind != SCR_DYN_NUM) {
+        scr_dyn_arg_type_fail("keepAliveTimeoutBuffer", "of type number", v);
+        scr_closure_release(handler);
+        return NULL;
+      }
+      timeout_buffer = v->v.num;
+      if (!scr_net_server_timeout_option_check(4, timeout_buffer)) {
+        scr_closure_release(handler);
+        return NULL;
+      }
+      has_timeout_buffer = true;
+    }
+  }
   ScrBytes *cert, *key;
   if (!scr_tls_srv_opts_walk(opts, "https.createServer", &cert, &key)) {
     scr_closure_release(handler);
@@ -1422,6 +1443,7 @@ ScrNetServer *scr_https_create_server_dyn(const ScrDyn *opts /*borrowed*/,
   }
   ScrNetServer *s = scr_https_create_server((const char *)cert->data, cert->len,
                                              (const char *)key->data, key->len, handler, fn);
+  if (has_timeout_buffer) scr_net_server_timeout_set(s, 4, timeout_buffer);
   scr_bytes_release(cert);
   scr_bytes_release(key);
   return s;

package/src/scr_union.c

@@ -15,7 +15,7 @@
 /* Live union count for the RC audit lane (-DSCR_RC_AUDIT); same contract
  * as scr_str_live_count in scr_string.c. */
 #ifdef SCR_RC_AUDIT
-static long scr_live_unions = 0;
+static SCR_TL long scr_live_unions = 0;
 long scr_union_live_count(void) { return scr_live_unions; }
 #endif
 

package/vendor/README.md

@@ -1,5 +1,13 @@
 # Vendored third-party code
 
+## libucontext (derived source)
+
+- Project: https://github.com/kaniini/libucontext
+- Commit: 49e671dd52ff6791295d8161ad3b6da7dc5f6f9d
+- License: ISC (copyright and permission notice reproduced in `src/scr_musl.c`)
+
+The x86_64 register-save/restore and `makecontext` logic is adapted into `src/scr_musl.c`, rather than carried as a separate library, to supply the legacy `ucontext` functions that musl declares but does not implement. It is compiled only for the explicit `x86_64-linux-musl` target and uses musl's public `ucontext_t` layout. The signal-mask compatibility wrapper is deliberately not included: scriptc fibers perform user-space register swaps and do not change a per-fiber signal mask.
+
 ## ryu/
 
 - Project: https://github.com/ulfjack/ryu