@scriptc/runtime 0.0.15 → 0.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/runtime",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "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);
 }

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
@@ -5835,11 +5839,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;
 }