@scriptc/cli-darwin-arm64 0.2.0 → 0.2.2

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

@@ -62,7 +62,7 @@ void scr_init(void);
 /* Program objects emitted by the bundled LLVM helper reference this symbol.
  * Its versioned spelling makes a mismatched manual runtime link fail before
  * the program can start. */
-void scr_runtime_abi_v5(void);
+void scr_runtime_abi_v6(void);
 
 /* ── the trap funnel (scr_console.c; scr_library.c under -DSCR_LIB) ──────
  * Every unrecoverable runtime trap — OOM, semantic range traps, internal-
@@ -78,6 +78,31 @@ void scr_runtime_abi_v5(void);
  * structured trap-teaching form before delivery (a message that already
  * begins with the 0x01 marker passes verbatim) — see ScrLibSinkFn below. */
 _Noreturn void scr_trap(const char *msg);
+
+/* glibc added arc4random_buf in 2.36. Older GNU targets use the same kernel
+ * CSPRNG as the musl shim, with no global state or persistent descriptor. */
+#ifdef __GLIBC__
+#if !__GLIBC_PREREQ(2, 36)
+#include <errno.h>
+#include <stdlib.h>
+#include <sys/random.h>
+static inline void scr_glibc_random_buf(void *buf, size_t n) {
+  unsigned char *p = buf;
+  while (n > 0) {
+    ssize_t got = getrandom(p, n, 0);
+    if (got > 0) {
+      p += (size_t)got;
+      n -= (size_t)got;
+    } else if (got < 0 && errno == EINTR) {
+      continue;
+    } else {
+      scr_trap("scriptc: getrandom failed\n");
+    }
+  }
+}
+#define arc4random_buf scr_glibc_random_buf
+#endif
+#endif
 _Noreturn void scr_trap_fmt(const char *fmt, ...);
 
 /* ── library mode (scr_library.c, linked only into library artifacts) ─────
@@ -472,6 +497,7 @@ typedef struct ScrClassObj {
   size_t ncaps;
   size_t length;
   struct ScrBox *prototype_data;
+  struct ScrBox *static_data;
   struct ScrBox *caps[];
 } ScrClassObj;
 
@@ -483,6 +509,7 @@ static inline ScrClassObj *scr_classobj_retain(ScrClassObj *c) {
   return c;
 }
 void scr_classobj_release(ScrClassObj *c);
+void scr_classobj_clear_properties(ScrClassObj *c);
 ScrClassObj *scr_classobj_new(const ScrClassObj *template, size_t ncaps);
 void scr_classobj_trace_v(void *c, ScrTraceVisit visit, void *ctx);
 /* void*-signature RC adapters (container slots) — scr_object.c. */
@@ -492,8 +519,16 @@ void scr_classobj_release_v(void *c);
 ScrStr *scr_classobj_name(ScrClassObj *c);
 struct ScrDyn *scr_dyn_class_prototype(struct ScrDyn *value, struct ScrDyn *base);
 struct ScrDyn *scr_dyn_class_base_prototype(struct ScrDyn *constructor);
+struct ScrDyn *scr_dyn_class_inherit(struct ScrDyn *constructor, struct ScrDyn *base);
 void scr_dyn_class_super(struct ScrDyn *constructor, struct ScrDyn *receiver, struct ScrDyn *arguments);
 struct ScrDyn *scr_dyn_assign_prototype(struct ScrDyn *target, struct ScrDyn *sources, struct ScrDyn *protected_keys);
+struct ScrDyn *scr_dyn_bag_get(struct ScrDyn *bag, ScrStr *key, struct ScrDyn *receiver);
+struct ScrDyn *scr_dyn_reflect_get(struct ScrDyn *target, struct ScrDyn *key, struct ScrDyn *receiver);
+bool scr_dyn_reflect_set(struct ScrDyn *target, struct ScrDyn *key, struct ScrDyn *value, struct ScrDyn *receiver);
+bool scr_dyn_reflect_define(struct ScrDyn *receiver, struct ScrDyn *key, struct ScrDyn *value);
+bool scr_dyn_abstract_eq(const struct ScrDyn *left, const struct ScrDyn *right);
+int scr_dyn_function_kind(const struct ScrDyn *value);
+void scr_dyn_bag_set(struct ScrDyn *bag, ScrStr *key, struct ScrDyn *value, struct ScrDyn *receiver);
 /* The keyed-write miss on a fixed-shape record: throws the catchable
  * TypeError naming the key (JS would add the property — the documented
  * monomorphic-struct divergence). scr_object.c. */
@@ -531,6 +566,10 @@ typedef struct ScrError {
                     * embed the slot and release it NULL-guarded. */
   struct ScrDyn *error_cause; /* NULL = absent; dyn undefined = present */
   bool cause_enumerable; /* assignment creates an enumerable own property */
+  bool message_present; /* super() leaves the inherited message property visible */
+  bool message_enumerable; /* assignment creates an enumerable own property */
+  bool name_present;
+  bool name_enumerable;
   ScrStr *stack_frames; /* captured native source frames */
   ScrStr *stack; /* lazily formatted, cached stack */
 } ScrError;
@@ -564,6 +603,10 @@ typedef struct ScrDomException {
   ScrStr *code;    /* the Node string-code slot (stays NULL here) */
   struct ScrDyn *error_cause; /* shared ScrError prefix; unused by DOMException */
   bool cause_enumerable;
+  bool message_present;
+  bool message_enumerable;
+  bool name_present;
+  bool name_enumerable;
   ScrStr *stack_frames;
   ScrStr *stack;
   double dom_code; /* the WebIDL legacy code (0 when the name is off-table) */
@@ -617,11 +660,15 @@ void scr_error_init_options(void *obj, int kind, const struct ScrDyn *message, c
 void scr_error_install_cause_drop(void (*fn)(void *obj));
 bool scr_error_has_cause(ScrError *e);
 struct ScrDyn *scr_error_cause(ScrError *e); /* +1, undefined when absent */
+void scr_error_define_cause(ScrError *e, struct ScrDyn *value);
 void scr_error_set_cause(ScrError *e, struct ScrDyn *value); /* borrowed operands */
 void scr_error_delete_cause(ScrError *e);
 /* ECMA Error.prototype.toString: "", name, message, or "name: message".
  * Borrows e, returns +1. */
 ScrStr *scr_error_to_string(ScrError *e);
+void scr_error_install_message_reader(ScrStr *(*reader)(ScrError *));
+void scr_error_install_name_reader(ScrStr *(*reader)(ScrError *));
+ScrStr *scr_error_default_name(const ScrError *e);
 ScrStr *scr_error_stack(ScrError *e);
 
 ScrError *scr_error_retain(ScrError *e);
@@ -732,6 +779,7 @@ ScrStr *scr_str_trim(ScrStr *s);
  * sets the regex link flag for case-conversion sites). Borrow s; +1. */
 ScrStr *scr_str_to_lower(const ScrStr *s);
 ScrStr *scr_str_to_upper(const ScrStr *s);
+ScrStr *scr_str_normalize(const ScrStr *s, const ScrStr *form);
 
 /* charAt(i): 1-code-unit string; out of range → empty string. Half of an
  * astral pair → U+FFFD (divergence, see above). Returns +1. */
@@ -813,6 +861,7 @@ ScrStr *scr_str_encode_uri_component(ScrStr *s);
  * hex or an invalid sequence THROWS the spec's catchable URIError ("URI
  * malformed") and returns NULL. Borrows s; result +1. */
 ScrStr *scr_str_decode_uri_component(ScrStr *s);
+ScrStr *scr_str_decode_uri(ScrStr *s);
 
 /* The non-throwing core of decodeURIComponent: NULL on malformed input
  * instead of the URIError — the try/catch shape node:querystring's
@@ -863,6 +912,12 @@ void scr_qs_parse_into(ScrMap *out, const ScrStr *qs, const ScrStr *sep,
  * Borrows config; returns +1, or NULL with a Node-coded TypeError pending. */
 struct ScrDyn *scr_util_parse_args(const struct ScrDyn *config);
 
+/* Node 24's dotenv grammar, shared by util.parseEnv and process.loadEnvFile.
+ * Arguments are borrowed; parseEnv returns a fresh ordinary object (+1).
+ * Validation and file failures leave a coded exception pending. */
+struct ScrDyn *scr_util_parse_env(const struct ScrDyn *content);
+void scr_process_load_env_file(const struct ScrDyn *path);
+
 /* querystring.stringify — Node's stringify over a borrowed dyn value (the
  * frontend dynFroms the typed record; JS-world dyn values pass straight
  * through). Non-object dyn values answer "" like Node; object keys iterate in
@@ -966,6 +1021,7 @@ typedef struct ScrArr {
   struct ScrArrProp *props; /* noncanonical numeric properties */
   size_t prop_len;
   size_t prop_cap;
+  struct ScrDyn *metadata; /* heterogeneous named properties of match results */
 } ScrArr;
 
 typedef struct ScrArrSparseSlot {
@@ -1003,6 +1059,7 @@ static inline ScrArr *scr_arr_retain(ScrArr *a) {
  * NULL-tolerant (uninitialized locals). Cycle-capable arrays (elem_trace
  * non-NULL) feed the candidate-root buffer like every headered type. */
 void scr_arr_release(ScrArr *a);
+void scr_arr_copy_metadata(ScrArr *a, struct ScrDyn *target);
 
 /* Trace entry point for cycle-capable arrays — stored in their collector
  * header and passed wherever a container stores an ARRAY payload's RC entry
@@ -1161,16 +1218,15 @@ ScrStr *scr_str_raw(ScrArr *raw, ScrArr *subs);
 /* ── regular expressions (scr_regex.c — linked ONLY when the program
  * contains a regex literal; see native-toolchain.ts) ────────────────────────────────
  * The engine is quickjs-ng's libregexp (the same bytecode interpreter the
- * dynamic island uses), compiled standalone. A ScrRegex is today ALWAYS an
- * immortal interned literal: the compiler emits one static per distinct
- * (pattern, flags) pair, exactly like string literals, and the bytecode is
- * compiled lazily on first use (cached on the struct, freed at exit).
+ * dynamic island uses), compiled standalone. Each regex literal evaluation
+ * creates a fresh refcounted instance sharing an immortal template per
+ * (pattern, flags) pair. Template bytecode compiles lazily on first use
+ * and is freed at exit; constructed regexes own their bytecode.
  * Subjects are matched as UTF-16 (converted per call from the UTF-8
  * storage), so all observable index behavior is UTF-16-exact like Node.
  *
- * Statefulness fence: /g and /y regexes carry mutable lastIndex in JS.
- * Supported only where iteration is internal (replace/replaceAll/split);
- * test() on a g/y-flagged regex aborts with a clear message.
+ * Global and sticky regexes carry numeric lastIndex. Exec/test update it
+ * after matching; String methods apply their specified state rules.
  *
  * Ownership: subjects/replacements are BORROWED; string/array results
  * return +1. replace_all without /g THROWS a catchable TypeError
@@ -1178,10 +1234,12 @@ ScrStr *scr_str_raw(ScrArr *raw, ScrArr *subs);
  * checks); every other failure mode aborts.
  */
 typedef struct ScrRegex {
-  size_t rc;      /* SIZE_MAX = immortal (every regex literal) */
+  size_t rc;      /* SIZE_MAX = immortal literal template */
   ScrStr *source; /* pattern text between the slashes */
   ScrStr *flags;  /* flags text, source order (alphabet fenced to gimsuy) */
   uint8_t *bc;    /* lazily compiled libregexp bytecode; NULL until first use */
+  double last_index;
+  struct ScrRegex *literal; /* immutable bytecode owner for literal instances */
 } ScrRegex;
 
 static inline ScrRegex *scr_regex_retain(ScrRegex *re) {
@@ -1192,6 +1250,8 @@ static inline ScrRegex *scr_regex_retain(ScrRegex *re) {
 void scr_regex_release(ScrRegex *re); /* NULL-tolerant */
 void *scr_regex_retain_v(void *re);
 void scr_regex_release_v(void *re);
+ScrRegex *scr_regex_literal(ScrRegex *literal); /* fresh state, shared cached bytecode */
+double scr_regex_last_index(ScrRegex *re);
 
 /* new RegExp(pattern, flags): a heap ScrRegex over the same engine. The
  * pattern compiles EAGERLY — an invalid pattern or flag throws Node's
@@ -1200,11 +1260,14 @@ void scr_regex_release_v(void *re);
  * spec's "(?:)" source. Borrows both; +1, NULL after a throw. */
 ScrRegex *scr_regex_new(ScrStr *pattern, ScrStr *flags);
 
-bool scr_regex_test(ScrRegex *re, ScrStr *s); /* aborts on /g or /y */
-/* s.match(re): +1 string[] of [whole, ...captures] (nonparticipating
- * captures hold "" — SEMANTICS.md), or NULL for no match. Aborts on /g
- * or /y like test(). Borrows both. */
+bool scr_regex_test(ScrRegex *re, ScrStr *s); /* exec state transitions */
+/* s.match(re): +1 string[] of whole matches under /g, otherwise
+ * [whole, ...captures] (nonparticipating captures hold ""), or NULL for
+ * no match. Non-global /y uses exec state transitions. Borrows both. */
 ScrArr *scr_regex_match(ScrStr *s, ScrRegex *re);
+/* re.exec(s), string-first ABI: match slice with global/sticky lastIndex
+ * transitions. Borrows both; +1 or NULL. */
+ScrArr *scr_regex_exec(ScrStr *s, ScrRegex *re);
 /* s.search(re): the first match's UTF-16 index, or -1 — a fresh exec from
  * position 0 (Symbol.search never touches lastIndex, so no flag fence:
  * /g is irrelevant, /y anchors at 0). Borrows both; never throws. */
@@ -1277,6 +1340,17 @@ typedef struct {
   bool live;    /* false = tombstone (key/val already released) */
 } ScrMapEntry;
 
+/* Checked views use the original storage. Slot converters borrow on reads
+ * and return owned references on writes, just like typed Map operations. */
+typedef struct {
+  const char *type;
+  struct ScrDyn *(*key_box)(uint64_t);
+  uint64_t (*key_unbox)(const struct ScrDyn *);
+  bool (*key_matches)(const struct ScrDyn *);
+  struct ScrDyn *(*val_box)(uint64_t);
+  uint64_t (*val_unbox)(const struct ScrDyn *);
+} ScrMapDynOps;
+
 typedef struct ScrMap {
   size_t rc; /* SIZE_MAX = immortal (unused for maps; kept per convention) */
   ScrMapKeyKind key_kind;
@@ -1297,8 +1371,16 @@ typedef struct ScrMap {
   size_t nbuckets;  /* power of two; >= 2 * ecap so probes terminate */
   size_t *buckets;  /* entry indices; SIZE_MAX = empty */
   size_t iter_depth; /* > 0: an iteration is active — no compaction */
+  const ScrMapDynOps *dyn_ops;
 } ScrMap;
 
+void scr_map_dyn_attach(ScrMap *map, const ScrMapDynOps *ops);
+struct ScrDyn *scr_map_dyn_key(const ScrMap *map, double index);
+struct ScrDyn *scr_map_dyn_value(const ScrMap *map, double index);
+struct ScrDyn *scr_map_dyn_get(ScrMap *map, const struct ScrDyn *key);
+bool scr_map_dyn_has(ScrMap *map, const struct ScrDyn *key, bool remove);
+void scr_map_dyn_set(ScrMap *map, const struct ScrDyn *key, const struct ScrDyn *value, bool set);
+
 /* retain/release/trace are NULL for scalar value kinds; retain/release are
  * required for SCR_MAP_VAL_REF; trace is non-NULL iff the value type is
  * cycle-capable (the map then allocates with the collector header). */
@@ -1477,7 +1559,7 @@ typedef struct ScrClosure {
    * (like the dyn→closure edge): a cycle through it is merely never
    * collected. */
   ScrBox *props;
-  uint32_t function_kind; /* low bits: 0 ordinary, 1 generator, 2 async, 3 async generator; bit 2: ordinary own prototype */
+  uint32_t function_kind; /* low bits: 0 ordinary, 1 generator, 2 async, 3 async generator; bit 2: ordinary own prototype; bit 3: checked callable adapter in caps[0] */
   ScrBox *caps[];
 } ScrClosure;
 
@@ -1997,7 +2079,9 @@ ScrStream *scr_stream_set_push_encoding(ScrStream *s, ScrStr *enc);
 bool scr_stream_push_null(ScrStream *s);
 void scr_stream_unshift(ScrStream *s, ScrBytes *chunk);
 void scr_stream_unshift_str(ScrStream *s, ScrStr *str);
-ScrBytes *scr_stream_read(ScrStream *s, double size); /* +1 or NULL; size < 0 = all/first; throws once encoded (the static type is Buffer|null) */
+ScrBytes *scr_stream_read(ScrStream *s, double size);
+ScrStream *scr_stream_on_dyn(ScrStream *s, ScrStr *name, ScrDyn *cb, bool once, bool prepend);
+ScrDyn *scr_stream_read_dyn(ScrStream *s, ScrDyn *size); /* +1 or NULL; size < 0 = all/first; throws once encoded (the static type is Buffer|null) */
 /* setEncoding(enc): string-chunk mode — pushes decode through the
  * StringDecoder, 'data' delivers strings (the emit ABI carries both
  * payload slots; see scr_stream_emit_data), lengths count JS string
@@ -2212,10 +2296,8 @@ void scr_exc_clear(void);
  * refcounted local, and every runtime question a catch body may ask —
  * typeof-style kind tests (emitted as direct kind reads), instanceof over
  * hierarchy payloads, payload extraction, rethrow — reads the box. The box
- * itself carries no collector header: bindings live only in frames (the
- * frontend rejects captures), so no cycle can pass through it, and its
- * payload reference simply counts as an external edge — trial deletion
- * restores it on scan. */
+ * participates in cycle collection because a closure may capture the
+ * binding and its payload may retain that closure. */
 typedef struct ScrCaught {
   size_t rc;
   ScrExcKind kind; /* never SCR_EXC_NONE */
@@ -2230,6 +2312,7 @@ typedef struct ScrCaught {
 ScrCaught *scr_exc_take(void); /* moves the pending cell into a fresh box (+1) */
 ScrCaught *scr_caught_retain(ScrCaught *c);
 void scr_caught_release(ScrCaught *c); /* NULL-tolerant */
+void scr_caught_trace_v(void *c, ScrTraceVisit visit, void *ctx);
 /* Replace the pending disposal error with a SuppressedError and consume the
  * original body-error snapshot. The current exception cell must be pending. */
 void scr_exc_suppress(ScrCaught *suppressed);
@@ -2530,6 +2613,8 @@ ScrStats *scr_fs_lstat(ScrStr *path); /* +1, or throws; NO follow (lstat) */
 ScrStats *scr_fs_fstat(double fd); /* +1, or throws */
 void scr_fs_fchmod(double fd, double mode);
 void scr_fs_fsync(double fd);
+void scr_fs_fdatasync(double fd);
+void scr_fs_ftruncate(double fd, double length);
 void scr_fs_link(ScrStr *source, ScrStr *dest);
 ScrStats *scr_stats_retain(ScrStats *s);
 void scr_stats_release(ScrStats *s);
@@ -2814,7 +2899,11 @@ ScrChild *scr_fork(double target, ScrArr *args, double in_mode,
 ScrChild *scr_spawn_opts(ScrStr *cmd, ScrArr *args, double in_mode,
                           double out_mode, double err_mode, double out_fd,
                           double err_fd, bool detached, bool shell, bool has_env,
-                          ScrArr *env_pairs, ScrStr *cwd);
+                         ScrArr *env_pairs, ScrStr *cwd);
+/* Runtime options use the same spawn core; validation and explicit
+ * unsupported-option refusals throw before starting a child. Borrows. */
+ScrChild *scr_spawn_dynamic(ScrStr *cmd, ScrArr *args, const ScrDyn *options);
+void scr_child_on_spawn(ScrChild *child, ScrClosure *cb); /* moves zero-argument callback */
 /* The callback slice: file + args, default options. The returned child has
  * all three stdio slots piped; stdout/stderr are captured internally and
  * the callback moves into the child registry until settlement. */
@@ -2902,9 +2991,28 @@ bool scr_child_killed(ScrChild *c);
 bool scr_child_kill(ScrChild *c, const ScrStr *signal);
 bool scr_child_kill_num(ScrChild *c, double signum);
 void scr_child_unref(ScrChild *c);
+void scr_child_ref(ScrChild *c);
 /* Installs ChildProcess's checked-dynamic handle identity bridge. Emitted
  * programs call this only when the child_process surface is present. */
 void scr_child_dyn_install(void);
+void scr_child_on_dyn(ScrChild *child, ScrStr *event, ScrDyn *listener); /* borrowed */
+/* Optional native-stream bridge. The table avoids a stream dependency
+ * in programs that only use the child-process surface. */
+typedef struct ScrChildStreamOps {
+  ScrStream *(*readable)(void);
+  ScrStream *(*writable)(ScrClosure *, ScrStreamChunkInv, ScrClosure *, ScrStreamPlainInv);
+  void *(*retain)(void *);
+  void (*release)(void *);
+  ScrTraceFn trace;
+  bool (*push)(ScrStream *, ScrBytes *);
+  bool (*end)(ScrStream *);
+  void (*write_done)(ScrStream *, ScrError *);
+  void (*final_done)(ScrStream *, ScrError *);
+} ScrChildStreamOps;
+extern const ScrChildStreamOps scr_stream_child_ops;
+ScrDyn *scr_stream_dyn_view(ScrStream *stream); /* borrowed; +1 live method/property view */
+void scr_child_dyn_streams_install(const ScrChildStreamOps *ops,
+    ScrDyn *(*readable_box)(void *), ScrDyn *(*writable_box)(void *));
 bool scr_children_reffed_pending(void);
 void scr_children_teardown(void);
 /* Node's signal-name table (scr_lib.c), shared with child.kill: the
@@ -2943,6 +3051,7 @@ ScrStr *scr_crypto_hash_digest_str(ScrStr *alg, ScrStr *data, ScrStr *enc);
 ScrStr *scr_crypto_hash_digest_bytes(ScrStr *alg, ScrBytes *data, ScrStr *enc);
 typedef struct ScrCryptoHash ScrCryptoHash;
 ScrCryptoHash *scr_crypto_hash_new(ScrStr *alg);
+ScrDyn *scr_crypto_native(void);
 ScrCryptoHash *scr_crypto_hmac_new_str(ScrStr *alg, ScrStr *key);
 ScrCryptoHash *scr_crypto_hmac_new_bytes(ScrStr *alg, ScrBytes *key);
 ScrCryptoHash *scr_crypto_hash_retain(ScrCryptoHash *h);
@@ -2960,22 +3069,33 @@ ScrBytes *scr_crypto_random_fill_rest(ScrBytes *bytes, double offset);
 double scr_crypto_random_int(double min, double max);
 ScrBytes *scr_crypto_pbkdf2(ScrBytes *password, ScrBytes *salt,
                             double iterations, double keylen, ScrStr *digest);
-typedef void (*ScrCryptoBytesFn)(ScrClosure *cb, ScrBytes *value /* moves */);
-void scr_crypto_defer_bytes(ScrBytes *value /* moves */, ScrClosure *cb /* moves */,
+ScrBytes *scr_crypto_hkdf_bytes(ScrStr *digest, ScrBytes *ikm, ScrBytes *salt,
+                                ScrBytes *info, double keylen);
+ScrDyn *scr_crypto_hkdf(ScrStr *digest, ScrBytes *ikm, ScrBytes *salt,
+                       ScrBytes *info, double keylen);
+ScrBytes *scr_crypto_scrypt(ScrBytes *password, ScrBytes *salt, double keylen, ScrDyn *options);
+ScrBytes *scr_crypto_scrypt_derive(ScrBytes *password, ScrBytes *salt, double keylen,
+                                  double n, double r, double p, double maxmem);
+typedef void (*ScrCryptoBytesFn)(ScrClosure *cb, ScrError *error /* borrowed */, ScrBytes *value /* moves */);
+void scr_crypto_defer_bytes(ScrBytes *value /* moves */, ScrError *error /* moves */, ScrClosure *cb /* moves */,
                             ScrCryptoBytesFn fn);
 void scr_crypto_random_bytes_async(double size, ScrClosure *cb /* moves */,
                                    ScrCryptoBytesFn fn);
 void scr_crypto_pbkdf2_async(ScrBytes *password, ScrBytes *salt,
                              double iterations, double keylen, ScrStr *digest,
                              ScrClosure *cb /* moves */, ScrCryptoBytesFn fn);
-/* One-shot raw digest/HMAC by algorithm name ("md5" | "sha1" | "sha256")
+void scr_crypto_hkdf_async(ScrStr *digest, ScrBytes *ikm, ScrBytes *salt,
+                           ScrBytes *info, double keylen, ScrClosure *cb, ScrCryptoBytesFn fn);
+void scr_crypto_scrypt_async(ScrBytes *password, ScrBytes *salt, double keylen,
+                             ScrDyn *options, ScrClosure *cb, ScrCryptoBytesFn fn);
+/* One-shot raw digest/HMAC by algorithm name ("md5", "sha1", and SHA-2)
  * — the island crypto shim's bridge (scr_island.c host hooks). Digest
- * bytes into out (≥32); returns the digest length, 0 for an unknown
+ * bytes into out (≥64); returns the digest length, 0 for an unknown
  * algorithm. */
 size_t scr_crypto_digest_raw(const char *alg, const unsigned char *data, size_t len,
-                             unsigned char out[32]);
+                             unsigned char out[64]);
 size_t scr_crypto_hmac_raw(const char *alg, const unsigned char *key, size_t keylen,
-                           const unsigned char *data, size_t len, unsigned char out[32]);
+                           const unsigned char *data, size_t len, unsigned char out[64]);
 /* The composed `new crypto.X509Certificate(data).fingerprint` read (the
  * handle never materializes): the SHA-1 of the DER, uppercase
  * colon-separated — PEM or raw-DER input; anything else throws Node's
@@ -3036,6 +3156,9 @@ ScrStr *scr_path_win32_to_namespaced_path(ScrStr *path);
  * The pair behind spawn's fd-stdio form. */
 double scr_fs_open(ScrStr *path, ScrStr *flags);
 double scr_fs_open_numeric(ScrStr *path, double flags, double mode);
+/* Engine callers supply the target OS's flags, rather than the frontend's
+ * portable constant mask. Argument validation happens before this seam. */
+double scr_fs_open_native(ScrStr *path, double flags, double mode);
 ScrFileHandle *scr_file_handle_open(ScrStr *path, ScrStr *flags, double mode);
 ScrFileHandle *scr_file_handle_retain(ScrFileHandle *h);
 void scr_file_handle_release(ScrFileHandle *h);
@@ -3043,6 +3166,12 @@ void *scr_file_handle_retain_v(void *p);
 void scr_file_handle_release_v(void *p);
 double scr_file_handle_fd(ScrFileHandle *h);
 void scr_file_handle_close(ScrFileHandle *h);
+ScrPromise *scr_file_handle_sync_promise(ScrFileHandle *h);
+ScrPromise *scr_file_handle_datasync_promise(ScrFileHandle *h);
+ScrPromise *scr_file_handle_truncate_promise(ScrFileHandle *h, double length);
+ScrPromise *scr_file_handle_chmod_promise(ScrFileHandle *h, double mode);
+double scr_file_handle_readv(ScrFileHandle *h, ScrArr *buffers, double position);
+double scr_file_handle_writev(ScrFileHandle *h, ScrArr *buffers, double position);
 double scr_file_handle_read(ScrFileHandle *h, ScrBytes *buf, double offset,
                             double length, double position, bool length_default);
 double scr_file_handle_write_bytes(ScrFileHandle *h, ScrBytes *buf,
@@ -3066,6 +3195,11 @@ double scr_fs_write_sync(double fd, ScrBytes *buf, double offset, double length,
                          double position);
 double scr_fs_write_str_sync(double fd, ScrStr *data, double position,
                              ScrStr *encoding);
+double scr_fs_readv_sync(double fd, ScrArr *buffers, double position);
+double scr_fs_writev_sync(double fd, ScrArr *buffers, double position);
+/* Unlike scalar readSync's zero-length fast path, a nonempty vector of
+ * empty views still tests the descriptor and positioned-read capability. */
+double scr_fs_read_zero(double fd, double position);
 void scr_fs_close(double fd);
 
 /* ── WHATWG URL (scr_url.c) ──────────────────────────────────────────
@@ -3084,6 +3218,10 @@ typedef struct ScrUrl ScrUrl;
 
 ScrUrl *scr_url_new(ScrStr *input); /* +1, or throws */
 ScrUrl *scr_url_new_base(ScrStr *input, ScrStr *base); /* +1, or throws */
+bool scr_url_can_parse(ScrStr *input);
+bool scr_url_can_parse_base(ScrStr *input, ScrStr *base);
+ScrDyn *scr_url_parse(ScrStr *input); /* +1 native URL or null; invalid URLs do not throw */
+ScrDyn *scr_url_parse_base(ScrStr *input, ScrStr *base);
 ScrUrl *scr_url_retain(ScrUrl *u);
 void scr_url_release(ScrUrl *u);
 void *scr_url_retain_v(void *p);
@@ -3211,6 +3349,7 @@ ScrBigInt *scr_bigint_shl(ScrBigInt *a, ScrBigInt *count);
 ScrBigInt *scr_bigint_shr(ScrBigInt *a, ScrBigInt *count);
 bool scr_bigint_eq(ScrBigInt *a, ScrBigInt *b);
 bool scr_bigint_eq_string(ScrBigInt *a, ScrStr *b); /* StringToBigInt failure is false */
+double scr_bigint_cmp_string(ScrBigInt *a, ScrStr *b); /* 2 = invalid StringToBigInt */
 double scr_bigint_cmp_f64(ScrBigInt *a, ScrBigInt *b); /* -1, 0, 1 */
 double scr_bigint_cmp_number(ScrBigInt *a, double b); /* -1, 0, 1; 2 = NaN */
 bool scr_bigint_truthy(ScrBigInt *value);
@@ -3438,6 +3577,8 @@ typedef enum {
   SCR_DYNH_DATE,           /* JavaScript Date with stable native identity */
   SCR_DYNH_ITERATOR,       /* live native array/string/byte iterator */
   SCR_DYNH_CONSOLE,        /* stored global console value */
+  SCR_DYNH_SEARCH_PARAMS,  /* live WHATWG URLSearchParams */
+  SCR_DYNH_FETCH_REQUEST,
   SCR_DYNH_COUNT,
 } ScrDynHandleTag;
 
@@ -3450,6 +3591,7 @@ typedef struct ScrDynTypedCast {
   void *ptr;
   void *(*retain)(void *);
   void (*release)(void *);
+  bool traced;
   struct ScrDynTypedCast *next;
 } ScrDynTypedCast;
 typedef struct ScrJsval ScrJsval; /* opaque island cell (C11 repeat; the
@@ -3510,7 +3652,7 @@ struct ScrDyn {
     ScrBigInt *bigint; /* owned (SCR_DYN_BIGINT) */
     /* Callbacks keep the optional symbol unit out of symbol-free binaries. */
     struct { ScrSym *value; void (*release)(ScrSym *); ScrStr *(*render)(ScrSym *); ScrStr *(*description)(ScrSym *); } symbol;
-    struct { size_t len; size_t cap; ScrDyn **items; struct ScrDyn *properties; bool sealed; bool frozen; } arr; /* owned */
+    struct { size_t len; size_t cap; ScrDyn **items; struct ScrDyn *properties; bool sealed; bool frozen; unsigned char *presence; } arr; /* owned; NULL presence means dense */
     struct {
       size_t len;
       size_t cap;
@@ -3526,10 +3668,7 @@ struct ScrDyn {
     /* SCR_DYN_FUNC: the boxed closure (owned) + its call descriptor. `sig`
      * and `name` are static compiler-emitted literals (never freed); name
      * may be NULL (anonymous — inspect prints [Function (anonymous)]).
-     * The dyn→closure edge is NOT visible to the cycle collector (ScrDyn
-     * has no trace header): trial deletion treats it as an external root,
-     * so nothing dangles — a cycle THROUGH a dyn-boxed function is merely
-     * never collected (documented divergence). */
+     * The dyn→closure ownership edge is traced by the cycle collector. */
     struct { ScrClosure *clo; ScrDynThunk thunk; const char *sig; const char *name; uint32_t arity; ScrClassObj *class_obj; } fn;
     /* Native handles normally keep conservative ownership edges. Sets
      * backed by cycle-capable maps expose their edge to the collector.
@@ -3553,6 +3692,7 @@ struct ScrDyn {
       ScrDyn *materialized;
       ScrDynTypedCast *casts;
       bool traced; /* native referent has a cycle header */
+      bool observed; /* native release reports this identity's disposal */
     } typed_ref;
     /* SCR_DYN_PROMISE: the retained promise. The boundary contract: it
      * settles with a dyn payload (SCR_EXC_REF ScrDyn fulfillment or a
@@ -3618,6 +3758,7 @@ ScrDyn *scr_dyn_obj_keys(const ScrDyn *v);
 ScrDyn *scr_dyn_for_in_keys(const ScrDyn *v);
 /* Snapshot all own string keys of a SCR_DYN_OBJ in JS order. Returns +1. */
 ScrDyn *scr_dyn_obj_own_keys(const ScrDyn *v);
+ScrDyn *scr_dyn_own_keys(const ScrDyn *value);
 ScrDyn *scr_dyn_get_own_property_names(const ScrDyn *value);
 ScrDyn *scr_dyn_get_own_property_symbols(const ScrDyn *value);
 /* Object.hasOwn over a dyn receiver: OBJ member presence, ARR index
@@ -3631,6 +3772,7 @@ bool scr_dyn_property_is_enumerable(const ScrDyn *value, const ScrStr *key);
  * and scalar/function/handle sources copy nothing. */
 ScrDyn *scr_dyn_assign(ScrDyn *target, const ScrDyn *src);
 ScrDyn *scr_dyn_copy_data_properties(ScrDyn *target, const ScrDyn *src);
+ScrDyn *scr_dyn_object_rest(const ScrDyn *source, const ScrDyn *excluded);
 ScrDyn *scr_dyn_copy_property_descriptors(ScrDyn *target, const ScrDyn *src);
 /* Variadic Object.assign (the spread-source form): the compiler packs
  * every source into one fresh dyn array — pack_push retains a plain
@@ -3665,9 +3807,12 @@ ScrDyn *scr_dyn_native_set(ScrMap *value); /* borrowed backing, +1 box */
 bool scr_dyn_native_set_is(const ScrDyn *value);
 ScrDyn *scr_dyn_native_map(ScrMap *value); /* borrowed backing, +1 box */
 bool scr_dyn_native_map_is(const ScrDyn *value);
+void scr_regex_reset_last_index(ScrRegex *re, double index);
 ScrRegex *scr_regex_new_checked(const ScrDyn *pattern, const ScrDyn *flags);
 ScrDyn *scr_dyn_native_url(ScrUrl *value);
 bool scr_dyn_native_url_is(const ScrDyn *value);
+ScrDyn *scr_dyn_native_search_params(ScrSearchParams *value);
+bool scr_dyn_native_search_params_is(const ScrDyn *value);
 bool scr_dyn_native_date_is(const ScrDyn *value);
 ScrDyn *scr_dyn_native_date_new(const ScrDyn *arguments);
 double scr_dyn_native_date_value(const ScrDyn *value);
@@ -3681,6 +3826,7 @@ ScrSym *scr_sym_well_known(ScrStr *name);
 ScrDyn *scr_dyn_symbol_get(const ScrDyn *value, const ScrStr *key);
 ScrDyn *scr_dyn_symbol_key_get(const ScrDyn *value, const ScrDyn *key, bool optional);
 void scr_dyn_symbol_key_set(ScrDyn *value, ScrDyn *key, ScrDyn *stored);
+void scr_dyn_symbol_key_placeholder(ScrDyn *value, ScrDyn *key);
 bool scr_dyn_has_key_computed(const ScrDyn *value, const ScrDyn *key);
 bool scr_dyn_has_own_computed(const ScrDyn *value, const ScrDyn *key);
 bool scr_dyn_property_is_enumerable_computed(const ScrDyn *value, const ScrDyn *key);
@@ -3693,9 +3839,14 @@ ScrDyn *scr_dyn_increment(const ScrDyn *value, bool increment);
 ScrDyn *scr_dyn_symbol_ref(ScrSym *value, void (*release)(ScrSym *), ScrStr *(*render)(ScrSym *), ScrStr *(*description)(ScrSym *));
 ScrDyn *scr_dyn_new_str(ScrStr *s);
 ScrDyn *scr_dyn_new_arr(void);
+ScrDyn *scr_dyn_array_constructor(void);
+bool scr_dyn_arr_has_index(const ScrDyn *arr, size_t index);
+void scr_dyn_arr_push_hole(ScrDyn *arr);
 ScrDyn *scr_dyn_new_obj(void);
 ScrDyn *scr_dyn_iterator(const ScrDyn *value, const ScrStr *spell);
+ScrDyn *scr_dyn_iterator_optional(const ScrDyn *value);
 void scr_dyn_install_iterator_symbol(ScrDyn *key);
+void scr_dyn_install_async_iterator_symbol(ScrDyn *key);
 ScrDyn *scr_dyn_array_values_function(void);
 ScrDyn *scr_dyn_array_from_iterator(const ScrDyn *value);
 ScrDyn *scr_dyn_iterator_result(ScrDyn *value);
@@ -3721,6 +3872,7 @@ bool scr_dyn_is_extensible(ScrDyn *object);
 ScrDyn *scr_dyn_seal(ScrDyn *object);
 bool scr_dyn_is_sealed(const ScrDyn *object);
 ScrDyn *scr_dyn_proxy_new(const ScrDyn *target, const ScrDyn *handler);
+bool scr_dyn_is_callable(const ScrDyn *value);
 ScrDyn *scr_dyn_proxy_get(const ScrDyn *proxy, const ScrStr *key);
 bool scr_dyn_proxy_has(const ScrDyn *proxy, const ScrStr *key);
 ScrDyn *scr_dyn_own_descriptor(const ScrDyn *value, const ScrStr *key);
@@ -3730,6 +3882,11 @@ void scr_dyn_proxy_unsupported(const char *operation);
 /* Retains the native view, preserving identity and its shared backing
  * allocation across the checked-dynamic boundary. Borrows b. */
 ScrDyn *scr_dyn_new_bytes(const ScrBytes *b);
+ScrDyn *scr_bytes_constructor(const ScrStr *name);
+bool scr_bytes_instanceof(const ScrDyn *value, const ScrDyn *callee);
+bool scr_dyn_data_view_is(const ScrDyn *value);
+ScrDyn *scr_dyn_construct(const ScrDyn *callee, const ScrDyn *args, const ScrStr *what);
+ScrDyn *scr_bytes_construct(const ScrDyn *callee, const ScrDyn *args, const ScrStr *what);
 ScrDyn *scr_dyn_bytes_key_get(const ScrDyn *value, const ScrStr *key);
 /* The Buffer-flavored twin (stream chunks): string coercion/toString
  * decode utf8 instead of joining elements. */
@@ -3749,6 +3906,11 @@ ScrDyn *scr_dyn_new_typed_ref_traced(
     const char *type_key, size_t type_key_len,
     ScrDyn *(*materialize)(void *),
     void (*commit)(void *, const ScrDyn *));
+ScrDyn *scr_dyn_new_typed_ref_observed(
+    void *ptr, void *(*retain)(void *), void (*release)(void *),
+    const char *type_key, size_t type_key_len,
+    ScrDyn *(*materialize)(void *),
+    void (*commit)(void *, const ScrDyn *));
 bool scr_dyn_typed_ref_is(
     const ScrDyn *d, const char *type_key, size_t type_key_len);
 bool scr_dyn_typed_ref_is_key(const ScrDyn *d, const ScrStr *type_key);
@@ -3760,11 +3922,12 @@ void *scr_dyn_typed_ref_cached_cast(
     const ScrDyn *d, const char *type_key, size_t type_key_len); /* +1/NULL */
 void scr_dyn_typed_ref_cache_cast(
     ScrDyn *d, const char *type_key, size_t type_key_len, void *ptr,
-    void *(*retain)(void *), void (*release)(void *));
+    void *(*retain)(void *), void (*release)(void *), bool traced);
 /* Retains a SCR_DYN_BYTES view (+1) for checked extraction. */
 ScrBytes *scr_dyn_bytes_unbox(const ScrDyn *d);
 /* Exact numeric typed-array brand; elem is a ScrBytesElem tag. */
 bool scr_dyn_bytes_is(const ScrDyn *d, int elem);
+bool scr_dyn_typed_array_is(const ScrDyn *d, int elem);
 void scr_dyn_arr_push(ScrDyn *arr, ScrDyn *item);
 /* Spread completion for a runtime-arity argument list (`f(...xs)` in the
  * checked-dynamic tier): flattens `src` into `arr` per JS's spread over the
@@ -3780,6 +3943,7 @@ void scr_dyn_arr_push_spread(ScrDyn *arr, const ScrDyn *src, const char *what);
  * compile-time source spelling), else the runtime kind wording. Borrows
  * both; NULL with the exception pending on the throw. */
 ScrDyn *scr_dyn_iter_pack(const ScrDyn *src, const ScrStr *msg);
+ScrDyn *scr_dyn_jsval_iter_n(const ScrDyn *src, double count);
 /* Map constructor seeds: retain array inputs for live iteration, accept
  * nullish inputs as empty, and validate each entry before reading 0/1. */
 ScrDyn *scr_dyn_map_seed_entries(const ScrDyn *src);
@@ -3834,7 +3998,14 @@ ScrStr *scr_dyn_to_string(const ScrDyn *d, const ScrStr *enc);
  * null-prototype dictionary throws "<what> is not a function" — its
  * prototype chain has no toString (Node's answer). */
 ScrStr *scr_dyn_to_string_method(const ScrDyn *d, const ScrStr *enc, const ScrStr *what);
+ScrDyn *scr_dyn_object_prototype(void);
+ScrDyn *scr_dyn_function_apply(void);
+ScrDyn *scr_dyn_reflect_apply(ScrDyn *target, ScrDyn *receiver, ScrDyn *arguments_list);
+ScrDyn *scr_dyn_apply_array_like(const ScrDyn *target, const ScrDyn *receiver, const ScrDyn *arguments, const char *what);
+bool scr_dyn_same_value(const ScrDyn *left, const ScrDyn *right);
+ScrDyn *scr_dyn_builtin_method(const ScrStr *prototype, const ScrStr *method);
 ScrStr *scr_dyn_to_string_argument(const ScrDyn *d, const ScrDyn *argument, const ScrStr *what);
+ScrStr *scr_num_to_string_radix(double value, const ScrDyn *radix);
 /* JS String() over the dyn kind (units render "null"/"undefined" where
  * scr_dyn_to_string throws) — the web globals' WebIDL ToString. +1. */
 ScrStr *scr_dyn_string_coerce(const ScrDyn *d);
@@ -3847,8 +4018,11 @@ bool scr_dyn_number_coerce_js(const ScrDyn *d, double *out);
  * with the exception pending when an object hook throws/refuses. */
 double scr_dyn_number_coerce(const ScrDyn *d);
 double scr_dyn_number_constructor(const ScrDyn *d);
+ScrBigInt *scr_dyn_bigint_constructor(const ScrDyn *d);
+ScrBigInt *scr_dyn_bigint_coerce(const ScrDyn *d);
 ScrDyn *scr_dyn_add(const ScrDyn *left, const ScrDyn *right); /* borrowed; +1 or NULL/pending */
 ScrDyn *scr_dyn_arithmetic(const ScrDyn *left, const ScrDyn *right, const ScrStr *operation);
+bool scr_dyn_compare(const ScrDyn *left, const ScrDyn *right, const ScrStr *operation);
 ScrDyn *scr_dyn_bitwise(const ScrDyn *left, const ScrDyn *right, const ScrStr *operation);
 
 /* `d instanceof TypeError` (and the other builtin error classes) on a
@@ -3880,6 +4054,9 @@ void scr_sc_validate_options(const ScrDyn *options);
 /* An %Error as the boundary's dyn shape ({name, message[, code]}).
  * Borrows; +1. */
 ScrDyn *scr_dyn_from_error(const ScrError *e);
+void scr_error_register_dyn(const ScrVt *vt, ScrDyn *(*box)(void *));
+ScrDyn *scr_error_dyn_fields(const ScrError *e);
+void scr_error_commit_dyn(ScrError *e, const ScrDyn *view);
 /* The reverse extraction, riding the same identity cache: a dyn error
  * that came from a runtime ScrError answers THAT instance (+1;
  * out-and-back crossings compare reference-equal); alien %error objects
@@ -3904,6 +4081,8 @@ bool scr_dyn_strict_eq(const ScrDyn *a, const ScrDyn *b);
  * a name the kind's prototype lacks throws Node's "<what> is not a
  * function"; OBJ receivers call the own member. recv/args borrowed,
  * result owned (+1). MAY THROW (NULL with the exception pending). */
+ScrDyn *scr_dyn_prepare_method(ScrDyn *recv, const char *method);
+ScrDyn *scr_dyn_invoke_prepared(ScrDyn *recv, ScrDyn *callee, const char *method, ScrDyn *const *args, size_t argc, const char *what);
 ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, size_t argc, const char *what);
 /* Keyed read on a FUNC node: the own-property table first (defineProperties
  * writes land there), then "name" (the box's best-effort static name; ""
@@ -3917,11 +4096,13 @@ ScrDyn *scr_dyn_fn_get(const ScrDyn *d, const char *key, size_t key_len);
  * Returns the target (+1, JS's return), or NULL with a pending catchable
  * TypeError (non-object target/descriptor — Node's messages). */
 ScrDyn *scr_dyn_define_props(ScrDyn *target, ScrDyn *descs);
+ScrDyn *scr_dyn_define_prototype_props(ScrDyn *target, ScrDyn *descs, ScrDyn *protected_keys);
 /* Boxes a closure as a callable dyn value. Ownership of `clo` MOVES in
  * (callers retain first when they keep their own reference); `sig`/`name`
  * must be static literals (the box never frees them; name may be NULL). */
 ScrDyn *scr_dyn_new_func(ScrClosure *clo, ScrDynThunk thunk, uint32_t arity, const char *sig, const char *name);
 ScrDyn *scr_dyn_new_class(ScrClassObj *cls, const char *type_key);
+bool scr_dyn_class_is_key(const ScrDyn *value, const ScrStr *type_key);
 bool scr_dyn_class_is(const ScrDyn *value, const char *type_key);
 /* Calls a dyn value: a non-function kind throws the catchable TypeError
  * "<what> is not a function" (Node's wording — `what` is the call site's
@@ -3945,8 +4126,12 @@ typedef struct ScrDynPath {
   const char *key;
   size_t index;
 } ScrDynPath;
+ScrSearchParams *scr_dyn_native_search_params_check(const ScrDyn *value, const ScrDynPath *path);
+ScrSearchParams *scr_sp_new_checked(const ScrDyn *value);
 ScrMap *scr_dyn_native_set_check(const ScrDyn *value, const ScrDynPath *path);
 ScrMap *scr_dyn_native_map_check(const ScrDyn *value, const ScrDynPath *path);
+bool scr_dyn_native_collection_is(const ScrDyn *value, int map, const char *type);
+ScrMap *scr_dyn_native_collection_check(const ScrDyn *value, int map, const char *type, const ScrDynPath *path);
 ScrStr *scr_url_checked_to_path(const ScrDyn *value);
 ScrUrl *scr_dyn_native_url_check(const ScrDyn *value, const ScrDynPath *path);
 ScrRegex *scr_dyn_native_regex_check(const ScrDyn *value, const ScrDynPath *path);
@@ -3996,7 +4181,10 @@ typedef struct ScrDynHandleOps {
   /* Immutable native iterables may drain into a fresh array. Mutable or
    * effectful iterators need a separate step/close protocol. NULL = not iterable. */
   ScrDyn *(*iter_pack)(void *h);
+  /* A live native iterator step; index advances only when a value is emitted. */
+  ScrDyn *(*iter_step)(void *h, double *index, unsigned selection);
 } ScrDynHandleOps;
+ScrDyn *scr_dyn_native_handle_iterator(ScrDyn *source, unsigned selection);
 
 ScrDyn *scr_intl_segmenter_new(void);
 ScrStr *scr_process_builtin_id(ScrDyn *id, ScrArr *known);
@@ -4049,6 +4237,7 @@ ScrDyn *scr_dyn_new_promise_adapting(ScrPromise *src,
                                      void (*adapt)(ScrPromise *dst, ScrPromise *src));
 /* BORROWED peek at the boxed promise; NULL when d is not a promise box. */
 ScrPromise *scr_dyn_promise_of(const ScrDyn *d);
+ScrPromise *scr_dyn_promise_all(const ScrDyn *entries);
 
 /* ── island values in the checked-dynamic tree (SCR_DYN_JSVAL) ─────────────────────────
  * Engine routing ops for JSVAL nodes, installed by the gated constructor
@@ -4108,6 +4297,7 @@ typedef struct ScrDynJsvalOps {
    * pending. */
   ScrDyn *(*iter_drain)(ScrJsval *cell, bool spread, const ScrStr *spell);
   ScrDyn *(*iterator)(ScrJsval *cell, const ScrStr *spell, bool array_from);
+  ScrDyn *(*iter_n)(ScrJsval *cell, double count);
 } ScrDynJsvalOps;
 
 /* The allocator view the gated constructor uses (installs the ops);
@@ -4165,6 +4355,7 @@ void scr_dyn_this_pop(void);
  * handle whose tag has no installed ops — a unit that fires without its
  * dyn half never binds). */
 ScrDyn *scr_dyn_this_get(void);
+ScrDyn *scr_gen_receiver(void);
 
 /* The data-chunk encoding window (setEncoding — scr_json.c's note): the
  * firing site opens/closes it around a 'data' pass; scr_dyn_new_chunk
@@ -4321,6 +4512,8 @@ long scr_obj_live_count(void);
  * tiebreaks) drives everything after %main returns. See scr_async.c.
  */
 ScrPromise *scr_promise_new(void);
+void scr_promise_share_identity(ScrPromise *dst, ScrPromise *src);
+bool scr_promise_identity_equal(ScrPromise *a, ScrPromise *b);
 ScrPromise *scr_promise_retain(ScrPromise *p);
 void scr_promise_release(ScrPromise *p);
 void *scr_promise_retain_v(void *p);
@@ -4373,6 +4566,8 @@ void scr_promise_rethrow_top_level(ScrPromise *p);
  * payload as a dyn value (+1; void fulfillments answer the undefined
  * value), or NULL with the rejection re-thrown into the awaiter. */
 ScrDyn *scr_await_dyn(ScrPromise *p);
+ScrDyn *scr_await_dyn_value_settled(ScrDyn *value);
+void scr_promise_resolve_dyn(ScrPromise *destination, ScrDyn *value);
 /* `await v` over a checked-dynamic VALUE: dyn promises adopt, everything
  * else takes JS's one-hop non-thenable await and answers itself (+1). */
 ScrDyn *scr_await_dyn_value(ScrDyn *v);
@@ -4859,6 +5054,11 @@ long scr_promise_live_count(void);
  * --dynamic the same TU boots the broader engine web surface. The
  * emitted main calls scr_fetch_install in either form. */
 void scr_fetch_install(void);
+ScrPromise *scr_fetch_input(ScrDyn *input, ScrDyn *init);
+ScrDyn *scr_fetch_function(void);
+void scr_global_fetch_install(ScrDyn *(*get)(void));
+ScrDyn *scr_fetch_request_new(ScrDyn *input, ScrDyn *init);
+ScrDyn *scr_fetch_headers_new(ScrDyn *init);
 ScrPromise *scr_fetch_static(ScrStr *url, ScrDyn *init); /* +1 promise<Response handle> */
 ScrDyn *scr_fetch_response_new(ScrDyn *body, ScrDyn *init); /* borrowed args; +1 Response handle or NULL pending */
 ScrPromise *scr_fetch_response_json(ScrDyn *response); /* +1 promise<dyn> */
@@ -5437,8 +5637,8 @@ double scr_bit_not(double a);
  * construction (owners point at nothing): never part of a cycle, no
  * trace. Element reads widen to double; writes coerce JS-exactly (ToUint8
  * / ToUint32 modular truncation, double→float rounding for f32).
- * Out-of-bounds ELEMENT access traps like arrays (JS returns undefined /
- * ignores the write — documented divergence); the Node-shaped operations
+ * Out-of-bounds typed ELEMENT reads trap like arrays; invalid writes are
+ * ignored as in JavaScript. The Node-shaped operations
  * (construction lengths, set(), the read/write numeric families, the
  * DataView constructor and getters) THROW catchable RangeErrors exactly
  * where Node throws. */
@@ -5466,6 +5666,7 @@ typedef struct ScrBytes {
    * points into backing->data — released, never freed. */
   struct ScrBytes *backing;
   bool is_buffer; /* Buffer brand belongs to the view, not its backing. */
+  bool is_data_view; /* DataView is distinct from a numeric typed array. */
   bool external; /* Root aliases foreign memory; releasing it never frees data. */
 } ScrBytes;
 
@@ -5511,6 +5712,7 @@ ScrBytes *scr_bytes_as_buffer(ScrBytes *bytes); /* borrows; +1, Buffer factory o
  * byte storage, including when src is itself a subarray. */
 ScrBytes *scr_bytes_buffer_view(ScrBytes *src, ScrBytesElem elem,
                                double offset, bool has_len, double length);
+ScrDyn *scr_array_buffer_constructor(void);
 ScrDyn *scr_array_buffer_new(ScrDyn *length);
 ScrDyn *scr_array_buffer_from_bytes(ScrBytes *view);
 bool scr_array_buffer_is(const ScrDyn *value);
@@ -5594,9 +5796,8 @@ double scr_dataview_get(const ScrBytes *b, double byte_off, ScrDataViewGet kind,
  * with the getters' one RangeError. */
 void scr_dataview_set(ScrBytes *b, double byte_off, double value, ScrDataViewGet kind, bool le);
 
-/* Element read/write. Any invalid index — negative, fractional, NaN, or
- * out of bounds — TRAPS like the array runtime (SEMANTICS.md documents
- * the divergence from JS's undefined-read/ignored-write). Writes coerce
+/* Element read/write. Invalid typed reads trap; invalid writes are ignored.
+ * Checked reads preserve JavaScript's undefined result. Valid writes coerce
  * JS-exactly: u8/u32 by modular truncation (NaN/±Infinity → 0, truncate
  * toward zero, wrap mod 2^8/2^32), f32 by double→float rounding. */
 double scr_bytes_get(const ScrBytes *b, double i);
@@ -5673,6 +5874,17 @@ ScrStr *scr_bytes_to_str_checked_range(const ScrBytes *b, const ScrStr *enc, dou
  * same replacement decode as toString("utf8") with the leading BOM
  * stripped. Borrows; +1; never throws. */
 ScrStr *scr_text_decode(const ScrBytes *b);
+double scr_text_decoder_encoding(const ScrDyn *label);
+ScrStr *scr_text_decoder_name(double encoding);
+ScrDyn *scr_text_encode_into(const ScrDyn *source, const ScrDyn *destination);
+bool scr_buffer_is_ascii(const ScrDyn *input);
+bool scr_buffer_is_utf8(const ScrDyn *input);
+ScrBytes *scr_buffer_transcode(const ScrDyn *source, const ScrDyn *from, const ScrDyn *to);
+ScrBytes *scr_bytes_buffer_source(const ScrDyn *value);
+ScrStr *scr_text_decode_buffer_source(const ScrDyn *value);
+ScrStr *scr_text_decode_options(const ScrBytes *b, bool fatal, bool ignore_bom);
+ScrStr *scr_text_decode_stream(ScrDyn *state, const ScrBytes *b, double encoding, bool fatal, bool ignore_bom, bool stream);
+ScrStr *scr_text_decode_legacy_options(const ScrBytes *b, double encoding, bool fatal, bool ignore_bom);
 
 /* TextDecoder with a compile-time WHATWG legacy-encoding id. The frontend
  * owns label canonicalization and emits only the ids understood by
@@ -5693,6 +5905,7 @@ ScrBytes *scr_bytes_from_str(const ScrStr *s, const ScrStr *enc);
  * Buffer.isEncoding(name) (case-insensitive over Node's alias set).
  * Borrow; never throw. */
 double scr_bytes_byte_length_str(ScrStr *s, const ScrStr *enc);
+double scr_buffer_byte_length_dyn(ScrDyn *value, ScrStr *enc);
 bool scr_bytes_is_encoding(const ScrStr *s);
 
 /* equals / compare / indexOf-lastIndexOf / fill / copy / swap / write on
@@ -5868,6 +6081,8 @@ ScrBytes *scr_fs_read_file_bytes(ScrStr *path); /* +1 */
  * value — a Buffer box for undefined/null, a string for utf8 — or NULL
  * with the exception pending. */
 ScrDyn *scr_fs_read_file_sync_dyn(ScrStr *path, const ScrDyn *enc);
+ScrDyn *scr_fs_callback_value(ScrStr *member);
+ScrDyn *scr_fs_callback_call(ScrStr *member, const ScrDyn *args);
 ScrBytes *scr_fs_read_fd_bytes(double fd);      /* +1; the fd form (scr_lib.c) */
 void scr_fs_write_file_bytes(ScrStr *path, const ScrBytes *data);
 void scr_fs_append_file_bytes(ScrStr *path, const ScrBytes *data);
@@ -7163,10 +7378,8 @@ void scr_assert_iferror_bool(bool b);
  * %error-marked objects throw with the error's message, everything else
  * with the inspection. */
 void scr_assert_iferror_dyn(const ScrDyn *v);
-/* assert.match / assert.doesNotMatch (scr_regex.c): a fresh exec from
- * index 0 — Node's exec on a fresh regex; lastIndex statefulness is not
- * modeled (SEMANTICS.md's regex stance), so g/y-flagged regexes test like
- * their flag-free twins instead of aborting. */
+/* assert.match / assert.doesNotMatch (scr_regex.c): RegExp.test semantics,
+ * including global/sticky lastIndex transitions. */
 void scr_assert_match(ScrStr *s, ScrRegex *re, bool negated, ScrStr *msg, bool has_msg);
 /* assert.throws(fn, /regex/) whose thrown ERROR did not match: Node tests
  * String(actual) ("Name: message") and reports the regex-mismatch message
@@ -7204,4 +7417,7 @@ void scr_console_log(size_t n, const ScrLogArg *args);
  * keeps source order. */
 void scr_console_error(size_t n, const ScrLogArg *args);
 
+bool scr_fetch_web_is(const ScrDyn *value, const ScrStr *name);
+bool scr_fetch_stream_is(const ScrDyn *value);
+
 #endif /* SCR_RUNTIME_H */