@scriptc/runtime 0.0.23 → 0.0.25

package/package.json

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

package/src/scr_array.c

@@ -68,6 +68,16 @@ static void scr_elem_release(const ScrArr *a, uint64_t slot) {
   else if (a->elem == SCR_ELEM_REF) a->elem_release(p);
 }
 
+static uint64_t scr_elem_retain_slot(const ScrArr *a, uint64_t slot) {
+  if (!scr_elem_is_ref(a->elem)) return slot;
+  void *p = scr_slot_to_ptr(slot);
+  if (a->elem == SCR_ELEM_STR) p = scr_str_retain((ScrStr *)p);
+  else if (a->elem == SCR_ELEM_ARR) p = scr_arr_retain((ScrArr *)p);
+  else if (a->elem == SCR_ELEM_BYTES) p = scr_bytes_retain((ScrBytes *)p);
+  else p = a->elem_retain(p);
+  return scr_slot_from_ptr(p);
+}
+
 /* ── lifecycle ─────────────────────────────────────────────────────────── */
 
 static void scr_arr_grow(ScrArr *a, size_t need) {
@@ -259,6 +269,61 @@ double scr_arr_push_ref(ScrArr *a, void *v) {
   return scr_arr_push_slot(a, scr_slot_from_ptr(v));
 }
 
+/* ── unshift / reverse ──────────────────────────────────────────────────
+ * Single-element unshift takes ownership, matching push. The emitter calls
+ * it from right to left after evaluating every variadic argument, preserving
+ * JS argument order without a temporary array. The spread form borrows and
+ * retains its source, snapshots the count, and handles self-spread after the
+ * tail move by reading the relocated original block. */
+static double scr_arr_unshift_slot(ScrArr *a, uint64_t slot) {
+  scr_arr_grow(a, a->len + 1);
+  memmove(a->data + 1, a->data, a->len * sizeof(uint64_t));
+  a->data[0] = slot;
+  a->len++;
+  return (double)a->len;
+}
+
+double scr_arr_unshift_f64(ScrArr *a, double v) {
+  return scr_arr_unshift_slot(a, scr_slot_from_f64(v));
+}
+
+double scr_arr_unshift_bool(ScrArr *a, bool v) {
+  return scr_arr_unshift_slot(a, (uint64_t)(v ? 1 : 0));
+}
+
+double scr_arr_unshift_ref(ScrArr *a, void *v) {
+  return scr_arr_unshift_slot(a, scr_slot_from_ptr(v));
+}
+
+double scr_arr_unshift_spread(ScrArr *a, const ScrArr *src) {
+  size_t old_len = a->len;
+  size_t add = src->len;
+  if (add == 0) return (double)old_len;
+  if (add > SIZE_MAX - old_len) scr_arr_oom();
+  scr_arr_grow(a, old_len + add);
+  memmove(a->data + add, a->data, old_len * sizeof(uint64_t));
+  if (src == a) {
+    for (size_t i = 0; i < add; i++) {
+      a->data[i] = scr_elem_retain_slot(a, a->data[add + i]);
+    }
+  } else {
+    for (size_t i = 0; i < add; i++) {
+      a->data[i] = scr_elem_retain_slot(src, src->data[i]);
+    }
+  }
+  a->len = old_len + add;
+  return (double)a->len;
+}
+
+ScrArr *scr_arr_reverse(ScrArr *a) {
+  for (size_t i = 0; i < a->len / 2; i++) {
+    uint64_t tmp = a->data[i];
+    a->data[i] = a->data[a->len - 1 - i];
+    a->data[a->len - 1 - i] = tmp;
+  }
+  return scr_arr_retain(a);
+}
+
 static uint64_t scr_arr_pop_slot(ScrArr *a) {
   if (a->len == 0) {
     scr_trap("scriptc: RangeError: pop() on an empty array\n");

package/src/scr_async.c

@@ -39,6 +39,7 @@
 #include <windows.h>
 #else
 #include <poll.h>
+#include <pthread.h>
 #include <signal.h>
 #include <ucontext.h>
 #include <unistd.h>
@@ -627,8 +628,9 @@ ScrArr *scr_active_resources(void) {
  * left queued on the uncaught paths) never run — the teardown releases
  * them, like Node dropping the queue at exit. */
 typedef struct ScrNtick {
-  ScrClosure *cb;    /* owned; NULL for a raw C-hook entry */
-  void (*raw)(void); /* the hook when cb == NULL (stream tick markers) */
+  ScrClosure *cb;             /* owned; NULL for a raw C-hook entry */
+  ScrFsRenameFn error_cb;     /* process-write success adapter, or NULL */
+  void (*raw)(void);          /* hook when cb == NULL (stream markers) */
   struct ScrNtick *next;
 } ScrNtick;
 
@@ -649,6 +651,20 @@ void scr_next_tick(ScrClosure *cb /*moves*/) {
   scr_nt_tail = t;
 }
 
+/* stdout/stderr write completions are Node nextTicks too, but their
+ * callback receives the success `null` argument. Reuse the error-first
+ * adapter ABI also used by fs.rename: emitted adapters construct the
+ * program's Error | null union, and NULL selects its null arm. */
+void scr_process_write_callback(ScrClosure *cb /*moves*/, ScrFsRenameFn fn) {
+  ScrNtick *t = calloc(1, sizeof *t);
+  if (!t) scr_oom();
+  t->cb = cb;
+  t->error_cb = fn;
+  if (scr_nt_tail) scr_nt_tail->next = t;
+  else scr_nt_head = t;
+  scr_nt_tail = t;
+}
+
 /* A RAW C-hook tick: the stream unit enqueues one marker per deferred
  * stream emission so those emissions interleave with user nextTicks in
  * true FIFO order — in Node they ARE nextTicks (resume_, emitReadable_,
@@ -1441,6 +1457,11 @@ ScrPromise *scr_fsp_write_file(ScrStr *path, ScrStr *data) {
   return scr_promise_settled_void();
 }
 
+ScrPromise *scr_fsp_write_file_mode(ScrStr *path, ScrStr *data, double mode) {
+  scr_fs_write_file_mode(path, data, mode);
+  return scr_promise_settled_void();
+}
+
 ScrPromise *scr_fsp_mkdir(ScrStr *path) {
   scr_fs_mkdir(path);
   return scr_promise_settled_void();
@@ -1486,6 +1507,248 @@ ScrPromise *scr_fsp_stat(ScrStr *path) {
   return scr_promise_settled_ref(st, &scr_stats_retain_v, &scr_stats_release_v, NULL);
 }
 
+ScrPromise *scr_fsp_rename(ScrStr *oldpath, ScrStr *newpath) {
+  scr_fs_rename(oldpath, newpath);
+  return scr_promise_settled_void();
+}
+
+/* fs.rename(old, new, cb): the static callback surface. The OS operation
+ * starts immediately on a native worker, matching libuv's key contract:
+ * while JS/main is synchronously occupied, the filesystem request can still
+ * make progress. Only immutable path bytes cross onto the worker. Error
+ * construction, callback invocation, and every RC mutation stay on the main
+ * runtime thread when a later loop turn observes completion.
+ *
+ * A compact operation queue is also the liveness handle: an outstanding
+ * callback-style request keeps the loop alive. Four persistent workers mirror
+ * libuv's default filesystem concurrency without creating one OS thread per
+ * request. A platform mutex publishes each result and the syscall's filesystem
+ * effects before the loop removes it from the completion queue. */
+#ifndef SCR_LIB
+typedef struct ScrFsRenameOp {
+  ScrStr *oldpath;
+  ScrStr *newpath;
+  ScrClosure *cb;
+  ScrFsRenameFn fn;
+  int error;
+  struct ScrFsRenameOp *next;
+} ScrFsRenameOp;
+
+static ScrFsRenameOp *scr_fs_rename_work = NULL;
+static ScrFsRenameOp **scr_fs_rename_work_tail = &scr_fs_rename_work;
+static ScrFsRenameOp *scr_fs_rename_done = NULL;
+static ScrFsRenameOp **scr_fs_rename_done_tail = &scr_fs_rename_done;
+static size_t scr_fs_rename_pending_count = 0;
+static size_t scr_fs_rename_worker_count = 0;
+static bool scr_fs_rename_stopping = false;
+static bool scr_fs_rename_shutdown_registered = false;
+
+#ifdef _WIN32
+static HANDLE scr_fs_rename_workers[4];
+static SRWLOCK scr_fs_rename_lock = SRWLOCK_INIT;
+static CONDITION_VARIABLE scr_fs_rename_cond = CONDITION_VARIABLE_INIT;
+static void scr_fs_rename_lock_enter(void) { AcquireSRWLockExclusive(&scr_fs_rename_lock); }
+static void scr_fs_rename_lock_leave(void) { ReleaseSRWLockExclusive(&scr_fs_rename_lock); }
+static void scr_fs_rename_wait(void) {
+  (void)SleepConditionVariableSRW(&scr_fs_rename_cond, &scr_fs_rename_lock, INFINITE, 0);
+}
+static void scr_fs_rename_signal(void) { WakeConditionVariable(&scr_fs_rename_cond); }
+static void scr_fs_rename_broadcast(void) { WakeAllConditionVariable(&scr_fs_rename_cond); }
+#else
+static pthread_t scr_fs_rename_workers[4];
+static pthread_mutex_t scr_fs_rename_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t scr_fs_rename_cond = PTHREAD_COND_INITIALIZER;
+static void scr_fs_rename_lock_enter(void) { (void)pthread_mutex_lock(&scr_fs_rename_lock); }
+static void scr_fs_rename_lock_leave(void) { (void)pthread_mutex_unlock(&scr_fs_rename_lock); }
+static void scr_fs_rename_wait(void) {
+  (void)pthread_cond_wait(&scr_fs_rename_cond, &scr_fs_rename_lock);
+}
+static void scr_fs_rename_signal(void) { (void)pthread_cond_signal(&scr_fs_rename_cond); }
+static void scr_fs_rename_broadcast(void) { (void)pthread_cond_broadcast(&scr_fs_rename_cond); }
+#endif
+
+static void scr_fs_rename_op_release(ScrFsRenameOp *op) {
+  scr_str_release(op->oldpath);
+  scr_str_release(op->newpath);
+  scr_closure_release(op->cb);
+  free(op);
+}
+
+static void scr_fs_rename_worker_loop(void) {
+  for (;;) {
+    scr_fs_rename_lock_enter();
+    while (scr_fs_rename_work == NULL && !scr_fs_rename_stopping) scr_fs_rename_wait();
+    if (scr_fs_rename_stopping) {
+      scr_fs_rename_lock_leave();
+      return;
+    }
+    ScrFsRenameOp *op = scr_fs_rename_work;
+    scr_fs_rename_work = op->next;
+    if (scr_fs_rename_work == NULL) scr_fs_rename_work_tail = &scr_fs_rename_work;
+    scr_fs_rename_lock_leave();
+
+    op->error = scr_fs_rename_raw(op->oldpath, op->newpath);
+
+    scr_fs_rename_lock_enter();
+    op->next = NULL;
+    *scr_fs_rename_done_tail = op;
+    scr_fs_rename_done_tail = &op->next;
+    scr_fs_rename_lock_leave();
+  }
+}
+
+#ifdef _WIN32
+static DWORD WINAPI scr_fs_rename_worker(LPVOID payload) {
+  (void)payload;
+  scr_fs_rename_worker_loop();
+  return 0;
+}
+#else
+static void *scr_fs_rename_worker(void *payload) {
+  (void)payload;
+  scr_fs_rename_worker_loop();
+  return NULL;
+}
+#endif
+
+/* Runs before the ordinary runtime atexit cleanup/audit (it is registered
+ * lazily by the first rename request, after scr_init/scr_lib_init). Fatal
+ * top-level or callback exceptions can stop the loop with requests still in
+ * flight; join the workers before releasing their retained path/callback
+ * payloads so sanitized builds keep the program's real exit verdict. */
+static void scr_fs_renames_shutdown(void) {
+  scr_fs_rename_lock_enter();
+  scr_fs_rename_stopping = true;
+  scr_fs_rename_broadcast();
+  scr_fs_rename_lock_leave();
+
+  for (size_t i = 0; i < scr_fs_rename_worker_count; i++) {
+#ifdef _WIN32
+    (void)WaitForSingleObject(scr_fs_rename_workers[i], INFINITE);
+    CloseHandle(scr_fs_rename_workers[i]);
+#else
+    (void)pthread_join(scr_fs_rename_workers[i], NULL);
+#endif
+  }
+
+  scr_fs_rename_lock_enter();
+  ScrFsRenameOp *work = scr_fs_rename_work;
+  ScrFsRenameOp *done = scr_fs_rename_done;
+  scr_fs_rename_work = NULL;
+  scr_fs_rename_work_tail = &scr_fs_rename_work;
+  scr_fs_rename_done = NULL;
+  scr_fs_rename_done_tail = &scr_fs_rename_done;
+  scr_fs_rename_pending_count = 0;
+  scr_fs_rename_lock_leave();
+  while (work != NULL) {
+    ScrFsRenameOp *next = work->next;
+    scr_fs_rename_op_release(work);
+    work = next;
+  }
+  while (done != NULL) {
+    ScrFsRenameOp *next = done->next;
+    scr_fs_rename_op_release(done);
+    done = next;
+  }
+}
+
+static bool scr_fs_renames_pending(void) { return scr_fs_rename_pending_count != 0; }
+
+static bool scr_fs_renames_dispatch(void) {
+  scr_fs_rename_lock_enter();
+  ScrFsRenameOp *op = scr_fs_rename_done;
+  if (op != NULL) {
+    scr_fs_rename_done = op->next;
+    if (scr_fs_rename_done == NULL) scr_fs_rename_done_tail = &scr_fs_rename_done;
+  }
+  scr_fs_rename_lock_leave();
+  if (op == NULL) return false;
+  scr_fs_rename_pending_count--;
+  ScrCaught *caught = NULL;
+  ScrError *err = NULL;
+  if (op->error != 0) {
+    scr_fs_rename_error(op->error, op->oldpath, op->newpath);
+    caught = scr_exc_take();
+    if (caught && caught->kind == SCR_EXC_OBJ && scr_error_is(caught->payload)) {
+      err = (ScrError *)caught->payload;
+    }
+  }
+  op->fn(op->cb, err);
+  scr_caught_release(caught);
+  scr_fs_rename_op_release(op);
+  return true;
+}
+#else
+static bool scr_fs_renames_pending(void) { return false; }
+static bool scr_fs_renames_dispatch(void) { return false; }
+#endif
+
+void scr_fs_rename_async(ScrStr *oldpath, ScrStr *newpath,
+                         ScrClosure *cb, ScrFsRenameFn fn) {
+#ifdef SCR_LIB
+  (void)oldpath; (void)newpath; (void)fn;
+  scr_closure_release(cb);
+  scr_trap("scriptc: internal error: fs.rename reached in a library build — please report this");
+#else
+  if (!scr_fs_rename_shutdown_registered) {
+    if (atexit(scr_fs_renames_shutdown) != 0) {
+      scr_trap("scriptc: could not register fs.rename worker cleanup\n");
+    }
+    scr_fs_rename_shutdown_registered = true;
+  }
+  ScrFsRenameOp *op = calloc(1, sizeof *op);
+  if (!op) scr_trap("scriptc: out of memory\n");
+  op->oldpath = scr_str_retain(oldpath);
+  op->newpath = scr_str_retain(newpath);
+  op->cb = cb;
+  op->fn = fn;
+  scr_fs_rename_pending_count++;
+  scr_fs_rename_lock_enter();
+  *scr_fs_rename_work_tail = op;
+  scr_fs_rename_work_tail = &op->next;
+  int create_error = 0;
+  if (scr_fs_rename_worker_count < 4) {
+#ifdef _WIN32
+    HANDLE worker = CreateThread(NULL, 0, scr_fs_rename_worker, NULL, 0, NULL);
+    if (worker != NULL) {
+      scr_fs_rename_workers[scr_fs_rename_worker_count] = worker;
+      scr_fs_rename_worker_count++;
+    } else {
+      create_error = EAGAIN;
+    }
+#else
+    pthread_t worker;
+    create_error = pthread_create(&worker, NULL, scr_fs_rename_worker, NULL);
+    if (create_error == 0) {
+      scr_fs_rename_workers[scr_fs_rename_worker_count] = worker;
+      scr_fs_rename_worker_count++;
+    }
+#endif
+  }
+  if (create_error != 0 && scr_fs_rename_worker_count == 0) {
+    /* Submission failure is still callback-asynchronous. No worker exists,
+     * so publish every queued request as the same resource error. */
+    while (scr_fs_rename_work != NULL) {
+      ScrFsRenameOp *failed = scr_fs_rename_work;
+      scr_fs_rename_work = failed->next;
+      failed->error = create_error;
+      failed->next = NULL;
+      *scr_fs_rename_done_tail = failed;
+      scr_fs_rename_done_tail = &failed->next;
+    }
+    scr_fs_rename_work_tail = &scr_fs_rename_work;
+  } else {
+    scr_fs_rename_signal();
+  }
+  scr_fs_rename_lock_leave();
+#endif
+}
+
+void scr_fs_rename_thunk0(ScrClosure *cb, ScrError *err) {
+  (void)err;
+  ((void (*)(ScrClosure *))cb->fn)(cb);
+}
+
 /* ── node:timers/promises ────────────────────────────────────────────
  * The promisified pair: a PENDING void promise a one-shot heap timer
  * (setTimeout) or the immediate queue (setImmediate) fulfills — the
@@ -1763,10 +2026,12 @@ bool scr_loop_run(ScrPromise *top_level) {
         scr_nt_head = t->next;
         if (scr_nt_head == NULL) scr_nt_tail = NULL;
         ScrClosure *cb = t->cb;
+        ScrFsRenameFn error_cb = t->error_cb;
         void (*raw)(void) = t->raw;
         free(t);
         if (cb) {
-          ((void (*)(ScrClosure *))cb->fn)(cb);
+          if (error_cb) error_cb(cb, NULL);
+          else ((void (*)(ScrClosure *))cb->fn)(cb);
           scr_closure_release(cb);
         } else {
           raw(); /* one stream tick, FIFO with the user ticks around it */
@@ -1807,6 +2072,16 @@ bool scr_loop_run(ScrPromise *top_level) {
      * here would walk the whole live heap every turn, which is precisely
      * what the generations exist to avoid. No-op on an empty buffer. */
     scr_cyc_collect_scheduled();
+    /* Completed callback-style filesystem work is delivered on the main
+     * runtime thread. A worker may have finished while synchronous user code
+     * occupied that thread. Deliver exactly one completion per checkpoint:
+     * Node drains nextTicks and microtasks after each native callback before
+     * invoking the next ready callback. */
+    if (scr_fs_renames_pending()) {
+      bool dispatched = scr_fs_renames_dispatch();
+      if (scr_exc_pending()) return false;
+      if (dispatched) continue;
+    }
     /* Stream tick dispatch (scr_stream.c, when linked): the deferred
      * next-tick emissions ('data' flow kicks, 'readable'/'end'/'finish'/
      * 'drain'/'error'/'close') fire now, FIRST — the nextTick station.
@@ -1874,7 +2149,8 @@ bool scr_loop_run(ScrPromise *top_level) {
           (scr_events_pending_fn != NULL && scr_events_pending_fn()) ||
           (scr_net_pending_fn != NULL && scr_net_pending_fn()) ||
           (scr_dgram_pending_fn != NULL && scr_dgram_pending_fn()) ||
-          (scr_watch_pending_fn != NULL && scr_watch_pending_fn());
+          (scr_watch_pending_fn != NULL && scr_watch_pending_fn()) ||
+          scr_fs_renames_pending();
       if (held) {
         scr_children_poll();
         if (scr_exc_pending()) return false; /* uncaught throw in a listener */
@@ -1893,13 +2169,14 @@ bool scr_loop_run(ScrPromise *top_level) {
     bool net = scr_net_pending_fn != NULL && scr_net_pending_fn();
     bool dgram = scr_dgram_pending_fn != NULL && scr_dgram_pending_fn();
     bool watch = scr_watch_pending_fn != NULL && scr_watch_pending_fn();
+    bool renames = scr_fs_renames_pending();
     /* Timer liveness counts only REF'd timers: an unref'd timer stays in
      * the heap (and fires if the loop runs on for other reasons) but does
      * not by itself keep the process alive — Node's unref semantics.
      * Children follow the same rule: an unref'd child is still REAPED
      * while the loop runs (kids drives the sweeps and sleeps above) but
      * only reffed ones keep the process alive. */
-    if (scr_reffed_timers == 0 && scr_reffed_immediates == 0 && !scr_children_reffed_pending() && !io && !events && !net && !dgram && !watch) break;
+    if (scr_reffed_timers == 0 && scr_reffed_immediates == 0 && !scr_children_reffed_pending() && !io && !events && !net && !dgram && !watch && !renames) break;
     /* Sleep to the earliest deadline, then run every due timer (each may
      * enqueue microtasks, which the next iteration drains first). Who
      * sleeps depends on what is pending:
@@ -1920,6 +2197,10 @@ bool scr_loop_run(ScrPromise *top_level) {
      * - timers only: plain nanosleep to the deadline. */
     double now = scr_now_ms();
     double due = scr_ntimers > 0 ? scr_timers[0].deadline_ms : now + SCR_IO_POLL_MS;
+    /* The rename worker has no platform poll handle yet. Bound the idle
+     * wait exactly like the portable child fallback so completion is noticed
+     * promptly even when another poller owns the sleep. */
+    if (renames && due > now + SCR_CHILD_POLL_MS) due = now + SCR_CHILD_POLL_MS;
     /* An armed island timer (AbortSignal.timeout) caps the sleep: it must
      * fire on time even while the poller waits on socket readiness. */
     if (scr_island_deadline_fn != NULL) {