@scriptc/runtime 0.0.26 → 0.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/runtime",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "description": "scriptc native runtime — C sources, compiled into every scriptc binary",
   "license": "Apache-2.0",
   "homepage": "https://scriptc.dev",

package/src/scr_array.c

@@ -8,7 +8,7 @@
 /* Live heap-array 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_arrays = 0;
+static SCR_TL long scr_live_arrays = 0;
 long scr_arr_live_count(void) { return scr_live_arrays; }
 #endif
 

package/src/scr_assert.c

@@ -158,9 +158,9 @@ void scr_assert_ok(bool pass, ScrStr *message) {
  * PAIR already being compared answers equal (the coinductive step —
  * Node's memo behavior exactly). The stack is global (comparisons never
  * interleave; the emitted walks cannot throw mid-compare). */
-static struct { const void *a, *b; } *g_deq_stack;
-static size_t g_deq_len;
-static size_t g_deq_cap;
+static SCR_TL struct { const void *a, *b; } *g_deq_stack;
+static SCR_TL size_t g_deq_len;
+static SCR_TL size_t g_deq_cap;
 
 bool scr_assert_deq_enter(const void *a, const void *b) {
   for (size_t i = 0; i < g_deq_len; i++) {
@@ -1228,7 +1228,7 @@ typedef struct {
   ScrStr *val; /* owned: the string value, or the regex's /source/flags */
 } ScrShapeSlot;
 
-static struct {
+static SCR_TL struct {
   ScrError *err; /* borrowed — alive across the straight-line sequence */
   ScrShapeSlot slots[3];
 } scr_shape;

package/src/scr_bytes.c

@@ -17,7 +17,7 @@
 #include <string.h>
 
 #ifdef SCR_RC_AUDIT
-static long scr_live_bytes = 0;
+static SCR_TL long scr_live_bytes = 0;
 long scr_bytes_live_count(void) { return scr_live_bytes; }
 #endif
 

package/src/scr_closure.c

@@ -5,8 +5,8 @@
 #include <string.h>
 
 #ifdef SCR_RC_AUDIT
-static long scr_live_boxes = 0;
-static long scr_live_closures = 0;
+static SCR_TL long scr_live_boxes = 0;
+static SCR_TL long scr_live_closures = 0;
 long scr_box_live_count(void) { return scr_live_boxes; }
 long scr_closure_live_count(void) { return scr_live_closures; }
 #endif

package/src/scr_console.c

@@ -11,7 +11,7 @@
 /* Set by scr_async.c at loop exhaustion; lives here (unconditionally) so
  * binaries that link the console without the async runtime still link, and
  * plain builds satisfy scr_async's reference. */
-static long scr_abandoned_fibers = 0;
+static SCR_TL long scr_abandoned_fibers = 0;
 void scr_note_abandoned_fibers(long n) { scr_abandoned_fibers = n; }
 
 #ifndef SCR_LIB

package/src/scr_cycle.c

@@ -95,7 +95,7 @@ static void scr_cyc_oom(void) {
 }
 
 /* Live cycle-headered objects — what the full-pass trigger watches. */
-static size_t scr_cyc_live = 0;
+static SCR_TL size_t scr_cyc_live = 0;
 
 void *scr_cyc_alloc(size_t size, ScrTraceFn trace, ScrCycFreeFn free_fn) {
   ScrCycHdr *h = calloc(1, sizeof(ScrCycHdr) + size);
@@ -137,25 +137,25 @@ static void scr_cyc_push(ScrVec *vec, void *obj) {
 
 /* ── the candidate-root buffers (one per generation) ──────────────────── */
 
-static ScrVec scr_roots[SCR_CYC_NGENS];
-static bool scr_collecting = false;
+static SCR_TL ScrVec scr_roots[SCR_CYC_NGENS];
+static SCR_TL bool scr_collecting = false;
 
 /* The candidates of the pass in flight, gathered across the generations it
  * collects so the phases can walk them without re-filtering the buffers. */
-static ScrVec scr_cands;
+static SCR_TL ScrVec scr_cands;
 
 /* Nursery survivors awaiting promotion (see scr_scan_black). */
-static ScrVec scr_promote;
+static SCR_TL ScrVec scr_promote;
 
 /* The gathered white set (freed after the walk completes). */
-static ScrVec scr_white;
+static SCR_TL ScrVec scr_white;
 
 /* Cross-generation targets pinned by the white set (see scr_xg_pin_visit),
  * one entry per skipped edge. Drained after the teardowns. */
-static ScrVec scr_xgen;
+static SCR_TL ScrVec scr_xgen;
 
 /* Objects above this generation are invisible to the pass in flight. */
-static unsigned scr_gen_limit = SCR_CYC_MATURE;
+static SCR_TL unsigned scr_gen_limit = SCR_CYC_MATURE;
 
 static size_t scr_cyc_pass(unsigned gen_limit);
 
@@ -166,10 +166,10 @@ static size_t scr_cyc_pass(unsigned gen_limit);
 #define SCR_CYC_FULL_FLOOR 4096        /* ...but not below this many objects */
 
 /* Live count as of the end of the last full pass. */
-static size_t scr_cyc_live_after_full = 0;
+static SCR_TL size_t scr_cyc_live_after_full = 0;
 
 static size_t scr_cyc_nursery_threshold(void) {
-  static size_t cached = 0;
+  static SCR_TL size_t cached = 0;
   if (cached == 0) {
     const char *env = getenv("SCR_CYCLE_THRESHOLD");
     long v = env ? strtol(env, NULL, 10) : 0;
@@ -186,12 +186,12 @@ static size_t scr_cyc_nursery_threshold(void) {
  * hysteresis a large mature buffer — which a nursery pass cannot drain —
  * would re-arm on every single release. Both start at zero, so the first
  * release runs one trivial pass that arms them properly. */
-static size_t scr_cyc_nbuffered = 0;
-static size_t scr_cyc_trigger = 0;
+static SCR_TL size_t scr_cyc_nbuffered = 0;
+static SCR_TL size_t scr_cyc_trigger = 0;
 
 /* Scheduled nursery passes for which at least one mature root was waiting.
  * A full pass resets the age; with no mature backlog there is nothing to age. */
-static size_t scr_cyc_scheduled_mature_age = 0;
+static SCR_TL size_t scr_cyc_scheduled_mature_age = 0;
 
 static size_t scr_cyc_buffered(void) {
   return scr_roots[SCR_CYC_NURSERY].n + scr_roots[SCR_CYC_MATURE].n;
@@ -404,7 +404,7 @@ static void scr_xg_pin_visit(void *child, void *ctx) {
 }
 
 /* Freed by the cross-generation drain, for the caller's fixpoint. */
-static size_t scr_xg_freed = 0;
+static SCR_TL size_t scr_xg_freed = 0;
 
 static void scr_xg_release(void *obj);
 static void scr_xg_child_visit(void *child, void *ctx) {

package/src/scr_error.c

@@ -17,7 +17,7 @@ static void scr_error_oom(void) {
   scr_trap("scriptc: out of memory\n");
 }
 
-static bool scr_error_traced = false;
+static SCR_TL bool scr_error_traced = false;
 
 void scr_error_set_traced(void) { scr_error_traced = true; }
 
@@ -49,7 +49,7 @@ static void scr_error_gcfree(void *obj) {
  * must stay linkable WITHOUT the checked-dynamic tree (the runtime C-unit tests link
  * subsets), so the drop goes through a hook scr_json.c installs before
  * any cause can exist (scr_domex_new is the only producer). */
-static void (*scr_domex_cause_drop)(void *obj) = NULL;
+static SCR_TL void (*scr_domex_cause_drop)(void *obj) = NULL;
 
 void scr_domex_install_cause_drop(void (*fn)(void *obj)) {
   scr_domex_cause_drop = fn;
@@ -90,7 +90,7 @@ static void scr_domex_reld(void *obj) {
 
 /* Defaults cover only the instants before main() stamps the program's real
  * preorder intervals; release is permanent. */
-ScrVt scr_error_vts[5] = {
+SCR_TL ScrVt scr_error_vts[5] = {
     {0, 4, &scr_error_reld}, /* Error */
     {1, 1, &scr_error_reld}, /* TypeError */
     {2, 2, &scr_error_reld}, /* RangeError */

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. */

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_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_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++) {

package/src/scr_lib.c

@@ -104,14 +104,14 @@ extern char **environ; /* env snapshot (scr_env_pairs) */
 
 /* ── process ─────────────────────────────────────────────────────────── */
 
-static int scr_lib_argc = 0;
-static char **scr_lib_argv = NULL;
-static ScrArr *scr_argv_arr = NULL;    /* interned process.argv */
-static ScrStr *scr_platform_str = NULL; /* interned process.platform */
-static ScrStr *scr_exec_path_str = NULL; /* interned process.execPath */
-static ScrStr *scr_arch_str = NULL;      /* interned process.arch */
-static ScrStr *scr_versions_node_str = NULL; /* interned process.versions.node */
-static ScrStr *scr_versions_openssl_str = NULL; /* interned process.versions.openssl */
+static SCR_TL int scr_lib_argc = 0;
+static SCR_TL char **scr_lib_argv = NULL;
+static SCR_TL ScrArr *scr_argv_arr = NULL;    /* interned process.argv */
+static SCR_TL ScrStr *scr_platform_str = NULL; /* interned process.platform */
+static SCR_TL ScrStr *scr_exec_path_str = NULL; /* interned process.execPath */
+static SCR_TL ScrStr *scr_arch_str = NULL;      /* interned process.arch */
+static SCR_TL ScrStr *scr_versions_node_str = NULL; /* interned process.versions.node */
+static SCR_TL ScrStr *scr_versions_openssl_str = NULL; /* interned process.versions.openssl */
 
 static void scr_lib_cleanup(void) {
   scr_arr_release(scr_argv_arr);
@@ -1103,8 +1103,27 @@ void scr_process_exit(double code) {
  * attribute monotonic stamp — the binary's own start, which is what
  * "the current Node.js process" means for a compiled program). */
 #ifdef _WIN32
+#if defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES)
+/* The uptime anchor belongs to the host PROCESS, not to a library
+ * instance. InitOnce keeps the lazy Windows spelling race-free when
+ * several thread instances ask for the clock concurrently. */
+static INIT_ONCE scr_uptime_once = INIT_ONCE_STATIC_INIT;
 static double scr_uptime_t0_ms;
+static BOOL CALLBACK scr_uptime_anchor_once(PINIT_ONCE once, PVOID param,
+                                             PVOID *ctx) {
+  (void)once;
+  (void)param;
+  (void)ctx;
+  scr_uptime_t0_ms = (double)GetTickCount64();
+  return TRUE;
+}
+static void scr_uptime_anchor_init(void) {
+  InitOnceExecuteOnce(&scr_uptime_once, scr_uptime_anchor_once, NULL, NULL);
+}
+#else
+static SCR_TL double scr_uptime_t0_ms;
 static void scr_uptime_anchor_init(void) { scr_uptime_t0_ms = (double)GetTickCount64(); }
+#endif
 static double scr_uptime_now_ms(void) { return (double)GetTickCount64(); }
 #else
 #include <sys/resource.h>
@@ -1112,6 +1131,10 @@ static double scr_uptime_now_ms(void) { return (double)GetTickCount64(); }
 #ifdef __APPLE__
 #include <mach/mach.h>
 #endif
+/* A load-time, process-wide anchor: the constructor runs on only the
+ * initial thread, while thread-instanced archives are entered from worker
+ * threads whose TLS slots would otherwise stay zero. It is immutable once
+ * main starts, so sharing it adds no cross-instance mutable state. */
 static double scr_uptime_t0_ms;
 static double scr_uptime_now_ms(void) {
   struct timespec ts;
@@ -1124,7 +1147,9 @@ __attribute__((constructor)) static void scr_uptime_anchor_init(void) {
 #endif
 
 double scr_process_uptime(void) {
-#ifdef _WIN32
+#if defined(_WIN32) && defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES)
+  scr_uptime_anchor_init();
+#elif defined(_WIN32)
   if (scr_uptime_t0_ms == 0) scr_uptime_anchor_init();
 #endif
   return (scr_uptime_now_ms() - scr_uptime_t0_ms) / 1000.0;
@@ -1134,7 +1159,9 @@ double scr_process_uptime(void) {
  * start (Node's timeOrigin anchor), fractional — the same monotonic
  * clock and anchor as uptime, in Node's performance.now units. */
 double scr_perf_now(void) {
-#ifdef _WIN32
+#if defined(_WIN32) && defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES)
+  scr_uptime_anchor_init();
+#elif defined(_WIN32)
   if (scr_uptime_t0_ms == 0) scr_uptime_anchor_init();
 #endif
   return scr_uptime_now_ms() - scr_uptime_t0_ms;
@@ -1353,7 +1380,7 @@ double scr_available_memory(void) {
 /* process._exiting — true once the exit sequence began (set above and by
  * scr_run_exit_listeners in scr_events.c; the flag lives HERE so reading
  * it never forces the events unit into the link). */
-bool scr_process_in_exit = false;
+SCR_TL bool scr_process_in_exit = false;
 
 bool scr_process_exiting(void) { return scr_process_in_exit; }
 
@@ -1372,7 +1399,7 @@ double scr_process_umask(double mask) {
   }
   return (double)prev;
 #elif defined(__wasi__)
-  static mode_t current = 022;
+  static SCR_TL mode_t current = 022;
   mode_t prev = current;
   if (mask >= 0) current = (mode_t)mask;
   return (double)prev;
@@ -1399,7 +1426,7 @@ void scr_process_chdir(ScrStr *dir) {
 /* net's process-wide happy-eyeballs attempt budget (Node's
  * getDefaultAutoSelectFamilyAttemptTimeout pair, default 250ms). Lives in
  * the core unit so the knob never forces scr_net.c into the link. */
-static double scr_net_autosel_timeout_ms = 250;
+static SCR_TL double scr_net_autosel_timeout_ms = 250;
 
 double scr_net_get_autosel_timeout(void) { return scr_net_autosel_timeout_ms; }
 
@@ -2745,8 +2772,8 @@ double scr_process_columns(double fd) {
  * NON-TTY stdin: Node's process.stdin is a Socket with no setRawMode
  * member at all, so the call throws Node's exact catchable TypeError. */
 #ifdef _WIN32
-static DWORD scr_stdin_cooked;
-static bool scr_stdin_cooked_saved = false;
+static SCR_TL DWORD scr_stdin_cooked;
+static SCR_TL bool scr_stdin_cooked_saved = false;
 
 void scr_process_stdin_set_raw_mode(bool raw) {
   if (!isatty(0)) {
@@ -2778,8 +2805,8 @@ void scr_process_stdin_set_raw_mode(bool raw) {
   scr_throw_error_msg(SCR_ERR_TYPE, msg, sizeof msg - 1);
 }
 #else
-static struct termios scr_stdin_cooked;
-static bool scr_stdin_cooked_saved = false;
+static SCR_TL struct termios scr_stdin_cooked;
+static SCR_TL bool scr_stdin_cooked_saved = false;
 
 void scr_process_stdin_set_raw_mode(bool raw) {
   if (!isatty(0)) {

package/src/scr_library.c

@@ -10,6 +10,24 @@
  * profile-agnostic and the program TU carries every profile-named symbol —
  * one place for the conformance symbol audit to look.
  *
+ * Multi-instance processes (the profile's abi.localize_runtime): the
+ * archive build demotes this file's externals — and every other runtime
+ * internal — to LOCAL symbols, so each linked archive carries its own
+ * private copy of all the state here: its own sink registration, poison
+ * flag, arena, and entry-symbol slot. Sinks therefore register per
+ * instance, and a trap poisons only the instance it fired in. Nothing in
+ * this file is thread-aware; the embedder contract is one thread per
+ * instance (an instance is never entered from two threads).
+ *
+ * Thread-instanced archives (the profile's abi.instance_per_thread) take
+ * the same story one level down: SCR_TL moves this file's state — and
+ * every other mutable static in the archive — into thread-local storage,
+ * so ONE linked archive serves one independent instance per embedder
+ * thread. A thread registers its own sink and calls the init entry before
+ * serving; its trap poisons only its own instance while sibling threads'
+ * instances keep answering. The one-thread-per-instance contract is
+ * unchanged — the calling thread IS the instance selector.
+ *
  * State after a sink call: none is legal. The trap fired mid-operation with
  * no unwinding — heap, arena, and collector state are unspecified; the library
  * is POISONED. Every runtime-touching entry prologue aborts on the flag
@@ -23,9 +41,9 @@
 
 /* ── sink registration + poison ───────────────────────────────────────── */
 
-static ScrLibSinkFn scr_library_sink = NULL;
-static void *scr_library_sink_ctx = NULL;
-static bool scr_library_poisoned = false;
+static SCR_TL ScrLibSinkFn scr_library_sink = NULL;
+static SCR_TL void *scr_library_sink_ctx = NULL;
+static SCR_TL bool scr_library_poisoned = false;
 
 void scr_library_set_sink(ScrLibSinkFn fn, void *ctx) {
   /* Latest registration wins; re-registration is permitted before a trap.
@@ -62,10 +80,12 @@ void scr_library_set_sink(ScrLibSinkFn fn, void *ctx) {
 
 /* The current-entry slot: every generated entry's prologue records its
  * external symbol before dispatching into core code. A single static slot
- * is sound — exactly one core is live per process (the one-live-core rule),
- * entries never nest, and a trap can only fire while an entry is on the
- * stack. NULL (never entered) renders as the empty symbol field. */
-static const char *scr_library_entry_symbol = NULL;
+ * is sound — exactly one core is live per copy of this state (the sole
+ * core in a classic process; each archive's own instance under
+ * abi.localize_runtime, where this slot is a per-instance local), entries
+ * never nest, and a trap can only fire while an entry is on the stack.
+ * NULL (never entered) renders as the empty symbol field. */
+static SCR_TL const char *scr_library_entry_symbol = NULL;
 
 /* Detected-trap classification: the runtime's trap sites self-classify
  * through their message conventions (the exact bytes the executable lane
@@ -103,7 +123,7 @@ static _Noreturn void scr_library_trap_deliver(const char *msg, size_t len, uint
      * no malloc on the failure path; text truncates before structure ever
      * would (codes and symbols are short; an oversized remediation drops
      * whole, never split). */
-    static char buf[2048];
+    static SCR_TL char buf[2048];
     const char *code = scr_library_trap_code(msg, len);
     const char *text = msg;
     size_t text_len = len;
@@ -168,7 +188,7 @@ __attribute__((noinline)) _Noreturn void scr_trap_len(const char *msg, size_t le
 }
 
 __attribute__((noinline)) _Noreturn void scr_trap_fmt(const char *fmt, ...) {
-  static char buf[512]; /* no malloc on the invariant-failure path */
+  static SCR_TL char buf[512]; /* no malloc on the invariant-failure path */
   va_list ap;
   va_start(ap, fmt);
   int n = vsnprintf(buf, sizeof buf, fmt, ap);
@@ -202,8 +222,8 @@ typedef struct {
   bool is_str; /* ScrStr vs ScrBytes — picks the release */
 } ScrCoreArenaEnt;
 
-static ScrCoreArenaEnt *scr_library_arena = NULL;
-static size_t scr_library_arena_n = 0, scr_library_arena_cap = 0;
+static SCR_TL ScrCoreArenaEnt *scr_library_arena = NULL;
+static SCR_TL size_t scr_library_arena_n = 0, scr_library_arena_cap = 0;
 
 static void scr_library_arena_keep(void *v, bool is_str) {
   if (scr_library_arena_n == scr_library_arena_cap) {
@@ -285,8 +305,8 @@ void scr_library_bytes_out(ScrBytes *b, const uint8_t **out, size_t *out_len) {
  * satisfied because the entry persists. */
 
 #define SCR_LIB_MAX_RESETS 32
-static void (*scr_library_resets[SCR_LIB_MAX_RESETS])(void);
-static size_t scr_library_nresets = 0;
+static SCR_TL void (*scr_library_resets[SCR_LIB_MAX_RESETS])(void);
+static SCR_TL size_t scr_library_nresets = 0;
 
 void scr_library_register_reset(void (*fn)(void)) {
   for (size_t i = 0; i < scr_library_nresets; i++) {

package/src/scr_map.c

@@ -24,7 +24,7 @@
 /* Live heap-map 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_maps = 0;
+static SCR_TL long scr_live_maps = 0;
 long scr_map_live_count(void) { return scr_live_maps; }
 #endif
 

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

@@ -29,6 +29,24 @@ char *strcasestr(const char *hay, const char *needle);
 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 ──────────────────────────────────────────────────────────── */
 
 /* Called once at the top of main: private stdout formatter buffer,
@@ -445,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) */
 
@@ -1373,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) */
@@ -1976,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. */

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_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