@scriptc/cli-darwin-arm64 0.2.2 → 0.2.4

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

@@ -420,13 +420,6 @@ void scr_regex_reset_last_index(ScrRegex *re, double index) {
   re->last_index = index;
 }
 
-bool scr_regex_test(ScrRegex *re, ScrStr *s) {
-  ScrArr *result = scr_regex_exec(s, re);
-  bool matched = result != NULL;
-  scr_arr_release(result);
-  return matched;
-}
-
 static int scr_regex_start(ScrRegex *re, int len) {
   double index = re->last_index;
   if (isnan(index) || index <= 0) return 0;
@@ -434,6 +427,43 @@ static int scr_regex_start(ScrRegex *re, int len) {
   return (int)floor(index);
 }
 
+/* A predicate needs only the match boundary, not the captured strings or
+ * result metadata. Short ASCII subjects already have the engine's one-byte
+ * representation. Bound that scan so a long mixed-text subject does not
+ * traverse an ASCII prefix twice before matching. Other subjects use exec's
+ * UTF-16 conversion. Register storage is bounded by alloc_count, not captures. */
+bool scr_regex_test(ScrRegex *re, ScrStr *s) {
+  uint8_t *bc = scr_regex_bc(re);
+  bool ascii = s->len <= 256;
+  size_t i = 0;
+  for (; ascii && s->len - i >= sizeof(uint64_t); i += sizeof(uint64_t)) {
+    uint64_t word;
+    memcpy(&word, s->data + i, sizeof word);
+    if (word & UINT64_C(0x8080808080808080)) ascii = false;
+  }
+  for (; ascii && i < s->len; i++) {
+    if ((unsigned char)s->data[i] >= 0x80) ascii = false;
+  }
+  int len;
+  uint16_t *converted = ascii ? NULL : scr_to_utf16(s, &len);
+  const uint8_t *subject = ascii ? (const uint8_t *)s->data : (const uint8_t *)converted;
+  if (ascii) len = (int)s->len;
+  uint8_t *registers[32];
+  uint8_t **capture = lre_get_alloc_count(bc) <= 32 ? registers : scr_capture_alloc(bc);
+  bool stateful = (lre_get_flags(bc) & (LRE_FLAG_GLOBAL | LRE_FLAG_STICKY)) != 0;
+  int pos = stateful ? scr_regex_start(re, len) : 0;
+  int rc = pos < 0 ? 0 : lre_exec(capture, bc, subject, pos, len, ascii ? 0 : 1, lre_opaque());
+  if (rc < 0) {
+    fflush(stdout);
+    scr_trap("scriptc: regular expression execution failed\n");
+  }
+  if (stateful) re->last_index = rc == 1
+    ? (double)((capture[1] - subject) >> (ascii ? 0 : 1)) : 0;
+  if (capture != registers) free(capture);
+  free(converted);
+  return rc == 1;
+}
+
 /* ── match ────────────────────────────────────────────────────────────── */
 
 /* re.exec(s): a fresh string[] of [whole match, ...captures], or NULL
@@ -719,6 +749,60 @@ ScrStr *scr_regex_replace(ScrStr *s, ScrRegex *re, ScrStr *rep) {
   return scr_replace_impl(s, re, rep);
 }
 
+
+/* The pinned Node ANSI matcher derives from ansi-regex, copyright (c)
+ * Sindre Sorhus <sindresorhus@gmail.com>, used under the MIT license:
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ * Keep the pattern equivalent to Node v24.15.0 internal/util/inspect.js. */
+#define SCR_VT_PATTERN "[\\u001B\\u009B][[\\]()#;?]*" \
+  "(?:(?:(?:(?:;[-a-zA-Z\\d\\/\\#&.:=?%@~_]+)*" \
+  "|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/\\#&.:=?%@~_]*)*)?" \
+  "(?:\\u0007|\\u001B\\u005C|\\u009C))" \
+  "|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"
+
+ScrStr *scr_util_strip_vt(const ScrDyn *input) {
+  if (!input || input->kind != SCR_DYN_STR) {
+    scr_dyn_arg_type_fail("str", "of type string", input ? input : scr_dyn_undefined());
+    return NULL;
+  }
+  ScrStr *subject = input->v.str;
+  bool escape = false;
+  for (size_t i = 0; i < subject->len; i++) {
+    if (subject->data[i] == '\x1b' || ((unsigned char)subject->data[i] == 0xc2 &&
+        i + 1 < subject->len && (unsigned char)subject->data[i + 1] == 0x9b)) {
+      escape = true;
+      break;
+    }
+  }
+  if (!escape) return scr_str_retain(subject);
+  static const struct { size_t rc, len, cap; char data[sizeof SCR_VT_PATTERN]; }
+    source = { SIZE_MAX, sizeof SCR_VT_PATTERN - 1, sizeof SCR_VT_PATTERN - 1, SCR_VT_PATTERN };
+  static const struct { size_t rc, len, cap; char data[2]; }
+    flags = { SIZE_MAX, 1, 1, "g" };
+  static SCR_TL ScrRegex template = { SIZE_MAX, (ScrStr *)&source, (ScrStr *)&flags, NULL, 0, NULL };
+  ScrRegex *regex = scr_regex_literal(&template);
+  ScrStr *empty = scr_str_new("", 0);
+  ScrStr *result = scr_regex_replace(subject, regex, empty);
+  scr_str_release(empty);
+  scr_regex_release(regex);
+  return result;
+}
+#undef SCR_VT_PATTERN
+
 ScrStr *scr_regex_replace_all(ScrStr *s, ScrRegex *re, ScrStr *rep) {
   if (!(lre_get_flags(scr_regex_bc(re)) & LRE_FLAG_GLOBAL)) {
     /* Node's exact TypeError — a real instance now: catch bindings narrow
@@ -1058,6 +1142,17 @@ bool scr_assert_regex_err_test(ScrRegex *re, ScrError *err) {
   return matched;
 }
 
+bool scr_assert_regex_dyn_test(ScrRegex *re, ScrDyn *actual) {
+  // String(symbol) accepts a direct Symbol; object conversion uses the
+  // string hint, including Symbol.toPrimitive and custom Error formatters.
+  ScrStr *str = actual->kind == SCR_DYN_SYMBOL
+    ? scr_dyn_string_constructor(actual) : scr_util_to_usv_string(actual);
+  if (!str) return false;
+  bool matched = scr_assert_regex_hits(re, str);
+  scr_str_release(str);
+  return matched;
+}
+
 /* The regex-valued shape slot (assert.throws(fn, {message: /re/})):
  * test the stashed actual key eagerly and store verdict + rendering, so
  * scr_assert.c's comparison and diff stay libregexp-free. An absent
@@ -1105,7 +1200,16 @@ ScrRegex *scr_regex_new(ScrStr *pattern, ScrStr *flags) {
   }
   re->rc = 1;
   re->source = pattern->len > 0 ? scr_str_retain(pattern) : scr_str_new("(?:)", 4);
-  re->flags = scr_str_retain(flags);
+  /* Public flags use getter order, independently of constructor spelling.
+   * Validate first so duplicates and invalid flags retain their errors. */
+  char canonical[6];
+  size_t flag_count = 0;
+  const char *order = "gimsuy";
+  for (unsigned i = 0; i < 6; i++) {
+    if (seen_flags & (1u << i)) canonical[flag_count++] = order[i];
+  }
+  re->flags = flag_count == flags->len && memcmp(canonical, flags->data, flag_count) == 0
+    ? scr_str_retain(flags) : scr_str_new(canonical, flag_count);
   /* Eager compile — the literal path stays lazy (its failure is an
    * abort; tsc already parsed those patterns). */
   int lre_flags = scr_lre_flags(re->flags);

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

@@ -297,7 +297,7 @@ void scr_library_bytes_out(ScrBytes *b, const uint8_t **out, size_t *out_len);
  * The collector is synchronous Bacon–Rajan trial deletion: a release that
  * leaves a candidate's rc above zero buffers it as a possible cycle root;
  * collection walks the buffer (markGray: trial-decrement internal edges;
- * scan: restore externally-referenced subgraphs; collectWhite: free the
+ * scan: restore externally-referenced subgraphs; gather: free the
  * dead cycle members, releasing only edges that LEAVE the white set).
  * It is GENERATIONAL: each header carries a generation, a pass names the
  * oldest one it will walk, and objects that survive a pass are promoted out
@@ -322,9 +322,9 @@ typedef void (*ScrTraceVisit)(void *child, void *ctx);
 typedef void (*ScrTraceFn)(void *obj, ScrTraceVisit visit, void *ctx);
 typedef void (*ScrCycFreeFn)(void *obj);
 
-/* DOOMED is WHITE that collectWhite has already gathered: it stops the
- * gather recursing twice, and distinguishes "about to be freed" from a
- * survivor for the re-buffering step (see scr_cycle.c). */
+/* DOOMED identifies the gathered dead set during re-buffering and weak
+ * observer teardown. WHITE candidates may still become black when a later
+ * outside root restores them; only the settled white set becomes DOOMED. */
 enum {
   SCR_CYC_BLACK = 0, SCR_CYC_PURPLE = 1, SCR_CYC_GRAY = 2, SCR_CYC_WHITE = 3,
   SCR_CYC_DOOMED = 4
@@ -437,7 +437,7 @@ typedef struct ScrVt {
  *
  * cap is the usable byte capacity of data[] excluding the NUL (allocation
  * is sizeof(ScrStr) + cap + 1); cap == len for interned literals and plain
- * allocations. Spare capacity (cap > len) exists only on concat results so
+ * allocations. Builders and concat results may have spare capacity so
  * scr_str_concat can append in place when the left operand is uniquely
  * owned (rc == 1) — observable immutability is preserved: a string with
  * rc > 1 or rc == SIZE_MAX is never mutated.
@@ -454,7 +454,7 @@ ScrStr *scr_str_new(const char *bytes, size_t len); /* returns +1 */
  * malformed subsequences with U+FFFD. NULL with len == 0 is an empty span. */
 ScrStr *scr_str_from_utf8_lossy(const uint8_t *bytes, size_t len); /* +1 */
 
-/* Internal allocators for buffer builders (scr_json.c): a +1 string with
+/* Internal allocators for buffer builders: a +1 string with
  * UNINITIALIZED data (the builder fills bytes, then len and the NUL), and
  * an rc==1-only realloc that grows capacity in place. Both keep the RC
  * audit's live count exact. */
@@ -470,6 +470,8 @@ void scr_str_release(ScrStr *s); /* NULL-tolerant (uninitialized locals) */
 
 /* Borrow both args, return +1. */
 ScrStr *scr_str_concat(ScrStr *a, ScrStr *b);
+/* Borrow each part without mutation; return one independently owned result. */
+ScrStr *scr_str_concat_parts(ScrStr *const *parts, size_t count);
 
 bool scr_str_eq(ScrStr *a, ScrStr *b);
 
@@ -818,6 +820,11 @@ ScrStr *scr_str_pad_end(ScrStr *s, double maxLength, ScrStr *fill);
  * both are no-ops on well-formed input). Borrow s; toWellFormed +1. */
 bool scr_str_is_well_formed(ScrStr *s);
 ScrStr *scr_str_to_well_formed(ScrStr *s);
+/* Node text utilities: borrowed input, +1 result or NULL+pending. The VT
+ * helper lives in the optional regex unit; USV conversion uses native strings. */
+ScrStr *scr_util_strip_vt(const struct ScrDyn *input);
+ScrStr *scr_util_to_usv_string(const struct ScrDyn *input);
+void scr_dyn_install_to_primitive_symbol(struct ScrDyn *key);
 
 /* RegExp.escape(s) — ES2025 EncodeForRegExpEscape per code point: leading
  * ASCII alphanumeric hex-escapes, SyntaxCharacters and '/' take a
@@ -911,11 +918,22 @@ void scr_qs_parse_into(ScrMap *out, const ScrStr *qs, const ScrStr *sep,
  * a fresh ParsedResults object whose `values` child has null prototype.
  * Borrows config; returns +1, or NULL with a Node-coded TypeError pending. */
 struct ScrDyn *scr_util_parse_args(const struct ScrDyn *config);
+ScrStr *scr_util_style_text(const struct ScrDyn *format, const struct ScrDyn *text, const struct ScrDyn *options);
+
+/* Node/libuv system error utilities. Arguments are checked without coercion;
+ * entries is a fresh array of [number, [name, message]] pairs (+1). */
+ScrStr *scr_util_system_error_name(const struct ScrDyn *error);
+ScrStr *scr_util_system_error_message(const struct ScrDyn *error);
+struct ScrDyn *scr_util_system_error_entries(void);
 
 /* 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);
+/* Checked primitives, ordinary records/arrays and byte views. Opaque native
+ * objects and accessor descriptors retain explicit catchable refusals. */
+bool scr_util_is_deep_strict_equal(const struct ScrDyn *a, const struct ScrDyn *b,
+                                  const struct ScrDyn *skip_prototype);
 void scr_process_load_env_file(const struct ScrDyn *path);
 
 /* querystring.stringify — Node's stringify over a borrowed dyn value (the
@@ -1119,6 +1137,10 @@ double scr_arr_get_number(const ScrArr *a, double i);
 bool scr_arr_index_eq(const ScrArr *a, double i, const ScrArr *b, double j);
 bool scr_arr_get_bool(ScrArr *a, double i);  /* trap missing/hole */
 void *scr_arr_get_ref(ScrArr *a, double i);  /* trap missing/hole; +1 */
+/* Borrow a non-null reference element, or NULL for a hole/undefined/missing
+ * property. Keep the array alive and retain before removing its element.
+ * This read does not invoke retain callbacks or mutate runtime state. */
+void *scr_arr_peek_ref(const ScrArr *a, double i);
 
 /* i == len appends; the _ref variant releases the old element (when
  * replacing) and takes ownership of the new one. */
@@ -1301,10 +1323,10 @@ ScrArr *scr_regex_match_all_into(ScrStr *s, ScrRegex *re, ScrArr *indices);
  * are visited (they append), deleted entries are skipped (tombstones), and
  * a delete + re-add moves the key to the end (Node-verified).
  *
- * Keys are identity references, string (content), or number with SameValueZero: NaN equals NaN
- * (canonicalized before hashing) and -0 is normalized to +0 at insertion,
- * exactly like JS (a stored -0 key reads back as +0). Hash is FNV-1a over
- * the reference address, string bytes, or canonicalized f64 bit pattern.
+ * Primitive keys compare by value and reference keys by identity. Numbers
+ * use SameValueZero: NaN equals NaN and -0 is stored as +0. Union wrappers
+ * are representations, never identities; their arm descriptors select
+ * the primitive or reference comparison, including null and undefined.
  *
  * Values are one uniform kind per map (like ScrArr elements): f64, bool, or
  * a refcounted pointer whose RC entry points arrive as function pointers at
@@ -1331,13 +1353,17 @@ ScrArr *scr_regex_match_all_into(ScrStr *s, ScrRegex *re, ScrArr *indices);
  * DYN owns a checked-value box and compares its JavaScript value using
  * SameValueZero, including reference identity for object payloads.
  * These key kinds serve both Maps and Sets. */
-typedef enum { SCR_MAP_KEY_F64, SCR_MAP_KEY_STR, SCR_MAP_KEY_REF, SCR_MAP_KEY_UNION_REF, SCR_MAP_KEY_DYN } ScrMapKeyKind;
+typedef enum {
+  SCR_MAP_KEY_F64, SCR_MAP_KEY_STR, SCR_MAP_KEY_REF, SCR_MAP_KEY_UNION_REF, SCR_MAP_KEY_DYN,
+  SCR_MAP_KEY_BIGINT, SCR_MAP_KEY_BOOL, SCR_MAP_KEY_UNION_VALUE,
+  SCR_MAP_KEY_NULL, SCR_MAP_KEY_UNDEFINED /* tag-only union arms */
+} ScrMapKeyKind;
 typedef enum { SCR_MAP_VAL_F64, SCR_MAP_VAL_BOOL, SCR_MAP_VAL_REF } ScrMapValKind;
 
 typedef struct {
   uint64_t key; /* double bits (normalized), ScrStr* (owned), or ref ptr (owned) */
   uint64_t val; /* double bits, bool, or owned pointer */
-  bool live;    /* false = tombstone (key/val already released) */
+  uint64_t hash; /* nonzero cached hash; zero = tombstone (key/val released) */
 } ScrMapEntry;
 
 /* Checked views use the original storage. Slot converters borrow on reads
@@ -1360,7 +1386,7 @@ typedef struct ScrMap {
   void *(*val_retain)(void *);
   void (*val_release)(void *);
   ScrTraceFn val_trace;
-  /* SCR_MAP_KEY_REF, SCR_MAP_KEY_UNION_REF and SCR_MAP_KEY_DYN only. */
+  /* Reference-represented keys, including bigint and union values. */
   void *(*key_retain)(void *);
   void (*key_release)(void *);
   ScrTraceFn key_trace;
@@ -1372,8 +1398,17 @@ typedef struct ScrMap {
   size_t *buckets;  /* entry indices; SIZE_MAX = empty */
   size_t iter_depth; /* > 0: an iteration is active — no compaction */
   const ScrMapDynOps *dyn_ops;
+  const uint8_t *union_keys; /* immutable key-kind table indexed by union tag */
 } ScrMap;
 
+/* Called once on a fresh UNION_VALUE collection, before its first insert. */
+void scr_map_union_keys(ScrMap *map, const uint8_t *kinds);
+/* Fresh shallow copies with compact storage and independent mutation.
+ * keys_only selects a Set; checked views materialize their boxed values. */
+ScrMap *scr_map_clone(const ScrMap *source, bool keys_only);
+ScrMap *scr_map_clone_dyn(const ScrMap *source, bool keys_only);
+void scr_map_values_into(ScrMap *set, const ScrMap *source, bool checked);
+
 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);
@@ -1406,9 +1441,11 @@ double scr_map_size(const ScrMap *m); /* live entries (Map.size) */
 void scr_map_clear(ScrMap *m);
 
 bool scr_map_has_f64(const ScrMap *m, double key);
+bool scr_map_has_bool(const ScrMap *m, bool key);
 bool scr_map_has_str(const ScrMap *m, const ScrStr *key);
 bool scr_map_has_ref(const ScrMap *m, const void *key);
 bool scr_map_delete_f64(ScrMap *m, double key);
+bool scr_map_delete_bool(ScrMap *m, bool key);
 bool scr_map_delete_str(ScrMap *m, const ScrStr *key);
 bool scr_map_delete_ref(ScrMap *m, const void *key);
 
@@ -1418,6 +1455,9 @@ bool scr_map_delete_ref(ScrMap *m, const void *key);
 void scr_map_set_f64_f64(ScrMap *m, double key, double v);
 void scr_map_set_f64_bool(ScrMap *m, double key, bool v);
 void scr_map_set_f64_ref(ScrMap *m, double key, void *v);
+void scr_map_set_bool_f64(ScrMap *m, bool key, double v);
+void scr_map_set_bool_bool(ScrMap *m, bool key, bool v);
+void scr_map_set_bool_ref(ScrMap *m, bool key, void *v);
 void scr_map_set_str_f64(ScrMap *m, ScrStr *key, double v);
 void scr_map_set_str_bool(ScrMap *m, ScrStr *key, bool v);
 void scr_map_set_str_ref(ScrMap *m, ScrStr *key, void *v);
@@ -1432,6 +1472,9 @@ void scr_map_set_ref_ref(ScrMap *m, void *key, void *v);
 bool scr_map_get_f64_f64(const ScrMap *m, double key, double *out);
 bool scr_map_get_f64_bool(const ScrMap *m, double key, bool *out);
 void *scr_map_get_f64_ref(const ScrMap *m, double key);
+bool scr_map_get_bool_f64(const ScrMap *m, bool key, double *out);
+bool scr_map_get_bool_bool(const ScrMap *m, bool key, bool *out);
+void *scr_map_get_bool_ref(const ScrMap *m, bool key);
 bool scr_map_get_str_f64(const ScrMap *m, const ScrStr *key, double *out);
 bool scr_map_get_str_bool(const ScrMap *m, const ScrStr *key, bool *out);
 void *scr_map_get_str_ref(const ScrMap *m, const ScrStr *key);
@@ -1447,6 +1490,7 @@ void *scr_map_get_ref_ref(const ScrMap *m, const void *key);
 double scr_map_iter_count(const ScrMap *m); /* entries incl. tombstones */
 bool scr_map_iter_live(const ScrMap *m, double i);
 double scr_map_iter_key_f64(const ScrMap *m, double i);
+bool scr_map_iter_key_bool(const ScrMap *m, double i);
 ScrStr *scr_map_iter_key_str(const ScrMap *m, double i); /* +1 */
 void *scr_map_iter_key_ref(const ScrMap *m, double i);     /* +1 */
 double scr_map_iter_val_f64(const ScrMap *m, double i);
@@ -1464,8 +1508,10 @@ void scr_set_add_all(ScrMap *set, ScrArr *values);
 /* `[...set]` (scr_lib.c): the live entries drained into a fresh +1 elem[]
  * in insertion order. Borrows the set; string elements retained in. */
 ScrArr *scr_set_to_arr_f64(const ScrMap *s);
+ScrArr *scr_set_to_arr_bool(const ScrMap *s);
 ScrArr *scr_set_to_arr_str(const ScrMap *s);
 ScrArr *scr_set_to_arr_ref(const ScrMap *s);
+ScrArr *scr_set_to_arr_dyn(const ScrMap *s);
 
 /* REF-element Set construction: a set-shaped map whose keys are refcounted
  * pointers under identity hashing (see SCR_MAP_KEY_REF above). The element
@@ -2615,7 +2661,29 @@ 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_utimes(ScrStr *path, double atime, double mtime, bool nofollow);
+void scr_fs_invalid_path(const ScrDyn *value, const ScrStr *path);
+void scr_fs_invalid_named_path(const ScrDyn *value, const ScrStr *path, const char *name);
+void scr_fs_futimes(double fd, double atime, double mtime);
 void scr_fs_link(ScrStr *source, ScrStr *dest);
+void scr_fs_symlink(ScrStr *target, ScrStr *destination, int kind);
+int scr_fs_symlink_infer(ScrStr *absolute);
+ScrBytes *scr_fs_readlink_bytes(ScrStr *path);
+void scr_fs_link_checked(const ScrDyn *existing, const ScrDyn *destination);
+void scr_fs_symlink_checked(const ScrDyn *target, const ScrDyn *destination, const ScrDyn *type);
+void scr_fs_symlink_promise_checked(const ScrDyn *target, const ScrDyn *destination, const ScrDyn *type);
+ScrDyn *scr_fs_readlink_checked(const ScrDyn *path, const ScrDyn *options, bool promise);
+ScrDyn *scr_fs_readlink_dyn(const ScrDyn *path, const ScrDyn *options);
+ScrDyn *scr_fs_statfs(ScrStr *path, bool bigint);
+ScrDyn *scr_fs_statfs_checked(const ScrDyn *path, const ScrDyn *options);
+ScrPromise *scr_fsp_statfs(const ScrDyn *path, const ScrDyn *options);
+ScrStr *scr_fs_readlink_str(const ScrDyn *path, const ScrDyn *options);
+ScrBytes *scr_fs_readlink_buffer(const ScrDyn *path, const ScrDyn *options);
+ScrPromise *scr_fsp_link(const ScrDyn *existing, const ScrDyn *destination);
+ScrPromise *scr_fsp_symlink(const ScrDyn *target, const ScrDyn *destination, const ScrDyn *type);
+ScrPromise *scr_fsp_readlink_dyn(const ScrDyn *path, const ScrDyn *options);
+ScrPromise *scr_fsp_readlink_str(const ScrDyn *path, const ScrDyn *options);
+ScrPromise *scr_fsp_readlink_buffer(const ScrDyn *path, const ScrDyn *options);
 ScrStats *scr_stats_retain(ScrStats *s);
 void scr_stats_release(ScrStats *s);
 void *scr_stats_retain_v(void *p);
@@ -2647,6 +2715,8 @@ ScrPromise *scr_fsp_mkdir_recursive(ScrStr *path);
 ScrPromise *scr_fsp_mkdir_recursive_mode(ScrStr *path, double mode);
 ScrPromise *scr_fsp_unlink(ScrStr *path);
 ScrPromise *scr_fsp_chmod(ScrStr *path, double mode);
+ScrPromise *scr_fsp_utimes(const ScrDyn *path, const ScrDyn *atime, const ScrDyn *mtime);
+ScrPromise *scr_fsp_lutimes(const ScrDyn *path, const ScrDyn *atime, const ScrDyn *mtime);
 ScrPromise *scr_fsp_readdir(ScrStr *path);
 ScrPromise *scr_fsp_rm(ScrStr *path);
 ScrPromise *scr_fsp_stat(ScrStr *path);
@@ -2655,6 +2725,7 @@ ScrPromise *scr_fsp_lstat(ScrStr *path);
 ScrPromise *scr_fsp_rename(ScrStr *oldpath, ScrStr *newpath);
 ScrPromise *scr_fsp_open(ScrStr *path, ScrStr *flags, double mode);
 ScrPromise *scr_file_handle_close_promise(ScrFileHandle *h);
+ScrPromise *scr_file_handle_utimes_promise(ScrFileHandle *h, const ScrDyn *atime, const ScrDyn *mtime);
 ScrPromise *scr_file_handle_read_file_promise(ScrFileHandle *h, ScrStr *encoding);
 ScrPromise *scr_file_handle_read_file_bytes_promise(ScrFileHandle *h, ScrStr *encoding);
 ScrPromise *scr_file_handle_write_file_promise(ScrFileHandle *h, ScrStr *data, ScrStr *encoding);
@@ -3203,7 +3274,7 @@ double scr_fs_read_zero(double fd, double position);
 void scr_fs_close(double fd);
 
 /* ── WHATWG URL (scr_url.c) ──────────────────────────────────────────
- * An immutable, refcounted URL value, parsed once at construction. The
+ * A mutable, refcounted URL value with selected component setters. The
  * parser covers the WHATWG algorithm's common ground exactly (see
  * scr_url.c's header comment for the covered surface and the documented
  * divergences: no IDNA, no IPv6, opaque paths verbatim).
@@ -3235,6 +3306,9 @@ ScrStr *scr_url_hostname(ScrUrl *u); /* +1 port-less host ("" when none) */
 ScrStr *scr_url_port(ScrUrl *u);     /* +1 "" or normalized non-default port */
 ScrStr *scr_url_pathname(ScrUrl *u); /* +1 */
 ScrStr *scr_url_href(ScrUrl *u);     /* +1; also toString() */
+void scr_url_set(ScrUrl *u, ScrStr *field, ScrStr *value); /* borrowed; href may throw */
+bool scr_url_set_component(ScrUrl *u, ScrStr *field, ScrStr *value); /* borrowed; false for ignored writes */
+void scr_url_set_checked(ScrUrl *u, ScrStr *field, const ScrDyn *value); /* borrowed; conversion may throw */
 ScrStr *scr_url_to_path(ScrUrl *u);      /* +1, or throws */
 ScrStr *scr_url_str_to_path(ScrStr *s);  /* +1, or throws */
 ScrUrl *scr_url_from_path(ScrStr *path); /* +1; throws on win32 UNC malformations only */
@@ -3348,6 +3422,7 @@ ScrBigInt *scr_bigint_xor(ScrBigInt *a, ScrBigInt *b);
 ScrBigInt *scr_bigint_shl(ScrBigInt *a, ScrBigInt *count);
 ScrBigInt *scr_bigint_shr(ScrBigInt *a, ScrBigInt *count);
 bool scr_bigint_eq(ScrBigInt *a, ScrBigInt *b);
+uint64_t scr_bigint_hash(const ScrBigInt *value); /* normalized value, no allocation */
 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 */
@@ -3928,6 +4003,8 @@ 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);
+bool scr_dyn_util_type_is(const ScrDyn *value, const ScrStr *probe);
+ScrDyn *scr_dyn_util_type_value(const ScrDyn *value, const ScrStr *probe);
 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
@@ -4133,6 +4210,9 @@ 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);
+ScrStr *scr_url_checked_to_path_options(const ScrDyn *value, const ScrDyn *options);
+ScrBytes *scr_url_checked_to_path_buffer(const ScrDyn *value, const ScrDyn *options);
+ScrUrl *scr_url_checked_from_path(const ScrDyn *value, const ScrDyn *options);
 ScrUrl *scr_dyn_native_url_check(const ScrDyn *value, const ScrDynPath *path);
 ScrRegex *scr_dyn_native_regex_check(const ScrDyn *value, const ScrDynPath *path);
 ScrClassObj *scr_dyn_class_check(const ScrDyn *value, const char *type_key, const ScrDynPath *path);
@@ -4194,6 +4274,8 @@ ScrDyn *scr_global_native(ScrArr *known);
 ScrDyn *scr_global_native_init(ScrArr *known, ScrDyn *(*console_get)(void));
 ScrDyn *scr_console_native(void);
 ScrDyn *scr_process_stdio(double fd);
+bool scr_dyn_process_stdio_is(const ScrDyn *value);
+double scr_dyn_process_stdio_fd(const ScrDyn *value, const ScrDynPath *path);
 
 void scr_dyn_handle_install(ScrDynHandleTag tag, const ScrDynHandleOps *ops);
 void scr_file_handle_dyn_install(void);
@@ -4298,6 +4380,7 @@ typedef struct ScrDynJsvalOps {
   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);
+  bool (*type_probe)(ScrJsval *cell, const ScrStr *probe); /* internal brand; no property access */
 } ScrDynJsvalOps;
 
 /* The allocator view the gated constructor uses (installs the ops);
@@ -5151,6 +5234,8 @@ typedef struct ScrIslandEdge {
  * after scr_lib_init. */
 void scr_island_modules(const ScrIslandModule *mods, size_t nmods,
                          const ScrIslandEdge *edges, size_t nedges);
+/* The logical source entry, independent of the installed binary path. */
+void scr_island_entry_module(const char *filename);
 
 /* The inflater for compressed embedded module text (raw DEFLATE, exact
  * inflated size known from the table row). The emitted main installs
@@ -5950,6 +6035,10 @@ ScrBytes *scr_buffer_new_string_fail(const ScrDyn *got);
  * numbers coerce (negatives answer now/1000), the rest throw Node's
  * ERR_INVALID_ARG_TYPE. Borrowed. */
 double scr_fs_to_unix_timestamp(const ScrDyn *t);
+double scr_fs_timestamp_value(const ScrDyn *t, const char *name);
+void scr_fs_utimes_checked(const ScrDyn *path, const ScrDyn *atime, const ScrDyn *mtime);
+void scr_fs_lutimes_checked(const ScrDyn *path, const ScrDyn *atime, const ScrDyn *mtime);
+void scr_fs_futimes_checked(const ScrDyn *fd, const ScrDyn *atime, const ScrDyn *mtime);
 /* The fs argument-validation ladders (the fs.*Chk libCalls): Node-order
  * validation over dyn values with Node's exact typed errors; a pass
  * meets the real operation where one exists (mkdtempSync, macOS
@@ -7364,6 +7453,11 @@ void scr_assert_shape_end(ScrStr *msg, bool has_msg);
 /* assert.doesNotReject whose rejection MATCHED (or had no expected):
  * "Got unwanted rejection[: message].\nActual message: \"...\"". */
 void scr_assert_unwanted_rejection(ScrError *err, ScrStr *msg, bool has_msg);
+/* No-error assertions share Node's unwanted-exception/rejection message.
+ * The frontend reads and coerces actual?.message, preserving getter throws. */
+void scr_assert_unwanted_error(ScrStr *actual_message, bool rejection, ScrStr *msg, bool has_msg);
+bool scr_assert_no_error_predicate(ScrDyn *predicate, ScrDyn *actual);
+bool scr_assert_regex_dyn_test(ScrRegex *re, ScrDyn *actual);
 /* assert.ifError over the static surface: throws for ANY value the
  * frontend routes here (Node: everything but null/undefined, falsy
  * included) — "ifError got unwanted exception: " + the error's message

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

@@ -271,6 +271,7 @@ ScrStr *scr_str_alloc_raw(size_t len, size_t cap) {
 }
 
 ScrStr *scr_str_regrow(ScrStr *s, size_t newcap) {
+  if (newcap < s->len || newcap > SIZE_MAX - sizeof(ScrStr) - 1) scr_oom();
   scr_short_forget(s);
   scr_sidx_purge(s); /* realloc may move; the old address may be recycled */
   ScrStr *r = realloc(s, sizeof(ScrStr) + newcap + 1);
@@ -300,6 +301,8 @@ void scr_str_release(ScrStr *s) {
 }
 
 ScrStr *scr_str_concat(ScrStr *a, ScrStr *b) {
+  if (a->len == 0) return scr_str_retain(b);
+  if (b->len == 0) return scr_str_retain(a);
   if (a->len > SIZE_MAX - b->len - sizeof(ScrStr) - 1) scr_oom();
   size_t newlen = a->len + b->len;
   /* In-place append: a is uniquely owned by the caller's borrow (rc == 1 —
@@ -343,6 +346,32 @@ ScrStr *scr_str_concat(ScrStr *a, ScrStr *b) {
   return s;
 }
 
+ScrStr *scr_str_concat_parts(ScrStr *const *parts, size_t count) {
+  const size_t limit = SIZE_MAX - sizeof(ScrStr) - 1;
+  size_t len = 0;
+  ScrStr *only = NULL;
+  size_t nonempty = 0;
+  for (size_t i = 0; i < count; i++) {
+    const size_t n = parts[i]->len;
+    if (n > limit - len) scr_oom();
+    len += n;
+    if (n != 0) {
+      only = parts[i];
+      nonempty++;
+    }
+  }
+  if (nonempty == 1) return scr_str_retain(only);
+  ScrStr *out = scr_str_alloc_raw(len, len);
+  size_t offset = 0;
+  for (size_t i = 0; i < count; i++) {
+    const ScrStr *part = parts[i];
+    memcpy(out->data + offset, part->data, part->len);
+    offset += part->len;
+  }
+  out->data[len] = '\0';
+  return out;
+}
+
 bool scr_str_eq(ScrStr *a, ScrStr *b) {
   return a == b || (a->len == b->len && memcmp(a->data, b->data, a->len) == 0);
 }

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

@@ -90,6 +90,11 @@ ScrSym *scr_sym_well_known(ScrStr *name) {
     scr_dyn_install_async_iterator_symbol(key);
     scr_dyn_release(key);
   }
+  if (name->len == 11 && !memcmp(name->data, "toPrimitive", 11)) {
+    ScrDyn *key = scr_dyn_new_symbol(symbol);
+    scr_dyn_install_to_primitive_symbol(key);
+    scr_dyn_release(key);
+  }
   return symbol;
 }