@scriptc/cli-darwin-x64 0.0.0 → 0.2.1

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

@@ -0,0 +1,213 @@
+#include "scr_runtime.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef SCR_RC_AUDIT
+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
+
+/* ── boxes ──────────────────────────────────────────────────────────────
+ * Every box carries a cycle header (a captured binding can hold anything,
+ * including the closure that captures it — the canonical cycle). The box's
+ * trace visits its payload when the payload type itself carries a header:
+ * closures always do; SCR_BOX_OBJ payloads iff the compiler passed a trace
+ * (obj_trace doubles as that flag); strings/scalars never. SCR_BOX_ARR
+ * holds acyclic arrays only — a CYCLE-CAPABLE array (traced ref elements)
+ * rides a SCR_BOX_OBJ box with the array's `_v` adapters + scr_arr_trace_v,
+ * so its edge stays visible to the collector. */
+
+static void *scr_box_ptr(const ScrBox *b) {
+  void *p;
+  memcpy(&p, &b->slot, sizeof p);
+  return p;
+}
+
+static void scr_box_trace(void *o, ScrTraceVisit visit, void *ctx) {
+  ScrBox *b = (ScrBox *)o;
+  void *p = scr_box_ptr(b);
+  if (!p) return; /* freshly-created boxes hold NULL until first write */
+  switch (b->kind) {
+  case SCR_BOX_FUNC:
+    visit(p, ctx);
+    break;
+  case SCR_BOX_OBJ:
+    if (b->obj_trace) visit(p, ctx);
+    break;
+  default:
+    break;
+  }
+}
+
+/* Teardown for the collector: release exactly the payloads the trace does
+ * NOT visit (the complement — see the contract in scr_runtime.h). */
+static void scr_box_gcfree(void *o) {
+  ScrBox *b = (ScrBox *)o;
+  void *p = scr_box_ptr(b);
+  if (p) {
+    switch (b->kind) {
+    case SCR_BOX_STR:
+      scr_str_release((ScrStr *)p);
+      break;
+    case SCR_BOX_ARR:
+      scr_arr_release((ScrArr *)p);
+      break;
+    case SCR_BOX_OBJ:
+      if (!b->obj_trace) b->obj_release(p);
+      break;
+    default: /* FUNC is traced; scalars own nothing */
+      break;
+    }
+  }
+#ifdef SCR_RC_AUDIT
+  scr_live_boxes--;
+#endif
+  scr_cyc_free(b);
+}
+
+ScrBox *scr_box_new(ScrBoxKind kind) {
+  ScrBox *b = scr_cyc_alloc(sizeof(ScrBox), &scr_box_trace, &scr_box_gcfree);
+  b->rc = 1;
+  b->kind = kind;
+#ifdef SCR_RC_AUDIT
+  scr_live_boxes++;
+#endif
+  return b;
+}
+
+ScrBox *scr_box_new_obj(void *(*retain)(void *), void (*release)(void *),
+                         ScrTraceFn trace) {
+  ScrBox *b = scr_box_new(SCR_BOX_OBJ);
+  b->obj_retain = retain;
+  b->obj_release = release;
+  b->obj_trace = trace;
+  return b;
+}
+
+/* Release one payload pointer by the box's kind. Factored so set_ref can
+ * release the value it REPLACED after the slot is already overwritten
+ * (mutators must unlink before releasing — see scr_cycle.c). */
+static void scr_box_release_payload(ScrBox *b, void *p) {
+  if (!p) return;
+  switch (b->kind) {
+  case SCR_BOX_STR:
+    scr_str_release((ScrStr *)p);
+    break;
+  case SCR_BOX_ARR:
+    scr_arr_release((ScrArr *)p);
+    break;
+  case SCR_BOX_FUNC:
+    scr_closure_release((ScrClosure *)p);
+    break;
+  case SCR_BOX_OBJ:
+    b->obj_release(p);
+    break;
+  case SCR_BOX_F64:
+  case SCR_BOX_BOOL:
+    break;
+  }
+}
+
+void scr_box_release(ScrBox *b) {
+  if (!b || b->rc == SIZE_MAX) return; /* NULL: a switch jumped past the decl */
+  if (--b->rc == 0) {
+    scr_cyc_on_dead(b);
+    scr_box_release_payload(b, scr_box_ptr(b));
+#ifdef SCR_RC_AUDIT
+    scr_live_boxes--;
+#endif
+    scr_cyc_free(b);
+  } else {
+    scr_cyc_on_release(b); /* possible cycle root; may collect — b is done */
+  }
+}
+
+double scr_box_get_f64(ScrBox *b) {
+  double v;
+  memcpy(&v, &b->slot, sizeof v);
+  return v;
+}
+
+bool scr_box_get_bool(ScrBox *b) { return b->slot != 0; }
+
+void *scr_box_get_ref(ScrBox *b) {
+  void *p = scr_box_ptr(b);
+  switch (b->kind) {
+  case SCR_BOX_STR:
+    return scr_str_retain((ScrStr *)p);
+  case SCR_BOX_ARR:
+    return scr_arr_retain((ScrArr *)p);
+  case SCR_BOX_FUNC:
+    return scr_closure_retain((ScrClosure *)p);
+  case SCR_BOX_OBJ:
+    return b->obj_retain(p);
+  default:
+    scr_trap("scriptc: internal error: box_get_ref on a scalar box\n");
+  }
+}
+
+void scr_box_set_f64(ScrBox *b, double v) { memcpy(&b->slot, &v, sizeof v); }
+
+void scr_box_set_bool(ScrBox *b, bool v) { b->slot = v ? 1 : 0; }
+
+void scr_box_set_ref(ScrBox *b, void *v) {
+  /* Unlink-then-release: the slot must already hold the new value when the
+   * old one's release runs (it can trigger a collection, which must not
+   * walk the b→old edge whose count was just given up). */
+  void *old = scr_box_ptr(b);
+  memcpy(&b->slot, &v, sizeof v);
+  scr_box_release_payload(b, old);
+}
+
+/* ── closures ─────────────────────────────────────────────────────────── */
+
+static void scr_closure_trace(void *o, ScrTraceVisit visit, void *ctx) {
+  ScrClosure *c = (ScrClosure *)o;
+  for (size_t i = 0; i < c->ncaps; i++) visit(c->caps[i], ctx);
+  visit(c->props, ctx);
+}
+
+static void scr_closure_gcfree(void *o) {
+  /* Captures and the own-property box are all traced. */
+#ifdef SCR_RC_AUDIT
+  scr_live_closures--;
+#endif
+  scr_cyc_free(o);
+}
+
+ScrClosure *scr_closure_new(void *fn, size_t ncaps) {
+  ScrClosure *c = scr_cyc_alloc(sizeof(ScrClosure) + ncaps * sizeof(ScrBox *),
+                                 &scr_closure_trace, &scr_closure_gcfree);
+  c->rc = 1;
+  c->fn = fn;
+  c->ncaps = ncaps;
+  c->props = NULL; /* lazily allocated by Object.defineProperties */
+  c->function_kind = 0;
+#ifdef SCR_RC_AUDIT
+  scr_live_closures++;
+#endif
+  return c;
+}
+
+void scr_closure_release(ScrClosure *c) {
+  if (!c || c->rc == SIZE_MAX) return; /* NULL: an uninitialized `let` local */
+  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->props); /* NULL-tolerant */
+#ifdef SCR_RC_AUDIT
+    scr_live_closures--;
+#endif
+    scr_cyc_free(c);
+  } else {
+    scr_cyc_on_release(c); /* possible cycle root; may collect — c is done */
+  }
+}
+
+void scr_closure_trace_v(void *c, ScrTraceVisit visit, void *ctx) {
+  scr_closure_trace(c, visit, ctx);
+}

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

@@ -0,0 +1,259 @@
+#include "scr_runtime.h"
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#ifdef _WIN32
+#include <fcntl.h> /* _O_BINARY */
+#include <io.h>    /* _setmode, _fileno */
+#include <windows.h>
+#endif
+
+/* 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 SCR_TL long scr_abandoned_fibers = 0;
+void scr_note_abandoned_fibers(long n) { scr_abandoned_fibers = n; }
+
+#ifndef SCR_LIB
+#ifdef SCR_RC_AUDIT
+extern long scr_str_live_count(void);     /* scr_string.c */
+extern long scr_arr_live_count(void);     /* scr_array.c */
+extern long scr_map_live_count(void);     /* scr_map.c */
+extern long scr_box_live_count(void);     /* scr_closure.c */
+extern long scr_closure_live_count(void); /* scr_closure.c */
+extern long scr_obj_live_count(void);     /* scr_object.c */
+extern long scr_union_live_count(void);   /* scr_union.c */
+extern long scr_dyn_live_count(void);     /* scr_json.c */
+extern long scr_bytes_live_count(void);   /* scr_bytes.c */
+#ifdef SCR_DYNAMIC
+extern long scr_jsval_live_count(void); /* scr_island.c */
+#endif
+
+static void scr_rc_audit_at_exit(void) {
+  /* Fibers suspended forever at loop exhaustion (awaits nobody resolves —
+   * Node exits 0 there too) still hold their stacks and owned values by
+   * design; a strict audit would only report that deliberate abandonment. */
+  if (scr_abandoned_fibers > 0) {
+    fprintf(stderr, "scriptc RC audit skipped: %ld fiber(s) never resumed\n",
+            scr_abandoned_fibers);
+    return;
+  }
+  long strings = scr_str_live_count();
+  long arrays = scr_arr_live_count();
+  long maps = scr_map_live_count();
+  long boxes = scr_box_live_count();
+  long closures = scr_closure_live_count();
+  long objects = scr_obj_live_count();
+  long unions = scr_union_live_count();
+  long dyns = scr_dyn_live_count();
+  long bytes = scr_bytes_live_count();
+#ifdef SCR_DYNAMIC
+  long jsvals = scr_jsval_live_count();
+#else
+  long jsvals = 0;
+#endif
+  if (strings != 0 || arrays != 0 || maps != 0 || boxes != 0 || closures != 0 ||
+      objects != 0 || unions != 0 || dyns != 0 || bytes != 0 || jsvals != 0) {
+    fflush(stdout);
+    fprintf(stderr,
+            "scriptc RC AUDIT FAILED: %ld heap string(s), %ld array(s), "
+            "%ld map(s), %ld box(es), %ld closure(s), %ld object(s), "
+            "%ld union(s), %ld dyn value(s), %ld bytes value(s), "
+            "%ld island value(s) live at exit\n",
+            strings, arrays, maps, boxes, closures, objects, unions, dyns,
+            bytes, jsvals);
+    _Exit(99);
+  }
+}
+#endif
+
+static void scr_flush_at_exit(void) { fflush(stdout); }
+
+static void scr_collect_cycles_at_exit(void) { scr_collect_cycles(); }
+
+#ifdef _WIN32
+static UINT scr_original_console_output_cp = 0;
+
+static void scr_restore_console_output_cp(void) {
+  if (scr_original_console_output_cp != 0) {
+    (void)SetConsoleOutputCP(scr_original_console_output_cp);
+  }
+}
+
+static void scr_enable_utf8_console_output(void) {
+  DWORD mode;
+  HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
+  HANDLE err = GetStdHandle(STD_ERROR_HANDLE);
+  bool out_is_console = out != NULL && out != INVALID_HANDLE_VALUE &&
+                        GetConsoleMode(out, &mode);
+  bool err_is_console = err != NULL && err != INVALID_HANDLE_VALUE &&
+                        GetConsoleMode(err, &mode);
+  if (!out_is_console && !err_is_console) return;
+
+  UINT original = GetConsoleOutputCP();
+  if (original == 0 || original == CP_UTF8) return;
+  if (!SetConsoleOutputCP(CP_UTF8)) return;
+
+  /* The code page belongs to the shared console, not this process. Restore
+   * it after every scriptc exit hook has finished writing. */
+  scr_original_console_output_cp = original;
+  if (atexit(scr_restore_console_output_cp) != 0) {
+    (void)SetConsoleOutputCP(original);
+    scr_original_console_output_cp = 0;
+  }
+}
+#endif
+
+void scr_runtime_abi_v6(void) {}
+
+void scr_init(void) {
+#ifdef _WIN32
+  /* The CRT opens std streams in TEXT mode, which writes \n as \r\n. Node
+   * on Windows does NOT translate — console.log emits \n whether stdout is
+   * a pipe or the console (libuv writes the bytes as given) — so the
+   * streams switch to binary here or every line would differ from the
+   * oracle by a byte. stdin too: readFileSync(0) must see the bytes on the
+   * pipe, not a CRLF-collapsed view. */
+  _setmode(_fileno(stdout), _O_BINARY);
+  _setmode(_fileno(stderr), _O_BINARY);
+  _setmode(_fileno(stdin), _O_BINARY);
+  /* Byte streams stay raw UTF-8. A real Windows console instead decodes
+   * narrow writes through its output code page, which commonly starts as
+   * CP437; select UTF-8 only while this process is attached and restore the
+   * shared setting at exit. */
+  scr_enable_utf8_console_output();
+#endif
+  /* 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
+   * (registered later, in scr_lib_init) → cycle collection → RC audit →
+   * flush → Windows console-code-page restore. The final collection frees
+   * cycles the program dropped, so the audit (and ASan's leak check) see
+   * them as freed, not leaked. */
+  atexit(scr_flush_at_exit);
+#ifdef SCR_RC_AUDIT
+  atexit(scr_rc_audit_at_exit);
+#endif
+  atexit(scr_collect_cycles_at_exit);
+}
+#endif /* !SCR_LIB — a library artifact never touches host stdio modes/buffering and
+        * registers no atexit handlers: scr_init and its exit hooks (the
+        * audit's _Exit(99) included) are executable-lane machinery; the
+        * library session reset lives in scr_library.c. */
+
+/* ONE formatter for both console streams — console.error/warn print
+ * byte-identically to console.log in Node (same inspect rendering), only
+ * the stream differs. */
+/* A real definition lets relocatable library links localize this hook;
+ * a tentative common symbol stays externally visible on Mach-O. */
+bool (*scr_stdio_write_hook)(int fd, const void *data, size_t len) = NULL;
+
+static void scr_console_write(FILE *out, size_t n, const ScrLogArg *args) {
+  if (scr_stdio_write_hook) {
+    size_t capacity = 1;
+    for (size_t i = 0; i < n; i++) {
+      size_t length = args[i].tag == SCR_ARG_STR ? args[i].v.s->len : 32;
+      if (length >= SIZE_MAX - capacity) scr_trap("scriptc: console output too large\n");
+      capacity += length + 1;
+    }
+    char *line = malloc(capacity);
+    if (!line) scr_trap("scriptc: out of memory\n");
+    size_t used = 0;
+    for (size_t i = 0; i < n; i++) {
+      if (i) line[used++] = ' ';
+      const ScrLogArg *arg = &args[i];
+      if (arg->tag == SCR_ARG_STR) {
+        memcpy(line + used, arg->v.s->data, arg->v.s->len);
+        used += arg->v.s->len;
+      } else if (arg->tag == SCR_ARG_BOOL) {
+        const char *text = arg->v.b ? "true" : "false";
+        size_t length = arg->v.b ? 4 : 5;
+        memcpy(line + used, text, length);
+        used += length;
+      } else if (arg->v.f == 0 && signbit(arg->v.f)) {
+        memcpy(line + used, "-0", 2);
+        used += 2;
+      } else {
+        used += scr_f64_to_str(arg->v.f, line + used);
+      }
+    }
+    line[used++] = '\n';
+    scr_stdio_write_hook(out == stderr ? 2 : 1, line, used);
+    free(line);
+    /* The global Node console uses ignoreErrors=true for stream writes. */
+    if (scr_exc_pending()) scr_exc_clear();
+    return;
+  }
+  char numbuf[32];
+  for (size_t i = 0; i < n; i++) {
+    if (i > 0) fputc(' ', out);
+    const ScrLogArg *a = &args[i];
+    switch (a->tag) {
+    case SCR_ARG_F64: {
+      /* console.log renders numbers via inspect, which distinguishes -0
+       * (String(-0) is "0", but console.log(-0) prints "-0"). */
+      if (a->v.f == 0 && signbit(a->v.f)) {
+        fputs("-0", out);
+        break;
+      }
+      size_t len = scr_f64_to_str(a->v.f, numbuf);
+      fwrite(numbuf, 1, len, out);
+      break;
+    }
+    case SCR_ARG_STR:
+      fwrite(a->v.s->data, 1, a->v.s->len, out);
+      break;
+    case SCR_ARG_BOOL:
+      fputs(a->v.b ? "true" : "false", out);
+      break;
+    }
+  }
+  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. 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. */
+int scr_stdio_write_raw(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) != len) return errno ? errno : EIO;
+  if (fflush(out) != 0) return errno ? errno : EIO;
+  return 0;
+}
+
+bool scr_stdio_write(int fd, const void *data, size_t len) {
+  if (scr_stdio_write_hook) return scr_stdio_write_hook(fd, data, len);
+  (void)scr_stdio_write_raw(fd, data, len);
+  return true;
+}

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

@@ -0,0 +1,95 @@
+#include "scr_runtime.h"
+#include <stdlib.h>
+#include <string.h>
+
+/* Stored console methods use the same native rendering as direct output.
+ * Reflection, mutation, and further Console APIs remain explicit boundaries. */
+static SCR_TL ScrDyn *scr_console_methods[5];
+static SCR_TL bool scr_console_registered;
+static void scr_console_methods_cleanup(void) {
+  for (size_t i = 0; i < 5; i++) {
+    ScrDyn *method = scr_console_methods[i];
+    scr_console_methods[i] = NULL;
+    scr_dyn_release(method);
+  }
+}
+
+static ScrDyn *scr_console_method_call(ScrClosure *closure, ScrDyn *const *args, size_t argc) {
+  if (argc > 1 && args[0]->kind == SCR_DYN_STR) {
+    ScrStr *format = args[0]->v.str;
+    for (size_t i = 0; i + 1 < format->len; i++) if (format->data[i] == '%' &&
+        strchr("sdifjoOc%", format->data[i + 1])) {
+      static const char message[] = "Format strings through stored console methods have no lowering";
+      scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020");
+      return NULL;
+    }
+  }
+  ScrLogArg *rendered = argc ? calloc(argc, sizeof *rendered) : NULL;
+  if (argc && !rendered) scr_trap("scriptc: out of memory\n");
+  size_t count = 0;
+  for (; count < argc; count++) {
+    rendered[count].tag = SCR_ARG_STR;
+    rendered[count].v.s = scr_insp_dyn_s(args[count], 2);
+    if (scr_exc_pending()) break;
+  }
+  if (!scr_exc_pending()) {
+    if (scr_box_get_f64(closure->caps[0]) != 0) scr_console_error(argc, rendered);
+    else scr_console_log(argc, rendered);
+  }
+  for (size_t i = 0; i < argc; i++) scr_str_release(rendered[i].v.s);
+  free(rendered);
+  return scr_exc_pending() ? NULL : scr_dyn_retain(scr_dyn_undefined());
+}
+
+static void *scr_console_retain(void *ptr) { return ptr; }
+static void scr_console_release(void *ptr) { (void)ptr; }
+static bool scr_console_set(void *ptr, const char *key, size_t len, const ScrDyn *value) {
+  (void)ptr; (void)key; (void)len; (void)value;
+  static const char message[] = "Mutating the native console has no lowering";
+  scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020");
+  return false;
+}
+static ScrDyn *scr_console_get(void *ptr, const char *key, size_t len) {
+  (void)ptr;
+  const char *names[] = {"log", "info", "debug", "error", "warn"};
+  for (size_t i = 0; i < 5; i++) if (strlen(names[i]) == len && memcmp(names[i], key, len) == 0) {
+    if (!scr_console_methods[i]) {
+      ScrClosure *closure = scr_closure_new(NULL, 1);
+      closure->caps[0] = scr_box_new(SCR_BOX_F64);
+      scr_box_set_f64(closure->caps[0], i >= 3 ? 1 : 0);
+      scr_console_methods[i] = scr_dyn_new_func(closure, scr_console_method_call, 0, "", names[i]);
+    }
+    return scr_dyn_retain(scr_console_methods[i]);
+  }
+  static const char *unsupported[] = {"Console", "assert", "clear", "count", "countReset", "dir", "dirxml", "group", "groupCollapsed", "groupEnd", "table", "time", "timeEnd", "timeLog", "trace", "profile", "profileEnd", "timeStamp", "context", "_stdout", "_stderr"};
+  for (size_t i = 0; i < sizeof unsupported / sizeof unsupported[0]; i++)
+    if (strlen(unsupported[i]) == len && memcmp(unsupported[i], key, len) == 0) {
+      static const char message[] = "This stored console member has no lowering";
+      scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020");
+      return NULL;
+    }
+  return scr_dyn_retain(scr_dyn_undefined());
+}
+static ScrDyn *scr_console_invoke(void *ptr, ScrDyn *self, const char *key, ScrDyn *const *args, size_t argc, const char *what) {
+  (void)self;
+  ScrDyn *method = scr_console_get(ptr, key, strlen(key));
+  if (!method) return NULL;
+  ScrDyn *result = scr_dyn_call(method, args, argc, what);
+  scr_dyn_release(method);
+  return result;
+}
+ScrDyn *scr_console_native(void) {
+  static const ScrDynHandleOps ops = {"console", scr_console_retain, scr_console_release, scr_console_invoke, scr_console_get, scr_console_set, NULL, NULL};
+  if (!scr_console_registered) {
+    scr_console_registered = true;
+    scr_atexit(scr_console_methods_cleanup);
+  }
+  scr_dyn_handle_install(SCR_DYNH_CONSOLE, &ops);
+  return scr_dyn_new_handle(&scr_console_registered, SCR_DYNH_CONSOLE);
+}
+
+/* Only programs that expose a stored global need its console provider.
+ * Keep the core builtin unit independent of optional inspection code. */
+ScrDyn *scr_global_native(ScrArr *known) {
+  return scr_global_native_init(known, scr_console_native);
+}