@scriptc/cli-darwin-x64 0.2.4 → 0.2.6

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

@@ -609,13 +609,13 @@ struct ScrNetSocket {
 };
 
 #ifdef SCR_RC_AUDIT
-static long scr_net_live = 0;
+static SCR_TL long scr_net_live = 0;
 long scr_net_live_count(void) { return scr_net_live; }
 #endif
 
-static ScrNetServer *scr_net_servers = NULL; /* registry: +1 each, tail-appended */
-static ScrNetSocket *scr_net_socks = NULL;
-static ScrPoller *scr_net_poller = NULL;
+static SCR_TL ScrNetServer *scr_net_servers = NULL; /* registry: +1 each, tail-appended */
+static SCR_TL ScrNetSocket *scr_net_socks = NULL;
+static SCR_TL ScrPoller *scr_net_poller = NULL;
 
 /* ── RC ──────────────────────────────────────────────────────────────── */
 
@@ -1649,7 +1649,7 @@ void scr_net_server_close_direct(ScrNetServer *s, ScrClosure *cb /*moves, nullab
     scr_net_ls_drop(&s->listening_cbs);
   }
   if (!s->closing) {
-    static size_t scr_net_close_seq = 0;
+    static SCR_TL size_t scr_net_close_seq = 0;
     s->close_seq = ++scr_net_close_seq;
   }
   s->closing = true; /* the sweep fires 'close' once nconns drains */
@@ -2222,6 +2222,7 @@ void scr_net_sock_write_str(ScrNetSocket *s, ScrStr *data /*borrowed*/) {
 }
 
 void scr_net_sock_write_bytes(ScrNetSocket *s, ScrBytes *data /*borrowed*/) {
+  SCR_BYTES_SNAPSHOT(data);
   scr_net_sock_write_raw(s, (const char *)data->data, (data->len * scr_bytes_elem_size(data->elem)));
 }
 
@@ -2430,6 +2431,7 @@ ScrBytes *scr_net_sock_read_bytes(ScrNetSocket *s, double n) {
  * buffer — every consumer (data listeners, an http parser, a TLS bio)
  * sees them before anything still in the kernel. */
 void scr_net_sock_unshift_bytes(ScrNetSocket *s, ScrBytes *data /*borrowed*/) {
+  SCR_BYTES_SNAPSHOT(data);
   if (data->len == 0) return;
   size_t avail = s->rlen - s->rhead;
   if (s->rhead >= data->len) {
@@ -2784,9 +2786,9 @@ void scr_net_server_get_native_conn(ScrNetServer *s, ScrNetNativeConnFn *fn, voi
  * pass after the work that flagged them — Node's later-than-the-handler
  * emits). Registered once by scr_http install-time code. */
 enum { SCR_NET_PROTO_SLOTS = 4 };
-static bool (*scr_net_proto_pendings[SCR_NET_PROTO_SLOTS])(void);
-static void (*scr_net_proto_sweeps[SCR_NET_PROTO_SLOTS])(void);
-static size_t scr_net_proto_n = 0;
+static SCR_TL bool (*scr_net_proto_pendings[SCR_NET_PROTO_SLOTS])(void);
+static SCR_TL void (*scr_net_proto_sweeps[SCR_NET_PROTO_SLOTS])(void);
+static SCR_TL size_t scr_net_proto_n = 0;
 
 /* ADDITIVE registration (each protocol unit — scr_http.c, scr_http2.c —
  * claims a slot at its install; both can co-link in one binary). */
@@ -3180,10 +3182,10 @@ static void scr_net_cleanup_atexit(void) {
 }
 
 void scr_net_install(void) {
-  static bool installed = false;
+  static SCR_TL bool installed = false;
   if (installed) return;
   installed = true;
-  atexit(scr_net_cleanup_atexit);
+  scr_atexit(scr_net_cleanup_atexit);
   scr_loop_set_net(&scr_net_pending, &scr_net_dispatch, &scr_net_pollfd);
 }
 
@@ -3204,7 +3206,7 @@ static void scr_net_dynh_unsupported(const char *member, const char *why) {
 /* The TLS-member hooks (scr_tls.c registers them when linked): TLSSocket
  * property reads, event names, and method names layer over the plain
  * socket dispatch without this unit naming that one's symbols. */
-static const ScrNetDynhTlsHooks *scr_net_dynh_tls = NULL;
+static SCR_TL const ScrNetDynhTlsHooks *scr_net_dynh_tls = NULL;
 void scr_net_set_dynh_tls(const ScrNetDynhTlsHooks *hooks) { scr_net_dynh_tls = hooks; }
 
 static bool scr_net_dynh_name_is(const ScrDyn *name, const char *lit) {
@@ -3457,7 +3459,7 @@ static const ScrDynHandleOps scr_net_dynh_sock_ops = {
  * at its dyn install — this unit cannot name http entry points without
  * breaking the link gate. */
 
-static bool (*scr_net_dynh_http_on)(ScrNetServer *s, const char *event, const ScrDyn *cb,
+static SCR_TL bool (*scr_net_dynh_http_on)(ScrNetServer *s, const char *event, const ScrDyn *cb,
                                     bool once);
 void scr_net_set_dynh_http_on(bool (*fn)(ScrNetServer *, const char *, const ScrDyn *, bool)) {
   scr_net_dynh_http_on = fn;

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

@@ -14,6 +14,7 @@
  * and the 1M-double fuzz gate (packages/runtime/test/gen-number-cases.mjs).
  */
 #include "scr_runtime.h"
+#include "scr_numeric.h"
 
 #include <math.h>
 #include <stdint.h>
@@ -27,10 +28,7 @@
 /* ECMA ToUint32, shared by bitwise operators and split's limit: non-finite
  * values become zero, finite values truncate toward zero and wrap mod 2^32. */
 uint32_t scr_to_uint32(double d) {
-  if (!isfinite(d)) return 0;
-  double t = fmod(trunc(d), 4294967296.0);
-  if (t < 0) t += 4294967296.0;
-  return (uint32_t)t;
+  return scr_numeric_to_u32(d);
 }
 
 /* ── bitwise operators ─────────────────────────────────────────────────
@@ -144,6 +142,40 @@ size_t scr_f64_to_str(double x, char *buf) {
     x = -x;
   }
 
+  /* Every integer through 2^53-1 has an unambiguous exact decimal spelling.
+   * Larger doubles keep the shortest-roundtrip algorithm: their rounded
+   * integer value can differ from JavaScript's chosen decimal digits. */
+  if (x <= 9007199254740991.0) {
+    uint64_t integer = (uint64_t)x;
+    if ((double)integer == x) {
+      static const char pairs[] =
+          "00010203040506070809" "10111213141516171819"
+          "20212223242526272829" "30313233343536373839"
+          "40414243444546474849" "50515253545556575859"
+          "60616263646566676869" "70717273747576777879"
+          "80818283848586878889" "90919293949596979899";
+      char digits[16];
+      char *begin = digits + sizeof digits;
+      while (integer >= 100) {
+        uint64_t quotient = integer / 100;
+        unsigned remainder = (unsigned)(integer - quotient * 100);
+        begin -= 2;
+        memcpy(begin, pairs + remainder * 2, 2);
+        integer = quotient;
+      }
+      if (integer < 10) *--begin = (char)('0' + integer);
+      else {
+        begin -= 2;
+        memcpy(begin, pairs + integer * 2, 2);
+      }
+      size_t count = (size_t)(digits + sizeof digits - begin);
+      memcpy(out, begin, count);
+      out += count;
+      *out = '\0';
+      return (size_t)(out - buf);
+    }
+  }
+
   char digits[18];
   int n;
   int k = scr_f64_digits(x, digits, &n);

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

@@ -0,0 +1,25 @@
+/* Internal numeric coercions shared by scalar operators and typed storage. */
+#ifndef SCR_NUMERIC_H
+#define SCR_NUMERIC_H
+#include <float.h>
+#include <stdint.h>
+#include <string.h>
+
+_Static_assert(sizeof(double) == sizeof(uint64_t) && DBL_MANT_DIG == 53 && DBL_MAX_EXP == 1024,
+               "numeric coercions require binary64 doubles");
+
+/* ToUint32 truncates toward zero and keeps the low 32 bits. Reading the
+ * binary64 exponent also handles non-finite values without floating modulo.
+ * Subnormals have magnitude below one; exponents >= 84 have no low bits. */
+static inline uint32_t scr_numeric_to_u32(double value) {
+  uint64_t bits;
+  memcpy(&bits, &value, sizeof bits);
+  unsigned exponent = (unsigned)((bits >> 52) & 0x7ff);
+  if (exponent < 1023 || exponent >= 1023 + 84) return 0;
+  unsigned shift = exponent - 1023;
+  uint64_t significand = (bits & UINT64_C(0x000fffffffffffff)) | UINT64_C(0x0010000000000000);
+  uint32_t integer = shift >= 52 ? (uint32_t)(significand << (shift - 52))
+                                : (uint32_t)(significand >> (52 - shift));
+  return bits >> 63 ? UINT32_C(0) - integer : integer;
+}
+#endif

package/dist/lib/runtime-sources/src/scr_numeric.test.c

@@ -0,0 +1,37 @@
+#include "scr_numeric.h"
+#include <assert.h>
+#include <math.h>
+#include <stdio.h>
+
+/* Independent arithmetic oracle: do not derive expectations from bit fields. */
+static uint32_t reference(double value) {
+  if (!isfinite(value)) return 0;
+  double residue = fmod(trunc(value), 4294967296.0);
+  if (residue < 0) residue += 4294967296.0;
+  return (uint32_t)residue;
+}
+
+static void check(uint64_t bits) {
+  double value;
+  memcpy(&value, &bits, sizeof value);
+  assert(scr_numeric_to_u32(value) == reference(value));
+}
+
+int main(void) {
+  uint64_t bits = UINT64_C(0x0123456789abcdef);
+  for (unsigned i = 0; i < 2000000; i++) {
+    bits ^= bits << 13;
+    bits ^= bits >> 7;
+    bits ^= bits << 17;
+    check(bits);
+  }
+  /* Both signs at every exponent, including non-finite and subnormal values. */
+  for (unsigned exponent = 0; exponent < 2048; exponent++) {
+    for (unsigned sign = 0; sign < 2; sign++) {
+      for (unsigned low = 0; low < 64; low++) {
+        check(((uint64_t)sign << 63) | ((uint64_t)exponent << 52) | low);
+      }
+    }
+  }
+  puts("numeric coercions passed");
+}

package/dist/lib/runtime-sources/src/scr_numeric.test.ts

@@ -0,0 +1,33 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { expect, test } from "vitest";
+
+const exec = promisify(execFile);
+
+test("integer coercion matches modular truncation across binary64 encodings", async () => {
+  const scratch = await mkdtemp(join(tmpdir(), "scriptc-numeric-"));
+  try {
+    const binary = join(scratch, "numeric");
+    await exec("clang", [
+      "-std=c11",
+      "-O2",
+      "-Wall",
+      "-Wextra",
+      "-fsanitize=address,undefined",
+      join(import.meta.dirname, "scr_numeric.test.c"),
+      "-o",
+      binary,
+      ...(process.platform === "linux" ? ["-lm"] : []),
+    ]);
+    const result = await exec(binary, [], {
+      env: { ...process.env, UBSAN_OPTIONS: "halt_on_error=1" },
+    });
+    expect(result.stdout).toBe("numeric coercions passed\n");
+    expect(result.stderr).toBe("");
+  } finally {
+    await rm(scratch, { recursive: true, force: true });
+  }
+});

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

@@ -32,14 +32,19 @@ ScrClassObj *scr_classobj_new(const ScrClassObj *template, size_t ncaps) {
   return c;
 }
 
+static void scr_classobj_destroy(void *object) {
+  ScrClassObj *c = object;
+  for (size_t i = 0; i < c->ncaps; i++) scr_box_release(c->caps[i]);
+  scr_box_release(c->prototype_data);
+  scr_box_release(c->static_data);
+  scr_classobj_gcfree(c);
+}
+
 void scr_classobj_release(ScrClassObj *c) {
   if (!c || c->rc == SIZE_MAX) return;
   if (--c->rc == 0) {
     scr_cyc_on_dead(c);
-    for (size_t i = 0; i < c->ncaps; i++) scr_box_release(c->caps[i]);
-    scr_box_release(c->prototype_data);
-    scr_box_release(c->static_data);
-    scr_classobj_gcfree(c);
+    scr_rc_destroy(c, scr_classobj_destroy);
   } else {
     scr_cyc_on_release(c);
   }

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

@@ -845,7 +845,7 @@ ScrStr *scr_path_win32_resolve(ScrArr *parts) {
        * the resolved drive. resolvedDevice is always a 2-byte drive here
        * (UNC devices are absolute and broke out of the loop). */
       char name[4] = {'=', dev.data[0], dev.data[1], 0};
-      const char *dcwd = getenv(name);
+      const char *dcwd = scr_getenv(name);
       if (dcwd && *dcwd) pb_append(&pathb, dcwd, strlen(dcwd));
       else scr_path_cwd(&pathb);
       if (!(pathb.len >= 2 && scr_path_w32_ieq(pathb.data, dev.data, 2)) &&

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

@@ -48,12 +48,12 @@ typedef struct ScrRl {
   struct ScrRl *next;
 } ScrRl;
 
-static ScrRl *scr_rls = NULL;
-static double scr_rl_next_id = 1;
-static size_t scr_rl_open = 0;        /* un-closed, un-dead interfaces */
-static ScrClosure *scr_rl_data_cb = NULL; /* the shared consumer (borrowed
+static SCR_TL ScrRl *scr_rls = NULL;
+static SCR_TL double scr_rl_next_id = 1;
+static SCR_TL size_t scr_rl_open = 0;        /* un-closed, un-dead interfaces */
+static SCR_TL ScrClosure *scr_rl_data_cb = NULL; /* the shared consumer (borrowed
                                             * mirror; the registry owns) */
-static bool scr_rl_end_registered = false;
+static SCR_TL bool scr_rl_end_registered = false;
 
 static ScrRl *scr_rl_find(double id) {
   for (ScrRl *rl = scr_rls; rl; rl = rl->next) {
@@ -146,7 +146,7 @@ static void scr_rl_data_adapter(ScrClosure *cb, ScrBytes *chunk) {
       rl->buf = realloc(rl->buf, rl->cap);
       if (!rl->buf) scr_rl_oom();
     }
-    memcpy(rl->buf + rl->len, chunk->data, chunk->len);
+    scr_bytes_read(chunk, 0, rl->buf + rl->len, chunk->len);
     rl->len += chunk->len;
     scr_rl_drain(rl);
     if (scr_exc_pending()) return;
@@ -197,10 +197,10 @@ static void scr_rl_cleanup_atexit(void) {
 }
 
 double scr_rl_create(void) {
-  static bool cleanup_registered = false;
+  static SCR_TL bool cleanup_registered = false;
   if (!cleanup_registered) {
     cleanup_registered = true;
-    atexit(scr_rl_cleanup_atexit);
+    scr_atexit(scr_rl_cleanup_atexit);
   }
   ScrRl *rl = calloc(1, sizeof *rl);
   if (!rl) scr_rl_oom();