@scriptc/cli-darwin-x64 0.0.0 → 0.2.1

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

@@ -0,0 +1,231 @@
+/* win32 libc shims — the POSIX/BSD functions the runtime calls that
+ * mingw-w64's CRT does not provide (declared in scr_runtime.h's _WIN32
+ * block). Compiled into win32-target builds only (native-toolchain.ts adds this TU and
+ * -ladvapi32 for windows triples); an empty TU anywhere else, so POSIX
+ * builds cannot change by a byte. */
+#ifdef _WIN32
+
+#include "scr_runtime.h"
+
+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <windows.h>
+
+/* LLVM's MSVC-target objects reference this marker when they use floating
+ * point. MinGW supplies the arithmetic runtime but not the MSVC marker.
+ * Select-any allows an embedding application's CRT to provide it as well. */
+__declspec(selectany) int _fltused = 0x9875;
+
+#ifndef CREATE_WAITABLE_TIMER_HIGH_RESOLUTION
+#define CREATE_WAITABLE_TIMER_HIGH_RESOLUTION 0x00000002
+#endif
+
+#define SCR_WIN_FILETIME_UNIX_EPOCH UINT64_C(116444736000000000)
+#define SCR_WIN_TICKS_PER_SECOND UINT64_C(10000000)
+
+static int scr_win_error(DWORD error) {
+  switch (error) {
+    case ERROR_INVALID_PARAMETER:
+      errno = EINVAL;
+      break;
+    case ERROR_NOT_ENOUGH_MEMORY:
+    case ERROR_OUTOFMEMORY:
+      errno = ENOMEM;
+      break;
+    default:
+      errno = EIO;
+      break;
+  }
+  return -1;
+}
+
+static int scr_win_clock_gettime(clockid_t clock_id, int64_t *seconds,
+                                 long *nanoseconds) {
+  if (clock_id == CLOCK_REALTIME || clock_id == CLOCK_REALTIME_COARSE) {
+    FILETIME file_time;
+    ULARGE_INTEGER ticks;
+    GetSystemTimePreciseAsFileTime(&file_time);
+    ticks.LowPart = file_time.dwLowDateTime;
+    ticks.HighPart = file_time.dwHighDateTime;
+    if (ticks.QuadPart < SCR_WIN_FILETIME_UNIX_EPOCH) {
+      errno = EOVERFLOW;
+      return -1;
+    }
+    ticks.QuadPart -= SCR_WIN_FILETIME_UNIX_EPOCH;
+    *seconds = (int64_t)(ticks.QuadPart / SCR_WIN_TICKS_PER_SECOND);
+    *nanoseconds = (long)((ticks.QuadPart % SCR_WIN_TICKS_PER_SECOND) * 100);
+    return 0;
+  }
+  if (clock_id == CLOCK_MONOTONIC) {
+    LARGE_INTEGER counter;
+    LARGE_INTEGER frequency;
+    if (!QueryPerformanceFrequency(&frequency) || frequency.QuadPart <= 0 ||
+        !QueryPerformanceCounter(&counter) || counter.QuadPart < 0) {
+      return scr_win_error(GetLastError());
+    }
+    *seconds = counter.QuadPart / frequency.QuadPart;
+    *nanoseconds = (long)(((uint64_t)(counter.QuadPart % frequency.QuadPart) *
+                             UINT64_C(1000000000)) /
+                            (uint64_t)frequency.QuadPart);
+    return 0;
+  }
+  errno = EINVAL;
+  return -1;
+}
+
+static int scr_win_nanosleep(int64_t seconds, long nanoseconds,
+                             int64_t *remaining_seconds,
+                             long *remaining_nanoseconds) {
+  if (seconds < 0 || nanoseconds < 0 || nanoseconds >= 1000000000L) {
+    errno = EINVAL;
+    return -1;
+  }
+  uint64_t subsecond_ticks = ((uint64_t)nanoseconds + 99) / 100;
+  if ((uint64_t)seconds >
+      ((uint64_t)INT64_MAX - subsecond_ticks) / SCR_WIN_TICKS_PER_SECOND) {
+    errno = EINVAL;
+    return -1;
+  }
+  uint64_t ticks =
+      (uint64_t)seconds * SCR_WIN_TICKS_PER_SECOND + subsecond_ticks;
+  if (ticks == 0) {
+    Sleep(0);
+  } else {
+    HANDLE timer = CreateWaitableTimerExW(
+        NULL, NULL, CREATE_WAITABLE_TIMER_HIGH_RESOLUTION,
+        TIMER_MODIFY_STATE | SYNCHRONIZE);
+    if (timer == NULL) timer = CreateWaitableTimerW(NULL, FALSE, NULL);
+    if (timer == NULL) return scr_win_error(GetLastError());
+    LARGE_INTEGER due;
+    due.QuadPart = -(LONGLONG)ticks;
+    if (!SetWaitableTimer(timer, &due, 0, NULL, NULL, FALSE)) {
+      DWORD error = GetLastError();
+      CloseHandle(timer);
+      return scr_win_error(error);
+    }
+    DWORD wait = WaitForSingleObject(timer, INFINITE);
+    DWORD error = wait == WAIT_OBJECT_0 ? ERROR_SUCCESS : GetLastError();
+    CloseHandle(timer);
+    if (wait != WAIT_OBJECT_0) return scr_win_error(error);
+  }
+  if (remaining_seconds != NULL) *remaining_seconds = 0;
+  if (remaining_nanoseconds != NULL) *remaining_nanoseconds = 0;
+  return 0;
+}
+
+int clock_gettime32(clockid_t clock_id, struct _timespec32 *tp) {
+  int64_t seconds;
+  long nanoseconds;
+  if (scr_win_clock_gettime(clock_id, &seconds, &nanoseconds) != 0) return -1;
+  if (seconds < INT32_MIN || seconds > INT32_MAX) {
+    errno = EOVERFLOW;
+    return -1;
+  }
+  tp->tv_sec = (__time32_t)seconds;
+  tp->tv_nsec = nanoseconds;
+  return 0;
+}
+
+int clock_gettime64(clockid_t clock_id, struct _timespec64 *tp) {
+  int64_t seconds;
+  long nanoseconds;
+  if (scr_win_clock_gettime(clock_id, &seconds, &nanoseconds) != 0) return -1;
+  tp->tv_sec = (__time64_t)seconds;
+  tp->tv_nsec = nanoseconds;
+  return 0;
+}
+
+int nanosleep32(const struct _timespec32 *request, struct _timespec32 *remain) {
+  int64_t remaining_seconds;
+  long remaining_nanoseconds;
+  int result = scr_win_nanosleep(
+      request->tv_sec, request->tv_nsec,
+      remain == NULL ? NULL : &remaining_seconds,
+      remain == NULL ? NULL : &remaining_nanoseconds);
+  if (result == 0 && remain != NULL) {
+    remain->tv_sec = (__time32_t)remaining_seconds;
+    remain->tv_nsec = remaining_nanoseconds;
+  }
+  return result;
+}
+
+int nanosleep64(const struct _timespec64 *request, struct _timespec64 *remain) {
+  int64_t remaining_seconds;
+  long remaining_nanoseconds;
+  int result = scr_win_nanosleep(
+      request->tv_sec, request->tv_nsec,
+      remain == NULL ? NULL : &remaining_seconds,
+      remain == NULL ? NULL : &remaining_nanoseconds);
+  if (result == 0 && remain != NULL) {
+    remain->tv_sec = (__time64_t)remaining_seconds;
+    remain->tv_nsec = remaining_nanoseconds;
+  }
+  return result;
+}
+
+/* POSIX.1-2008 stpcpy: strcpy returning the END of the copy — scr_number.c
+ * (untouchable by project rule; ryu-adjacent) builds "e+"/"e-" exponent
+ * tails with it. */
+char *stpcpy(char *dst, const char *src) {
+  size_t n = strlen(src);
+  memcpy(dst, src, n + 1);
+  return dst + n;
+}
+
+/* arc4random_buf over RtlGenRandom (advapi32's SystemFunction036) — the
+ * kernel CSPRNG behind rand_s and BCryptGenRandom, available everywhere
+ * without a bcrypt link. Failure aborts: like the BSD/glibc original, the
+ * callers (Math.random, crypto.randomUUID/randomBytes) have no error arm
+ * and returning predictable bytes is never acceptable. */
+BOOLEAN NTAPI SystemFunction036(PVOID buffer, ULONG length);
+
+void arc4random_buf(void *buf, size_t n) {
+  unsigned char *p = buf;
+  while (n > 0) {
+    ULONG step = n > 0x7fffffffUL ? 0x7fffffffUL : (ULONG)n;
+    if (!SystemFunction036(p, step)) {
+      fputs("scriptc: RtlGenRandom failed\n", stderr);
+      abort();
+    }
+    p += step;
+    n -= step;
+  }
+}
+
+/* POSIX gmtime_r: the win32 CRT's gmtime already answers from per-thread
+ * storage, so the reentrant spelling is a copy-out (scr_http.c's Date
+ * header formatter is the caller). */
+struct tm *gmtime_r(const time_t *t, struct tm *out) {
+  struct tm *g = gmtime(t);
+  if (g == NULL) return NULL;
+  *out = *g;
+  return out;
+}
+
+/* GNU/BSD strcasestr — scr_http.c's Connection-token scan. Naive
+ * quadratic scan like the musl original; header values are tiny. */
+char *strcasestr(const char *hay, const char *needle) {
+  size_t n = strlen(needle);
+  if (n == 0) return (char *)hay;
+  for (; *hay != '\0'; hay++) {
+    size_t i = 0;
+    while (i < n && hay[i] != '\0' &&
+           tolower((unsigned char)hay[i]) == tolower((unsigned char)needle[i]))
+      i++;
+    if (i == n) return (char *)hay;
+  }
+  return NULL;
+}
+
+#else /* !_WIN32 */
+
+/* Empty TU off-Windows: native-toolchain.ts only compiles this file for windows triples,
+ * but an accidental link elsewhere must stay harmless. */
+typedef int scr_win_unused;
+
+#endif /* _WIN32 */

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

@@ -0,0 +1,23 @@
+#ifndef SCR_WIN_STATS_H
+#define SCR_WIN_STATS_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+/* IO_REPARSE_TAG_MOUNT_POINT covers both directory junctions and mounted
+ * volumes. Node/libuv only presents drive-letter junction targets as links;
+ * a volume target (\\??\\Volume{...}) is followed even by lstat(). Keep this
+ * predicate platform-neutral so its payload classification can be unit-tested
+ * without requiring a spare Windows volume. */
+static inline bool scr_win_stats_mount_target_is_junction(
+    const uint16_t *target, size_t len) {
+  return len >= 6 &&
+         target[0] == '\\' && target[1] == '?' && target[2] == '?' &&
+         target[3] == '\\' &&
+         ((target[4] >= 'A' && target[4] <= 'Z') ||
+          (target[4] >= 'a' && target[4] <= 'z')) &&
+         target[5] == ':' && (len == 6 || target[6] == '\\');
+}
+
+#endif /* SCR_WIN_STATS_H */

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

@@ -0,0 +1,358 @@
+/* node:zlib, the lowered slice: the one-shot zlib/raw-DEFLATE/gzip codecs
+ * over u8 bytes with Node's DEFAULT options. Compiled ONLY when the program
+ * uses zlib (native-toolchain.ts gates it exactly like scr_regex.c/libregexp),
+ * so zlib-free binaries keep their historical link line. Host builds link
+ * the system -lz; cross targets link the vendored zlib built per target
+ * (ensureZlibObjects in native-toolchain.ts).
+ *
+ * Compressed OUTPUT bytes are zlib-version-dependent — the differential
+ * corpus tests round-trips and fixed-blob inflation, never raw deflate
+ * output. deflate of valid input cannot fail (OOM aborts); inflate of
+ * corrupt input THROWS Node's catchable Error (zlib's own msg text:
+ * "incorrect header check", ...). */
+#include "scr_runtime.h"
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <zlib.h>
+
+static void scr_zlib_oom(void) {
+  scr_trap("scriptc: out of memory\n");
+}
+
+ScrBytes *scr_zlib_deflate(const ScrBytes *data) {
+  uLong srcLen = (uLong)data->len;
+  uLong cap = compressBound(srcLen);
+  uint8_t *buf = malloc(cap ? cap : 1);
+  if (!buf) scr_zlib_oom();
+  uLongf outLen = cap;
+  int rc = compress2(buf, &outLen, data->data, srcLen, Z_DEFAULT_COMPRESSION);
+  if (rc != Z_OK) scr_zlib_oom(); /* Z_MEM_ERROR is the only reachable code */
+  ScrBytes *out = scr_bytes_new(SCR_BYTES_U8, (double)outLen);
+  memcpy(out->data, buf, outLen);
+  free(buf);
+  return out;
+}
+
+ScrBytes *scr_zlib_inflate(const ScrBytes *data) {
+  z_stream zs;
+  memset(&zs, 0, sizeof zs);
+  if (inflateInit(&zs) != Z_OK) scr_zlib_oom();
+  size_t cap = data->len > 64 ? data->len * 4 : 256;
+  uint8_t *buf = malloc(cap);
+  if (!buf) scr_zlib_oom();
+  zs.next_in = data->data;
+  zs.avail_in = (uInt)data->len;
+  size_t len = 0;
+  for (;;) {
+    zs.next_out = buf + len;
+    zs.avail_out = (uInt)(cap - len);
+    int rc = inflate(&zs, Z_NO_FLUSH);
+    len = cap - zs.avail_out;
+    if (rc == Z_STREAM_END) break;
+    if (rc == Z_OK || rc == Z_BUF_ERROR) {
+      if (rc == Z_BUF_ERROR && zs.avail_in == 0 && zs.avail_out > 0) {
+        /* Truncated input: Node throws "unexpected end of file". */
+        inflateEnd(&zs);
+        free(buf);
+        static const char msg[] = "unexpected end of file";
+        scr_throw_error_msg(SCR_ERR_ERROR, msg, sizeof msg - 1);
+        return NULL;
+      }
+      if (cap - len < 64) {
+        cap *= 2;
+        uint8_t *grown = realloc(buf, cap);
+        if (!grown) scr_zlib_oom();
+        buf = grown;
+      }
+      continue;
+    }
+    /* Corrupt data: zlib's msg is exactly Node's error message text. */
+    const char *msg = zs.msg ? zs.msg : "zlib error";
+    size_t mlen = strlen(msg);
+    inflateEnd(&zs);
+    free(buf);
+    scr_throw_error_msg(SCR_ERR_ERROR, msg, mlen);
+    return NULL;
+  }
+  inflateEnd(&zs);
+  ScrBytes *out = scr_bytes_new(SCR_BYTES_U8, (double)len);
+  memcpy(out->data, buf, len);
+  free(buf);
+  return out;
+}
+
+/* ── format-mode variants (static raw/gzip/unzip calls use these directly;
+ * scr_zlib_island.c also bridges them into the embedded engine's node:zlib
+ * shim) ───────────────────────────────────────────────────────────────
+ * mode: 0 zlib (windowBits 15), 1 raw (-15), 2 gzip (15+16); inflate
+ * additionally takes 3 = auto-detect zlib/gzip (15+32, Node's unzip). */
+
+static int scr_zlib_window_bits(int mode, bool inflating) {
+  switch (mode) {
+  case 1: return -15;
+  case 2: return 15 + 16;
+  case 3: return inflating ? 15 + 32 : 15;
+  default: return 15;
+  }
+}
+
+ScrBytes *scr_zlib_deflate_mode(const ScrBytes *data, double mode, double level) {
+  z_stream zs;
+  memset(&zs, 0, sizeof zs);
+  int lvl = (int)level;
+  if (lvl < -1 || lvl > 9) lvl = Z_DEFAULT_COMPRESSION;
+  if (deflateInit2(&zs, lvl, Z_DEFLATED, scr_zlib_window_bits((int)mode, false), 8,
+                   Z_DEFAULT_STRATEGY) != Z_OK) {
+    scr_zlib_oom();
+  }
+  uLong cap = deflateBound(&zs, (uLong)data->len);
+  uint8_t *buf = malloc(cap ? cap : 1);
+  if (!buf) scr_zlib_oom();
+  zs.next_in = data->data;
+  zs.avail_in = (uInt)data->len;
+  zs.next_out = buf;
+  zs.avail_out = (uInt)cap;
+  int rc = deflate(&zs, Z_FINISH);
+  if (rc != Z_STREAM_END) scr_zlib_oom(); /* bound guarantees completion */
+  size_t len = cap - zs.avail_out;
+  deflateEnd(&zs);
+  ScrBytes *out = scr_bytes_new(SCR_BYTES_U8, (double)len);
+  memcpy(out->data, buf, len);
+  free(buf);
+  return out;
+}
+
+ScrBytes *scr_zlib_inflate_mode(const ScrBytes *data, double mode) {
+  z_stream zs;
+  memset(&zs, 0, sizeof zs);
+  if (inflateInit2(&zs, scr_zlib_window_bits((int)mode, true)) != Z_OK) scr_zlib_oom();
+  size_t cap = data->len > 64 ? data->len * 4 : 256;
+  uint8_t *buf = malloc(cap);
+  if (!buf) scr_zlib_oom();
+  zs.next_in = data->data;
+  zs.avail_in = (uInt)data->len;
+  size_t len = 0;
+  for (;;) {
+    zs.next_out = buf + len;
+    zs.avail_out = (uInt)(cap - len);
+    int rc = inflate(&zs, Z_NO_FLUSH);
+    len = cap - zs.avail_out;
+    if (rc == Z_STREAM_END) break;
+    if (rc == Z_OK || rc == Z_BUF_ERROR) {
+      if (rc == Z_BUF_ERROR && zs.avail_in == 0 && zs.avail_out > 0) {
+        inflateEnd(&zs);
+        free(buf);
+        static const char msg[] = "unexpected end of file";
+        scr_throw_error_msg_code(SCR_ERR_ERROR, msg, sizeof msg - 1, "Z_BUF_ERROR");
+        return NULL;
+      }
+      if (cap - len < 64) {
+        cap *= 2;
+        uint8_t *grown = realloc(buf, cap);
+        if (!grown) scr_zlib_oom();
+        buf = grown;
+      }
+      continue;
+    }
+    const char *msg = zs.msg ? zs.msg : "zlib error";
+    size_t mlen = strlen(msg);
+    /* Node stamps the zlib return code's name (err.code) */
+    const char *code = rc == Z_DATA_ERROR ? "Z_DATA_ERROR"
+                       : rc == Z_NEED_DICT ? "Z_NEED_DICT"
+                       : rc == Z_MEM_ERROR ? "Z_MEM_ERROR"
+                                           : "Z_STREAM_ERROR";
+    inflateEnd(&zs);
+    free(buf);
+    scr_throw_error_msg_code(SCR_ERR_ERROR, msg, mlen, code);
+    return NULL;
+  }
+  inflateEnd(&zs);
+  ScrBytes *out = scr_bytes_new(SCR_BYTES_U8, (double)len);
+  memcpy(out->data, buf, len);
+  free(buf);
+  return out;
+}
+
+double scr_zlib_crc32(const ScrBytes *data, double value) {
+  char recv[48], msg[160];
+  scr_num_received(value, recv);
+  if (!(isfinite(value) && trunc(value) == value)) {
+    int len = snprintf(msg, sizeof msg,
+                       "The value of \"value\" is out of range. It must be an integer. Received %s",
+                       recv);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)len, "ERR_OUT_OF_RANGE");
+    return 0;
+  }
+  if (value < 0 || value > 4294967295.0) {
+    int len = snprintf(msg, sizeof msg,
+                       "The value of \"value\" is out of range. It must be >= 0 && <= 4294967295. Received %s",
+                       recv);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)len, "ERR_OUT_OF_RANGE");
+    return 0;
+  }
+  return (double)(uint32_t)crc32_z((uLong)value, data->data, data->len);
+}
+
+/* The callback convenience methods share the executable's four-worker
+ * pool with fs.rename. Only copied raw bytes and malloc-owned result state
+ * cross threads; runtime RC, exceptions, Buffer/Error construction, and
+ * callback execution stay on the main thread. */
+#ifndef SCR_LIB
+typedef struct {
+  unsigned char *data;
+  size_t len;
+  int mode;
+  bool compressing;
+  unsigned char *result;
+  size_t result_len;
+  int error;
+  char message[128];
+  ScrClosure *cb;
+  ScrZlibBytesFn fn;
+} ScrZlibAsyncOp;
+
+static const char *scr_zlib_error_code(int error) {
+  switch (error) {
+  case Z_BUF_ERROR: return "Z_BUF_ERROR";
+  case Z_DATA_ERROR: return "Z_DATA_ERROR";
+  case Z_NEED_DICT: return "Z_NEED_DICT";
+  case Z_MEM_ERROR: return "Z_MEM_ERROR";
+  default: return "Z_STREAM_ERROR";
+  }
+}
+
+static void scr_zlib_async_deflate(ScrZlibAsyncOp *op) {
+  z_stream zs;
+  memset(&zs, 0, sizeof zs);
+  if (deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
+                   scr_zlib_window_bits(op->mode, false), 8,
+                   Z_DEFAULT_STRATEGY) != Z_OK) {
+    scr_zlib_oom();
+  }
+  uLong cap = deflateBound(&zs, (uLong)op->len);
+  op->result = malloc(cap ? cap : 1);
+  if (!op->result) scr_zlib_oom();
+  zs.next_in = op->data;
+  zs.avail_in = (uInt)op->len;
+  zs.next_out = op->result;
+  zs.avail_out = (uInt)cap;
+  int rc = deflate(&zs, Z_FINISH);
+  if (rc != Z_STREAM_END) scr_zlib_oom();
+  op->result_len = cap - zs.avail_out;
+  deflateEnd(&zs);
+}
+
+static void scr_zlib_async_inflate(ScrZlibAsyncOp *op) {
+  z_stream zs;
+  memset(&zs, 0, sizeof zs);
+  if (inflateInit2(&zs, scr_zlib_window_bits(op->mode, true)) != Z_OK) {
+    scr_zlib_oom();
+  }
+  size_t cap = op->len > 64 ? op->len * 4 : 256;
+  op->result = malloc(cap);
+  if (!op->result) scr_zlib_oom();
+  zs.next_in = op->data;
+  zs.avail_in = (uInt)op->len;
+  size_t len = 0;
+  for (;;) {
+    zs.next_out = op->result + len;
+    zs.avail_out = (uInt)(cap - len);
+    int rc = inflate(&zs, Z_NO_FLUSH);
+    len = cap - zs.avail_out;
+    if (rc == Z_STREAM_END) {
+      op->result_len = len;
+      break;
+    }
+    if (rc == Z_OK || rc == Z_BUF_ERROR) {
+      if (rc == Z_BUF_ERROR && zs.avail_in == 0 && zs.avail_out > 0) {
+        op->error = Z_BUF_ERROR;
+        memcpy(op->message, "unexpected end of file", sizeof "unexpected end of file");
+        break;
+      }
+      if (cap - len < 64) {
+        cap *= 2;
+        unsigned char *grown = realloc(op->result, cap);
+        if (!grown) scr_zlib_oom();
+        op->result = grown;
+      }
+      continue;
+    }
+    op->error = rc;
+    snprintf(op->message, sizeof op->message, "%s", zs.msg ? zs.msg : "zlib error");
+    break;
+  }
+  inflateEnd(&zs);
+}
+
+static void scr_zlib_async_work(void *payload) {
+  ScrZlibAsyncOp *op = payload;
+  if (op->compressing) scr_zlib_async_deflate(op);
+  else scr_zlib_async_inflate(op);
+}
+
+static void scr_zlib_async_after(void *payload) {
+  ScrZlibAsyncOp *op = payload;
+  if (op->error == Z_OK) {
+    ScrBytes *value = scr_bytes_new(SCR_BYTES_U8, (double)op->result_len);
+    memcpy(value->data, op->result, op->result_len);
+    op->fn(op->cb, NULL, value);
+    return;
+  }
+  scr_throw_error_msg_code(SCR_ERR_ERROR, op->message, strlen(op->message),
+                           scr_zlib_error_code(op->error));
+  ScrCaught *caught = scr_exc_take();
+  ScrError *error = caught && caught->kind == SCR_EXC_OBJ && scr_error_is(caught->payload)
+      ? (ScrError *)caught->payload
+      : NULL;
+  op->fn(op->cb, error, NULL);
+  scr_caught_release(caught);
+}
+
+static void scr_zlib_async_destroy(void *payload) {
+  ScrZlibAsyncOp *op = payload;
+  free(op->data);
+  free(op->result);
+  scr_closure_release(op->cb);
+  free(op);
+}
+
+void scr_zlib_codec_async(const ScrBytes *data, double mode, bool compressing,
+                          ScrClosure *cb, ScrZlibBytesFn fn) {
+  ScrZlibAsyncOp *op = calloc(1, sizeof *op);
+  if (!op) scr_zlib_oom();
+  op->data = malloc(data->len ? data->len : 1);
+  if (!op->data) scr_zlib_oom();
+  memcpy(op->data, data->data, data->len);
+  op->len = data->len;
+  op->mode = (int)mode;
+  op->compressing = compressing;
+  op->cb = cb;
+  op->fn = fn;
+  scr_work_submit(op, &scr_zlib_async_work, &scr_zlib_async_after,
+                  &scr_zlib_async_destroy);
+}
+#endif
+
+/* One-shot raw-DEFLATE inflate into a caller-sized buffer: the island's
+ * compressed embedded module text (the emitter stores big npm sources
+ * deflated and their exact inflated length in the table row — the emitted
+ * main installs this through scr_island_set_inflate). True only when the
+ * stream ends exactly at dst_len; any mismatch is a build/runtime bug the
+ * caller surfaces, never a silent truncation. */
+bool scr_zlib_inflate_exact(const unsigned char *src, size_t src_len,
+                            unsigned char *dst, size_t dst_len) {
+  z_stream zs;
+  memset(&zs, 0, sizeof zs);
+  if (inflateInit2(&zs, -15) != Z_OK) return false; /* raw DEFLATE */
+  zs.next_in = (Bytef *)(uintptr_t)src;
+  zs.avail_in = (uInt)src_len;
+  zs.next_out = dst;
+  zs.avail_out = (uInt)dst_len;
+  int rc = inflate(&zs, Z_FINISH);
+  bool ok = rc == Z_STREAM_END && zs.total_out == dst_len;
+  inflateEnd(&zs);
+  return ok;
+}

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

@@ -0,0 +1,15 @@
+/* The zlib ↔ island bridge — the one translation unit referencing BOTH
+ * scr_zlib.c and the island (the scr_inspect_island.c precedent): native-toolchain.ts
+ * compiles it exactly when a --dynamic build's embedded npm graph
+ * imports node:zlib, and the emitted main calls scr_zlib_island_install
+ * before any island entry. zlib-free dynamic builds keep the island's
+ * "zlib is not linked" refusal; island-free zlib builds never load this
+ * file. */
+#include "scr_runtime.h"
+
+void scr_island_set_zlib(ScrBytes *(*deflate)(const ScrBytes *, double, double),
+                         ScrBytes *(*inflate)(const ScrBytes *, double));
+
+void scr_zlib_island_install(void) {
+  scr_island_set_zlib(scr_zlib_deflate_mode, scr_zlib_inflate_mode);
+}

package/dist/lib/runtime-sources/vendor/README.md

@@ -0,0 +1,60 @@
+# 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 and AArch64 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 for the explicit `x86_64-linux-musl` and `aarch64-linux-musl` targets and uses musl's public `ucontext_t` layouts. 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
+- Commit: 4c0618b0e44f7ef027ebae05d2cc7812048f7c8f
+- License: Apache-2.0 OR BSL-1.0, used under the Boost Software License 1.0 (see ryu/LICENSE-Boost)
+
+The double-to-shortest-decimal core of Ryū (d2s and its headers only — the float and fixed/exponent variants are not vendored). scr_number.c textually `#include`s d2s.c and calls its internal `d2d` digit generator; ECMA-262 digit *placement* stays in scr_number.c. The only modification to upstream files: `#include "ryu/x.h"` flattened to `#include "x.h"` in d2s.c and d2s_intrinsics.h so the directory is self-contained. To update, re-fetch the listed files at the new commit and re-apply that include flattening.
+
+## quickjs-ng/
+
+- Project: https://github.com/quickjs-ng/quickjs
+- Version: v0.15.1
+- Commit: 3c8f3d68953955950074c41c6e4d999562ae82a7
+- License: MIT (see quickjs-ng/LICENSE)
+
+The QuickJS-ng JavaScript engine, embedded by the opt-in `--dynamic` build mode (see packages/runtime/src/scr_island.c). Static builds never compile or link any of this.
+
+The tree is a plain snapshot of the upstream commit with directories the library build does not need removed (tests/, docs/, examples/, test262 fixtures, CI config, generator scripts). No vendored file is modified; to update, re-clone upstream at the new commit, delete its .git directory, apply the same trim, and update this file.
+
+The engine archive (libqjs.a) is prebuilt best-effort during npm installation (or explicitly by `scriptc cache warm`) and otherwise built lazily on the first `--dynamic` compile. It lives under the per-user build cache's `vendor/<commit>-<flavor>-<target>-<toolchain>/` directory — one flavor per lane (plain, asan), native platform/architecture or explicit cross target, and compiler environment/identity.
+
+## zlib/
+
+- Project: https://github.com/madler/zlib
+- Version: 1.3.1 (release tarball zlib-1.3.1.tar.gz, sha256 9a93b2b7dfdac77ceba5a558a580e74667dd6fede4585b91eefb60f03b72df23)
+- License: zlib (see zlib/LICENSE)
+
+The CROSS-target arm of node:zlib (see packages/runtime/src/scr_zlib.c): host builds keep the historical system `-lz` link (macOS ships libz), but zig's cross sysroots have no libz, so SCRIPTC_TARGET builds compile this vendored copy per target instead. Only the flat `*.c`/`*.h` at the distribution root are vendored (LICENSE beside them) — contrib, tests, build machinery, and docs are not. No vendored file is modified; the gz* file-I/O TUs are vendored for faithfulness but never compiled (nothing references the gzFile API — see ZLIB_SOURCES in packages/compiler/src/backend/vendor-archives.ts). To update, re-fetch the release tarball, copy the same flat set, and bump `ZLIB_VERSION` in vendor-archives.ts.
+
+The objects build lazily on the first zlib-using cross compile into the per-user build cache's `vendor/zlib-<version>-<flavor>-<target>-<toolchain>/` directory — one flavor per driver/target and compiler environment/identity (the lre-objects pattern). Zlib-free binaries never compile any of this; compressed OUTPUT bytes are zlib-version-dependent, which is why the corpus only compares round-trips and fixed-blob inflation.
+
+## curl/
+
+- Project: https://curl.se/ (Debian bookworm's libcurl4-openssl-dev 7.88.1, the exact library the Linux lane's pinned container image ships)
+- Version: 7.88.1 (headers copied byte-for-byte from `node:24.15.0-bookworm`'s `/usr/include/aarch64-linux-gnu/curl/`; the arch-specific include dir is Debian multiarch layout — the headers themselves are architecture-independent, `system.h` selects per-arch typedefs at preprocessing time)
+- License: curl (see curl/COPYRIGHT — the Debian machine-readable copyright file for the package the headers came from)
+
+HEADERS ONLY — no curl C source is vendored and none is ever compiled. These headers now serve ONLY the RETIRED curl reference implementation of fetch (packages/runtime/src/scr_fetch_curl.c, selected by `SCRIPTC_FETCH_CURL=1`; kept compilable for one release as the native flip's reference — see scr_fetch.c, the default, which rides scr_net/scr_tls/scr_http/zlib and touches nothing here). Under the flag: host builds link the system `-lcurl` (macOS ships libcurl), and linux-gnu CROSS builds compile scr_fetch_curl.c against these headers, then link against a generated STUB `libcurl.so` (soname `libcurl.so.4`, empty definitions of exactly the symbols scr_fetch_curl.c calls — see CURL_STUB_SYMBOLS in packages/compiler/src/backend/vendor-archives.ts) so the produced binary records a plain `DT_NEEDED libcurl.so.4` that the TARGET system's real libcurl satisfies at load time, the standard cross-link import-stub technique. The 7.88.1 pin is a floor, not a lock: scr_fetch_curl.c's newest requirement is CURLOPT_PROTOCOLS_STR (7.85.0) and the unversioned symbol references bind to any libcurl.so.4. This whole directory leaves with scr_fetch_curl.c when the reference retires for good.
+
+The stub builds lazily on the first flag-selected fetch cross compile into the per-user build cache's `vendor/curl-stub-<target>-<toolchain>/` directory (the zlib-objects pattern). Default builds never see any of this, and no build ever compiles curl itself.
+
+## mbedtls/
+
+- Project: https://github.com/Mbed-TLS/mbedtls
+- Version: mbedtls-3.6.7 (the 3.6 LTS line — 4.x moved the crypto core into the separate TF-PSA-Crypto repository; the self-contained LTS is what a vendored tree wants)
+- License: Apache-2.0 (see mbedtls/LICENSE)
+
+The TLS provider behind node:tls/node:https (see the design note atop packages/runtime/src/scr_tls.c for why mbedTLS over SecureTransport/BoringSSL/libtls). Only `include/` and `library/` are vendored (LICENSE beside them) — tests, docs, programs, scripts, and CMake machinery are not. No vendored file is modified and no custom config is applied (the stock `mbedtls_config.h` builds every `library/*.c` standalone with clang); to update, re-fetch the release tarball, copy the same two directories, and bump `MBEDTLS_VERSION` in packages/compiler/src/backend/vendor-archives.ts.
+
+The archive (libmbedtls.a) is prebuilt best-effort during npm installation (or explicitly by `scriptc cache warm`) and otherwise built lazily on the first TLS-using compile. It lives under the per-user build cache's `vendor/mbedtls-<version>-<flavor>-<target>-<toolchain>/` directory — one flavor per lane (plain, asan), native platform/architecture or explicit cross target, and compiler environment/identity, the libqjs.a pattern. TLS-free binaries never compile or link any of this.