@scriptc/runtime 0.0.15 → 0.0.17

package/package.json

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

package/src/scr_bytes_io.c

@@ -154,13 +154,12 @@ ScrBytes *scr_crypto_random_bytes(double n) {
 /* ── process.stdout/stderr.write(buf) ──────────────────────────────────── */
 
 bool scr_process_stdout_write_bytes(const ScrBytes *b) {
-  fwrite(b->data, 1, b->len * scr_bytes_elem_size(b->elem), stdout);
+  scr_stdio_write(1, b->data, b->len * scr_bytes_elem_size(b->elem));
   return true;
 }
 
 bool scr_process_stderr_write_bytes(const ScrBytes *b) {
-  fflush(stdout); /* merged 2>&1 output keeps source order (scr_lib.c) */
-  fwrite(b->data, 1, b->len * scr_bytes_elem_size(b->elem), stderr);
+  scr_stdio_write(2, b->data, b->len * scr_bytes_elem_size(b->elem));
   return true;
 }
 

package/src/scr_console.c

@@ -83,8 +83,11 @@ void scr_init(void) {
   _setmode(_fileno(stderr), _O_BINARY);
   _setmode(_fileno(stdin), _O_BINARY);
 #endif
-  /* Full buffering matches Node writing to a pipe (the differential harness
-   * never runs either side on a TTY) and makes output-heavy programs fast. */
+  /* A private formatting buffer coalesces the several stdio calls needed to
+   * render one console line. Every JavaScript-visible stdout write flushes
+   * before returning, so this buffer is never observable as delayed output:
+   * Node hands each console.log/process.stdout.write chunk to its backing
+   * stream immediately. */
   static char outbuf[1 << 16];
   setvbuf(stdout, outbuf, _IOFBF, sizeof outbuf);
   /* atexit is LIFO; registration order makes exit run: library cleanup
@@ -131,18 +134,36 @@ static void scr_console_write(FILE *out, size_t n, const ScrLogArg *args) {
     }
   }
   fputc('\n', out);
+  /* Console methods submit one formatted chunk to their backing stream.
+   * Keep the C buffer only as a formatter coalescing detail: a caller
+   * observing a live child must see this line before the next JS turn. */
+  fflush(out);
 }
 
 void scr_console_log(size_t n, const ScrLogArg *args) {
   scr_console_write(stdout, n, args);
 }
 
-/* console.error and console.warn. stderr is UNBUFFERED (C's default; Node
- * writes stderr synchronously too), and stdout FLUSHES first so a merged
- * redirection (2>&1) sees writes in source order despite stdout's full
- * buffering — Node's piped stdout/stderr preserve write order the same
- * way. */
+/* console.error and console.warn. Flush stdout first so runtime-internal
+ * output that is still being assembled cannot cross this stderr line under
+ * a merged redirection (2>&1); JavaScript-visible stdout writes have already
+ * flushed themselves. */
 void scr_console_error(size_t n, const ScrLogArg *args) {
   fflush(stdout);
   scr_console_write(stderr, n, args);
 }
+
+/* One JavaScript-visible raw write. Node's global console and process stream
+ * methods hand each chunk to the backing stream when called; they do not
+ * retain stdout until a later stderr write, a 64 KiB threshold, or process
+ * exit. The runtime remains synchronous internally, so its backpressure
+ * surface is still constantly true, but the bytes are observable promptly.
+ *
+ * stderr flushes any runtime-internal stdout fragment first to preserve the
+ * existing merged-fd ordering convention. */
+void scr_stdio_write(int fd, const void *data, size_t len) {
+  FILE *out = fd == 2 ? stderr : stdout;
+  if (fd == 2) fflush(stdout);
+  if (len > 0) fwrite(data, 1, len, out);
+  fflush(out);
+}

package/src/scr_exception.c

@@ -307,8 +307,8 @@ int scr_exit_code_hint_get(void) { return scr_exit_code_hint; }
 
 void scr_exc_print_uncaught(void) {
   scr_exit_code_note(1);
-  /* Pre-throw stdout must land before the stderr line when both share a
-   * terminal; stdout is fully buffered (scr_init). */
+  /* Settle any runtime-internal stdout fragment before the stderr line when
+   * both share an fd. JavaScript-visible writes already flush themselves. */
   fflush(stdout);
   fputs("Uncaught ", stderr);
   switch (scr_exc_kind) {

package/src/scr_island.c

@@ -2682,7 +2682,7 @@ static JSValue isl_host_write(JSContext *ctx, JSValueConst this_val, int argc,
   size_t len;
   const char *s = JS_ToCStringLen(ctx, &len, argv[1]);
   if (!s) return JS_EXCEPTION;
-  fwrite(s, 1, len, fd == 2 ? stderr : stdout);
+  scr_stdio_write(fd, s, len);
   JS_FreeCString(ctx, s);
   return JS_TRUE;
 }

package/src/scr_lib.c

@@ -584,21 +584,18 @@ ScrStr *scr_process_cwd(void) {
   return scr_str_new(buf, strlen(buf));
 }
 
-/* The raw byte writes. stdout goes through the SAME stdio stream and
- * buffer console.log uses (scr_init's setvbuf), so interleaved writes
- * keep source order; stderr is unbuffered, like Node's, and FLUSHES
- * stdout first (the console.error convention) so merged 2>&1 output
- * keeps source order despite stdout's full buffering. The boolean is
- * Node's backpressure signal — a synchronous fwrite has no backpressure,
- * so it is constantly true. */
+/* The raw byte writes use the SAME stdio stream as console, and each call
+ * flushes before returning so live consumers see Node's source order without
+ * an observable C buffering delay. The boolean is Node's backpressure signal
+ * — this synchronous runtime has no queued backpressure, so it is constantly
+ * true. */
 bool scr_process_stdout_write(const ScrStr *data) {
-  fwrite(data->data, 1, data->len, stdout);
+  scr_stdio_write(1, data->data, data->len);
   return true;
 }
 
 bool scr_process_stderr_write(const ScrStr *data) {
-  fflush(stdout);
-  fwrite(data->data, 1, data->len, stderr);
+  scr_stdio_write(2, data->data, data->len);
   return true;
 }
 
@@ -606,7 +603,7 @@ bool scr_process_stderr_write(const ScrStr *data) {
  * WritableStream-typed value — the prefixStream idiom): the value is the
  * stream's fd (1 or 2, minted by the process.stdout/stderr reads), and
  * the write dispatches onto the exact stdout/stderr paths above so
- * buffering and ordering stay identical. */
+ * prompt submission and ordering stay identical. */
 bool scr_proc_stream_write(double fd, const ScrStr *data) {
   return (int)fd == 2 ? scr_process_stderr_write(data) : scr_process_stdout_write(data);
 }
@@ -3506,6 +3503,170 @@ ScrStr *scr_num_to_fixed0(double x) {
   return r;
 }
 
+/* The explicit-fraction-digits toFixed needs the exact binary value, not
+ * the shortest decimal that round-trips to it: (1.005).toFixed(2) is
+ * "1.00", for example. Represent abs(x) * 10^f as
+ *
+ *     mantissa * 5^f * 2^(binary_exponent + f)
+ *
+ * in a tiny base-2^32 integer, then shift right with the spec's
+ * round-half-up rule. The largest value handled here is below 1e21 with
+ * f=100, so the rounded integer is below 1e121 (402 bits); sixteen limbs
+ * leave comfortable headroom without heap allocation. */
+#define SCR_FIXED_LIMBS 16
+typedef struct {
+  uint32_t limb[SCR_FIXED_LIMBS]; /* little-endian */
+  int len;
+} ScrFixedInt;
+
+static void scr_fixed_normalize(ScrFixedInt *v) {
+  while (v->len > 1 && v->limb[v->len - 1] == 0) v->len--;
+}
+
+static void scr_fixed_mul5(ScrFixedInt *v) {
+  uint64_t carry = 0;
+  for (int i = 0; i < v->len; i++) {
+    uint64_t p = (uint64_t)v->limb[i] * 5 + carry;
+    v->limb[i] = (uint32_t)p;
+    carry = p >> 32;
+  }
+  if (carry != 0) v->limb[v->len++] = (uint32_t)carry;
+}
+
+static bool scr_fixed_bit(const ScrFixedInt *v, int bit) {
+  int word = bit / 32;
+  return word < v->len && ((v->limb[word] >> (bit % 32)) & 1u) != 0;
+}
+
+static void scr_fixed_shr(ScrFixedInt *v, int bits) {
+  int words = bits / 32;
+  int rem = bits % 32;
+  if (words >= v->len) {
+    v->limb[0] = 0;
+    v->len = 1;
+    return;
+  }
+  int n = v->len - words;
+  for (int i = 0; i < n; i++) {
+    uint32_t lo = v->limb[i + words] >> rem;
+    uint32_t hi =
+        rem != 0 && i + words + 1 < v->len
+            ? v->limb[i + words + 1] << (32 - rem)
+            : 0;
+    v->limb[i] = lo | hi;
+  }
+  v->len = n;
+  scr_fixed_normalize(v);
+}
+
+static void scr_fixed_shl(ScrFixedInt *v, int bits) {
+  uint32_t out[SCR_FIXED_LIMBS] = {0};
+  int words = bits / 32;
+  int rem = bits % 32;
+  for (int i = 0; i < v->len; i++) {
+    int at = i + words;
+    out[at] |= v->limb[i] << rem;
+    if (rem != 0) out[at + 1] |= v->limb[i] >> (32 - rem);
+  }
+  int n = v->len + words + (rem != 0 ? 1 : 0);
+  memcpy(v->limb, out, sizeof out);
+  v->len = n;
+  scr_fixed_normalize(v);
+}
+
+static void scr_fixed_inc(ScrFixedInt *v) {
+  uint64_t carry = 1;
+  for (int i = 0; i < v->len && carry != 0; i++) {
+    uint64_t s = (uint64_t)v->limb[i] + carry;
+    v->limb[i] = (uint32_t)s;
+    carry = s >> 32;
+  }
+  if (carry != 0) v->limb[v->len++] = (uint32_t)carry;
+}
+
+/* Divide in place by 1e9; each quotient limb still fits uint32_t because
+ * the carried remainder is below the divisor. Returns the remainder. */
+static uint32_t scr_fixed_div1e9(ScrFixedInt *v) {
+  uint64_t rem = 0;
+  for (int i = v->len - 1; i >= 0; i--) {
+    uint64_t cur = (rem << 32) | v->limb[i];
+    v->limb[i] = (uint32_t)(cur / 1000000000u);
+    rem = cur % 1000000000u;
+  }
+  scr_fixed_normalize(v);
+  return (uint32_t)rem;
+}
+
+/* Number.prototype.toFixed(fractionDigits), with the argument already
+ * number-typed by the frontend. ToIntegerOrInfinity validation precedes
+ * the receiver's non-finite arm, as ECMA-262 requires. Invalid precision
+ * raises V8's catchable RangeError text; otherwise the result is +1. */
+ScrStr *scr_num_to_fixed(double x, double fraction_digits) {
+  double fd = isnan(fraction_digits) ? 0 : trunc(fraction_digits);
+  if (!(fd >= 0 && fd <= 100)) {
+    static const char msg[] =
+        "toFixed() digits argument must be between 0 and 100";
+    scr_throw_error_msg(SCR_ERR_RANGE, msg, sizeof msg - 1);
+    return NULL;
+  }
+  int f = (int)fd;
+  if (!isfinite(x) || fabs(x) >= 1e21) return scr_f64_to_scrstr(x);
+
+  bool neg = x < 0; /* false for -0, exactly like the spec's sign arm */
+  double a = neg ? -x : x;
+  uint64_t bits;
+  memcpy(&bits, &a, sizeof bits);
+  uint64_t mantissa = bits & ((1ull << 52) - 1);
+  int ieee_exp = (int)((bits >> 52) & 0x7ffu);
+  int binary_exp;
+  if (ieee_exp == 0) {
+    binary_exp = -1074;
+  } else {
+    mantissa |= 1ull << 52;
+    binary_exp = ieee_exp - 1023 - 52;
+  }
+
+  ScrFixedInt n = {{(uint32_t)mantissa, (uint32_t)(mantissa >> 32)}, 2};
+  scr_fixed_normalize(&n);
+  for (int i = 0; i < f; i++) scr_fixed_mul5(&n);
+  int shift = binary_exp + f;
+  if (shift >= 0) {
+    scr_fixed_shl(&n, shift);
+  } else {
+    int right = -shift;
+    bool round_up = scr_fixed_bit(&n, right - 1);
+    scr_fixed_shr(&n, right);
+    if (round_up) scr_fixed_inc(&n);
+  }
+
+  /* Render the exact rounded integer through base-1e9 chunks, then place
+   * the decimal point f digits from the right (padding through zero). */
+  uint32_t chunks[SCR_FIXED_LIMBS];
+  int chunk_count = 0;
+  do {
+    chunks[chunk_count++] = scr_fixed_div1e9(&n);
+  } while (!(n.len == 1 && n.limb[0] == 0));
+
+  char digits[128];
+  int dlen = snprintf(digits, sizeof digits, "%u", chunks[chunk_count - 1]);
+  for (int i = chunk_count - 2; i >= 0; i--) {
+    dlen += snprintf(digits + dlen, sizeof digits - (size_t)dlen,
+                     "%09u", chunks[i]);
+  }
+
+  char out[128];
+  int o = 0;
+  if (neg) out[o++] = '-';
+  int padded = dlen > f + 1 ? dlen : f + 1;
+  int integer_digits = padded - f;
+  int leading_zeros = padded - dlen;
+  for (int i = 0; i < padded; i++) {
+    if (f != 0 && i == integer_digits) out[o++] = '.';
+    out[o++] = i < leading_zeros ? '0' : digits[i - leading_zeros];
+  }
+  return scr_str_new(out, (size_t)o);
+}
+
 /* Increment a decimal digit string in place. Returns true on overflow —
  * the value becomes 1 followed by len zeros (the caller folds the zeros
  * into its scale); an EMPTY string increments to "1" the same way (the

package/src/scr_readline.c

@@ -235,9 +235,10 @@ void scr_rl_question(double id, const ScrStr *query, ScrClosure *cb /*moves*/,
     scr_throw_error_msg(SCR_ERR_ERROR, "readline was closed", 19);
     return;
   }
-  /* The prompt writes to stdout under pipes too (Node's question does);
-   * same stream and buffer as console.log, so ordering holds. */
-  fwrite(query->data, 1, query->len, stdout);
+  /* The prompt writes to stdout under pipes too (Node's question does), and
+   * must be visible before input arrives even though it has no trailing
+   * newline. */
+  scr_stdio_write(1, query->data, query->len);
   if (rl->dead) {
     /* Created after stdin ended: pinned against Node — the prompt still
      * writes, but the DESTROYED stream delivers nothing and 'close'

package/src/scr_runtime.h

@@ -35,8 +35,9 @@ char *strcasestr(const char *hay, const char *needle);
 
 /* ── process ──────────────────────────────────────────────────────────── */
 
-/* Called once at the top of main: stdout buffering to match piped Node,
- * flush-at-exit, RC audit registration (when built with -DSCR_RC_AUDIT). */
+/* Called once at the top of main: private stdout formatter buffer,
+ * flush-at-exit, RC audit registration (when built with -DSCR_RC_AUDIT).
+ * JavaScript-visible writes flush before returning. */
 void scr_init(void);
 
 /* ── the trap funnel (scr_console.c; scr_library.c under -DSCR_LIB) ──────
@@ -1840,10 +1841,13 @@ int scr_lib_arg_count(void);
 const char *scr_lib_arg(int i);
 ScrStr *scr_process_platform(void); /* +1 interned ("darwin", "linux", ...) */
 ScrStr *scr_process_cwd(void);      /* +1 fresh (getcwd) */
-/* process.stdout/.stderr .write — the raw byte writes (no newline, no
- * formatting; data borrowed). stdout shares console.log's stream+buffer
- * (ordering preserved); stderr is unbuffered like Node's. Constantly true
- * (Node's backpressure boolean never fires on synchronous writes). */
+/* Submit one raw chunk to fd 1/2 and flush it before returning. Used by all
+ * JavaScript-visible console/process/readline/island output paths so the
+ * internal stdio formatting buffer never delays live output. */
+void scr_stdio_write(int fd, const void *data, size_t len);
+/* process.stdout/.stderr .write — raw bytes (no newline or formatting; data
+ * borrowed), promptly visible and ordered with console output. Constantly
+ * true (the synchronous runtime never queues backpressure). */
 bool scr_process_stdout_write(const ScrStr *data);
 bool scr_process_stderr_write(const ScrStr *data);
 /* The first-class WritableStream write: fd is the stream value itself
@@ -4239,12 +4243,14 @@ bool scr_num_is_finite(double x);
 bool scr_num_is_nan(double x);
 bool scr_num_is_integer(double x);
 bool scr_num_is_safe_integer(double x);
-/* The fraction-digits-free Number.prototype formatters: toExponential()
- * (shortest correctly-rounded mantissa, "7e+0" exponent shape) and
- * toFixed() (closest integer, ties toward +∞ on the magnitude, "-0" for
- * negative fractions, ToString at |x| ≥ 1e21). +1 results; never throw. */
+/* Number.prototype formatters: toExponential() is the fraction-digits-free
+ * shortest correctly-rounded mantissa; toFixed0 is the non-throwing omitted
+ * argument form. toFixed implements an explicit 0..100 fractionDigits with
+ * exact binary-value rounding and THROWS V8's catchable RangeError outside
+ * that range. All successful results are +1. */
 ScrStr *scr_num_to_exponential(double x);
 ScrStr *scr_num_to_fixed0(double x);
+ScrStr *scr_num_to_fixed(double x, double fraction_digits);
 
 /* Object.is over two numbers — the spec's SameValue on doubles: NaN
  * equals NaN, +0 differs from -0, everything else is ==. Never throws. */
@@ -5835,11 +5841,11 @@ typedef struct {
   } v;
 } ScrLogArg;
 
-/* Space-joined args + '\n', single buffered write. Borrows string args. */
+/* Space-joined args + '\n', submitted before return. Borrows string args. */
 void scr_console_log(size_t n, const ScrLogArg *args);
 /* The stderr twin (console.error AND console.warn — one stream in Node):
- * identical formatting, unbuffered stderr, stdout flushed first so merged
- * (2>&1) output keeps source order. */
+ * identical formatting, with stdout settled first so merged (2>&1) output
+ * keeps source order. */
 void scr_console_error(size_t n, const ScrLogArg *args);
 
 #endif /* SCR_RUNTIME_H */

package/src/scr_web.c

@@ -1739,7 +1739,7 @@ static JSValue web_host_write(JSContext *ctx, JSValueConst this_val, int argc,
   size_t len;
   const char *s = JS_ToCStringLen(ctx, &len, argv[1]);
   if (!s) return JS_EXCEPTION;
-  fwrite(s, 1, len, fd == 2 ? stderr : stdout);
+  scr_stdio_write(fd, s, len);
   JS_FreeCString(ctx, s);
   return JS_UNDEFINED;
 }