@scriptc/runtime 0.0.25 → 0.0.27

package/src/scr_events.c

@@ -30,6 +30,9 @@
 #include <io.h>
 #include <unistd.h> /* mingw-w64 ships one: read */
 #include <windows.h>
+#elif defined(__wasi__)
+#include <poll.h>
+#include <unistd.h>
 #else
 #include <poll.h>
 #include <unistd.h>
@@ -40,6 +43,21 @@ static void scr_events_oom(void) {
   abort();
 }
 
+#ifdef __wasi__
+/* The native child unit normally owns these generic Error-listener adapters.
+ * WASI cannot spawn children and therefore does not link that unit, while
+ * stdin's error event intentionally shares the same adapter ABI. */
+void scr_child_err_thunk0(ScrClosure *cb, ScrStr *msg) {
+  (void)msg;
+  ((void (*)(ScrClosure *))cb->fn)(cb);
+}
+
+void scr_child_err_thunk_error(ScrClosure *cb, ScrStr *msg) {
+  ScrError *error = scr_error_new(0 /* Error */, msg);
+  ((void (*)(ScrClosure *, ScrError *))cb->fn)(cb, error);
+}
+#endif
+
 /* ── process signal events (process.on("SIGINT" | "SIGTERM")) ─────────
  * Classic self-pipe integration: a watched signal's sigaction handler
  * (installed WITHOUT SA_RESTART) sets a per-signal flag and writes one
@@ -62,7 +80,7 @@ typedef struct {
 
 typedef struct ScrSigReg {
   int sig;
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__wasi__)
   void (*prev)(int); /* restored when the last listener leaves */
 #else
   struct sigaction prev; /* restored when the last listener leaves */
@@ -116,7 +134,7 @@ static void scr_sig_cleanup(void) {
 }
 
 static void scr_wake_pipe_init(void) {
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__wasi__)
   /* No self-pipe: the win32 loop never polls fds (scr_async.c's capped
    * nanosleep takes the idle sleep), so the handler's flag is the whole
    * wake path and the fds stay -1 — every pipe use below is guarded. */
@@ -141,6 +159,15 @@ static void scr_wake_pipe_drain(void) {
 }
 
 void scr_signal_on(double signum, ScrClosure *cb /*moves*/, bool once) {
+#ifdef __wasi__
+  (void)signum;
+  (void)once;
+  scr_closure_release(cb);
+  /* The compiler rejects this capability before linking. This guard keeps
+   * the optional events unit honest if hand-authored IR reaches it. */
+  scr_trap("scriptc: internal error: OS signal surface reached on WASI\n");
+  return;
+#else
   int sig = (int)signum;
   if (sig <= 0 || sig >= SCR_SIG_MAX) {
     scr_closure_release(cb); /* frontend only emits classic signals */
@@ -176,11 +203,15 @@ void scr_signal_on(double signum, ScrClosure *cb /*moves*/, bool once) {
   reg->ls[reg->n].cb = cb;
   reg->ls[reg->n].once = once;
   reg->n++;
+#endif
 }
 
 static void scr_sig_reg_drop(ScrSigReg *reg) {
 #ifdef _WIN32
   signal(reg->sig, reg->prev); /* default disposition back */
+#elif defined(__wasi__)
+  /* No signal disposition exists in WASI Preview 1. The compiler refuses
+   * signal registrations, so this arm is only the cleanup safety net. */
 #else
   sigaction(reg->sig, &reg->prev, NULL); /* default disposition back */
 #endif
@@ -193,6 +224,12 @@ static void scr_sig_reg_drop(ScrSigReg *reg) {
 }
 
 void scr_signal_off(double signum, ScrClosure *cb /*borrowed*/) {
+#ifdef __wasi__
+  (void)signum;
+  (void)cb;
+  scr_trap("scriptc: internal error: OS signal surface reached on WASI\n");
+  return;
+#else
   int sig = (int)signum;
   ScrSigReg *reg = scr_sig_regs;
   while (reg && reg->sig != sig) reg = reg->next;
@@ -206,6 +243,7 @@ void scr_signal_off(double signum, ScrClosure *cb /*borrowed*/) {
       return;
     }
   }
+#endif
 }
 
 /* One dispatch pass: every flagged signal fires its listener SNAPSHOT
@@ -486,6 +524,10 @@ static void scr_stdin_service(void) {
       if (WaitForSingleObject(h, 0) != WAIT_OBJECT_0) return;
     }
   }
+#elif defined(__wasi__)
+  /* install() puts fd 0 in nonblocking mode, so a direct read is both the
+   * readiness probe and the operation. This also observes a closed pipe on
+   * WASI hosts whose poll_oneoff adapter does not report POLLHUP. */
 #else
   struct pollfd pfd = {0 /* stdin */, POLLIN, 0};
   int rc = poll(&pfd, 1, 0);
@@ -705,6 +747,10 @@ void scr_events_install(void) {
   static bool installed = false;
   if (installed) return;
   installed = true;
+#ifdef __wasi__
+  int stdin_flags = fcntl(0, F_GETFL, 0);
+  if (stdin_flags >= 0) (void)fcntl(0, F_SETFL, stdin_flags | O_NONBLOCK);
+#endif
   atexit(scr_events_cleanup_atexit);
   atexit(scr_exit_atexit);
   scr_loop_set_events(&scr_events_pending, &scr_events_watching, &scr_events_dispatch,

package/src/scr_events_emitter.c

@@ -97,11 +97,11 @@ struct ScrEeReg {
  * stamps pre/post from the program's preorder numbering (the
  * scr_error_vts precedent). release is the direct teardown below. */
 static void scr_emitter_release_direct(void *obj);
-ScrVt scr_emitter_vt = {0, 0, &scr_emitter_release_direct};
+SCR_TL ScrVt scr_emitter_vt = {0, 0, &scr_emitter_release_direct};
 
-double scr_emitter_default_max = 10; /* EventEmitter.defaultMaxListeners */
+SCR_TL double scr_emitter_default_max = 10; /* EventEmitter.defaultMaxListeners */
 
-static bool scr_ee_trace_hint_shown = false;
+static SCR_TL bool scr_ee_trace_hint_shown = false;
 
 /* Post-registration hook (scr_runtime.h): the stream unit's flow kick.
  * NULL in stream-free builds — behavior byte-identical. */
@@ -390,10 +390,10 @@ ScrEmitter *scr_emitter_on_via(ScrEmitter *em, ScrStr *name, ScrClosure *orig /*
 
 /* ── fixed-arity invoke shims (scr_runtime.h's contract) ──────────────
  * Read k pointer-size slots and call the fixed-signature adapter behind
- * cb->fn. The LLVM lane's emit sites pass every tuple argument pointer-
- * classed (f64 as its i64 bit pattern, bool zero-extended) and the
- * runtime's own emits are pointer-only, so va_arg(ap, void *) reads every
- * tuple a fixed-registered listener can observe. */
+ * cb->fn. The LLVM lane's emit sites pass scalars by pointer to typed stack
+ * slots and references directly; the runtime's own emits are pointer-only,
+ * so va_arg(ap, void *) reads every tuple a fixed-registered listener can
+ * observe on 32- and 64-bit targets. */
 void scr_ee_inv_fixed0(ScrClosure *cb, va_list ap) {
   (void)ap;
   ((void (*)(ScrClosure *))cb->fn)(cb);

package/src/scr_exception.c

@@ -35,28 +35,38 @@ _Noreturn void scr_trap_fmt(const char *fmt, ...) {
 }
 #endif /* !SCR_LIB */
 
-static ScrExcCell scr_main_exc; /* fiber zero (the main stack) */
+static SCR_TL ScrExcCell scr_main_exc; /* fiber zero (the main stack) */
+#if defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES)
+/* A thread-local pointer cannot be initialized with &scr_main_exc — the
+ * address of a thread-local is not a constant expression — so NULL stands
+ * for the main cell and every read resolves it. Fibers never exist in
+ * library artifacts, so the cell only ever IS the main cell here. */
+static SCR_TL ScrExcCell *scr_cur;
+#define SCR_EXC_CUR() (scr_cur ? scr_cur : &scr_main_exc)
+#else
 static ScrExcCell *scr_cur = &scr_main_exc;
+#define SCR_EXC_CUR() (scr_cur)
+#endif
 
 /* Fiber switching (scr_async.c) points the exception machinery at the
  * incoming fiber's cell; returns the previous cell. */
 ScrExcCell *scr_exc_swap_cell(ScrExcCell *cell) {
-  ScrExcCell *prev = scr_cur;
+  ScrExcCell *prev = SCR_EXC_CUR();
   scr_cur = cell ? cell : &scr_main_exc;
   return prev;
 }
 
 /* The ACTIVE cell, for runtime code that moves a pending payload out of it
  * (a new-Promise executor throw rejecting the promise). */
-ScrExcCell *scr_exc_current_cell(void) { return scr_cur; }
+ScrExcCell *scr_exc_current_cell(void) { return SCR_EXC_CUR(); }
 
-#define scr_exc_kind (scr_cur->kind)
-#define scr_exc_f64 (scr_cur->f64)
-#define scr_exc_bool (scr_cur->b)
-#define scr_exc_payload (scr_cur->payload)
-#define scr_exc_retain_fn (scr_cur->retain_fn)
-#define scr_exc_release_fn (scr_cur->release_fn)
-#define scr_exc_trace_fn (scr_cur->trace_fn)
+#define scr_exc_kind (SCR_EXC_CUR()->kind)
+#define scr_exc_f64 (SCR_EXC_CUR()->f64)
+#define scr_exc_bool (SCR_EXC_CUR()->b)
+#define scr_exc_payload (SCR_EXC_CUR()->payload)
+#define scr_exc_retain_fn (SCR_EXC_CUR()->retain_fn)
+#define scr_exc_release_fn (SCR_EXC_CUR()->release_fn)
+#define scr_exc_trace_fn (SCR_EXC_CUR()->trace_fn)
 
 bool scr_exc_pending(void) { return scr_exc_kind != SCR_EXC_NONE; }
 
@@ -187,7 +197,7 @@ ScrStr *scr_caught_to_string(const ScrCaught *c) {
  * delivery; only the 0x01-led verbatim path below bypasses assembly. */
 void scr_library_check_exc(void) {
   if (!scr_exc_pending()) return;
-  static char buf[1024]; /* the message is copied out before the payload dies */
+  static SCR_TL char buf[1024]; /* the message is copied out before the payload dies */
   /* The ratified verbatim rule: a thrown message that ALREADY begins with
    * the structured trap-teaching marker (0x01) is delivered exactly as
    * authored — no "Uncaught " prefix, no added newline — which is how a
@@ -301,7 +311,7 @@ void scr_throw_obj(void *v, void *(*retain)(void *), void (*release)(void *),
  * events unit's atexit, when linked) must see that code, like Node's.
  * Lives HERE so the unit is self-contained (the reporters below and in
  * scr_async.c both note it; scr_events.c reads it). */
-static int scr_exit_code_hint = 0;
+static SCR_TL int scr_exit_code_hint = 0;
 void scr_exit_code_note(int code) { scr_exit_code_hint = code; }
 int scr_exit_code_hint_get(void) { return scr_exit_code_hint; }
 

package/src/scr_http.c

@@ -2009,6 +2009,7 @@ void scr_http2_stream_undef_call(ScrStr *member) {
 ScrNetServer *scr_http_create_server(ScrClosure *handler /*moves, nullable*/, ScrHttpReqFn fn) {
   scr_http_install();
   ScrNetServer *s = scr_net_create_server(NULL, NULL);
+  scr_net_server_enable_http_timeout_surface(s);
   ScrHttpSrvCtx *ctx = calloc(1, sizeof *ctx);
   if (!ctx) scr_http_oom();
   ctx->proto = SCR_NET_PROTO_HTTP1;

package/src/scr_inspect.c

@@ -237,11 +237,11 @@ typedef struct {
   bool all_num; /* every entry so far flagged numeric (grouping order) */
 } InspFrame;
 
-static InspFrame *g_frames;
-static size_t g_nframes;
-static size_t g_frames_cap;
-static size_t g_indent;       /* ctx.indentationLvl */
-static double g_cur_depth;    /* ctx.currentDepth (last-entered composite) */
+static SCR_TL InspFrame *g_frames;
+static SCR_TL size_t g_nframes;
+static SCR_TL size_t g_frames_cap;
+static SCR_TL size_t g_indent;       /* ctx.indentationLvl */
+static SCR_TL double g_cur_depth;    /* ctx.currentDepth (last-entered composite) */
 
 static InspFrame *insp_top(void) { return &g_frames[g_nframes - 1]; }
 
@@ -297,12 +297,12 @@ typedef struct {
   int id; /* circular id (0 while only on the stack) */
 } InspSeenEnt;
 
-static InspSeenEnt *g_seen;
-static size_t g_nseen;
-static size_t g_seen_cap;
+static SCR_TL InspSeenEnt *g_seen;
+static SCR_TL size_t g_nseen;
+static SCR_TL size_t g_seen_cap;
 /* Detection-numbered circular targets (persist across the call). */
-static const void *g_circ[64];
-static int g_ncirc;
+static SCR_TL const void *g_circ[64];
+static SCR_TL int g_ncirc;
 
 static void insp_circ_reset(void) {
   g_nseen = 0;

package/src/scr_island.c

@@ -118,7 +118,7 @@ static void *isl_realloc_fn(void *opaque, void *ptr, size_t size) {
   if (!ptr && p) isl_live_allocs++;
   return p;
 }
-static size_t isl_usable_size(const void *ptr) { return isl_malloc_size(ptr); }
+static size_t isl_usable_size(const void *ptr) { return isl_malloc_size((void *)ptr); }
 
 static const JSMallocFunctions isl_mf = {
     isl_calloc, isl_malloc, isl_free, isl_realloc_fn, isl_usable_size,
@@ -2107,7 +2107,7 @@ ScrJsval *scr_jsval_from_promise(ScrPromise *p, int payload) {
   w->payload = payload;
   w->next = isl_prom_wraps;
   isl_prom_wraps = w;
-  ScrPromise *waiter = scr_async_spawn(isl_prom_wrap_entry, w);
+  ScrPromise *waiter = scr_async_spawn_after(w->p, isl_prom_wrap_entry, w);
   scr_promise_release(waiter); /* the waiter never rejects; nobody awaits it */
   return isl_cell_new(prom);
 }
@@ -3352,7 +3352,7 @@ static JSValue isl_host_ids(JSContext *ctx, JSValueConst this_val, int argc,
   (void)argc;
   (void)argv;
   JSValue arr = JS_NewArray(ctx);
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__wasi__)
   JS_SetPropertyUint32(ctx, arr, 0, JS_NewInt32(ctx, -1));
   JS_SetPropertyUint32(ctx, arr, 1, JS_NewInt32(ctx, -1));
 #else
@@ -3370,7 +3370,7 @@ static JSValue isl_host_umask(JSContext *ctx, JSValueConst this_val, int argc,
   (void)this_val;
   (void)argc;
   (void)argv;
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__wasi__)
   return JS_NewInt32(ctx, 0);
 #else
   mode_t m = umask(0);
@@ -3495,11 +3495,15 @@ static JSValue isl_host_hostname(JSContext *ctx, JSValueConst this_val, int argc
    * counted like the socket units' own WSAStartup calls (ws2_32 is on
    * every win32 link line). */
   char buf[256];
+#if defined(__wasi__)
+  buf[0] = '\0';
+#else
 #ifdef _WIN32
   WSADATA wsa;
   if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) return JS_NewString(ctx, "");
 #endif
   if (gethostname(buf, sizeof buf) != 0) buf[0] = '\0';
+#endif
   buf[sizeof buf - 1] = '\0';
   return JS_NewString(ctx, buf);
 }

package/src/scr_json.c

@@ -31,7 +31,7 @@
 /* Live dyn-node 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_dyns = 0;
+static SCR_TL long scr_live_dyns = 0;
 long scr_dyn_live_count(void) { return scr_live_dyns; }
 #endif
 
@@ -49,7 +49,7 @@ static void scr_json_oom(void) {
 /* The ScrStr block behind a non-empty buffer. */
 #define SCR_JB_STR(b) ((ScrStr *)((char *)(b)->data - offsetof(ScrStr, data)))
 
-static size_t scr_jb_hint = 64;
+static SCR_TL size_t scr_jb_hint = 64;
 
 void scr_jb_init(ScrJsonBuf *b) {
   b->data = NULL;
@@ -280,9 +280,9 @@ void scr_jb_edge_idx(ScrJsonBuf *b, size_t i) {
  * (SEMANTICS.md documents the divergence). The emitted converters over
  * cycle-capable containers bracket their walks with enter/leave; the
  * stack is global (conversions never interleave). */
-static const void **g_td_seen;
-static size_t g_td_nseen;
-static size_t g_td_cap;
+static SCR_TL const void **g_td_seen;
+static SCR_TL size_t g_td_nseen;
+static SCR_TL size_t g_td_cap;
 
 void scr_dyn_from_enter(const void *v) {
   for (size_t i = 0; i < g_td_nseen; i++) {
@@ -315,8 +315,8 @@ void scr_dyn_from_leave(void) {
  * strict alloc/free balance.
  */
 #ifndef SCR_RC_AUDIT
-static ScrDyn *scr_dyn_free_arr, *scr_dyn_free_obj, *scr_dyn_free_misc;
-static size_t scr_dyn_free_count;
+static SCR_TL ScrDyn *scr_dyn_free_arr, *scr_dyn_free_obj, *scr_dyn_free_misc;
+static SCR_TL size_t scr_dyn_free_count;
 #define SCR_DYN_FREE_MAX 8192
 #endif
 
@@ -818,7 +818,7 @@ ScrBytes *scr_dyn_bytes_copy_out(const ScrDyn *d) {
  * Per-chunk utf8 decode: a multibyte character split across chunks does
  * not re-join (Node's StringDecoder holds the partial byte); ASCII-clean
  * bodies — the overwhelming test shape — are exact. */
-static bool scr_dyn_chunk_utf8;
+static SCR_TL bool scr_dyn_chunk_utf8;
 void scr_dyn_chunk_enc(bool utf8) { scr_dyn_chunk_utf8 = utf8; }
 
 /* One 'data' payload as the dyn value the current window dictates:
@@ -1122,7 +1122,7 @@ ScrDyn *scr_dyn_alloc_promise(void (*release_fn)(ScrPromise *p)) {
  * this allocator view and installs the engine-routing ops — the
  * scr_dyn_alloc_promise story: a dynamic-free link never references
  * engine symbols, and JSVAL nodes exist only after an install. */
-static const ScrDynJsvalOps *scr_dynjs_ops = NULL;
+static SCR_TL const ScrDynJsvalOps *scr_dynjs_ops = NULL;
 
 ScrDyn *scr_dyn_alloc_jsval(ScrJsval *cell, const ScrDynJsvalOps *ops) {
   scr_dynjs_ops = ops;
@@ -1256,8 +1256,8 @@ typedef struct {
   ScrDyn *dv;           /* dyn entry (+1); NULL for handle/undefined entries */
 } ScrDynThisEnt;
 
-static ScrDynThisEnt *scr_dyn_this_stack;
-static size_t scr_dyn_this_n, scr_dyn_this_cap;
+static SCR_TL ScrDynThisEnt *scr_dyn_this_stack;
+static SCR_TL size_t scr_dyn_this_n, scr_dyn_this_cap;
 
 static ScrDynThisEnt *scr_dyn_this_grow(void) {
   if (scr_dyn_this_n == scr_dyn_this_cap) {
@@ -1526,9 +1526,9 @@ typedef struct {
   ScrDyn *dyn;   /* retained */
 } ScrErrDynEnt;
 
-static ScrErrDynEnt *scr_errdyn_cache = NULL;
-static size_t scr_errdyn_n = 0, scr_errdyn_cap = 0;
-static bool scr_errdyn_teardown_registered = false;
+static SCR_TL ScrErrDynEnt *scr_errdyn_cache = NULL;
+static SCR_TL size_t scr_errdyn_n = 0, scr_errdyn_cap = 0;
+static SCR_TL bool scr_errdyn_teardown_registered = false;
 
 static void scr_errdyn_teardown(void) {
   for (size_t i = 0; i < scr_errdyn_n; i++) {