@scriptc/runtime 0.0.25 → 0.0.26

package/src/scr_runtime.h

@@ -15,22 +15,18 @@
 #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
 
 /* ── process ──────────────────────────────────────────────────────────── */
@@ -241,16 +237,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,
@@ -1421,9 +1423,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
@@ -3548,6 +3551,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 +5138,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_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/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