@scriptc/cli-darwin-x64 0.2.1 → 0.2.3

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

@@ -522,6 +522,13 @@ 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. */
@@ -772,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. */
@@ -810,6 +818,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
@@ -903,6 +916,23 @@ 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
  * frontend dynFroms the typed record; JS-world dyn values pass straight
@@ -1105,6 +1135,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. */
@@ -1452,6 +1486,7 @@ void scr_set_add_all(ScrMap *set, ScrArr *values);
 ScrArr *scr_set_to_arr_f64(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
@@ -1545,7 +1580,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;
 
@@ -2599,7 +2634,31 @@ 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_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);
@@ -2631,6 +2690,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);
@@ -2639,6 +2700,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);
@@ -3053,22 +3115,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
@@ -3129,6 +3202,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);
@@ -3136,6 +3212,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,
@@ -3159,10 +3241,15 @@ 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) ──────────────────────────────────────────
- * 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).
@@ -3177,6 +3264,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);
@@ -3190,6 +3281,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 */
@@ -3607,7 +3701,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;
@@ -3781,6 +3875,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);
@@ -3793,6 +3888,9 @@ 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);
@@ -3823,6 +3921,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);
@@ -3878,6 +3977,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
@@ -3969,6 +4070,7 @@ bool scr_dyn_number_coerce_js(const ScrDyn *d, double *out);
 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);
@@ -4045,6 +4147,7 @@ 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). */
@@ -4081,6 +4184,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);
@@ -4142,6 +4248,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);
@@ -4185,6 +4293,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
@@ -4245,6 +4354,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);
@@ -4513,6 +4623,7 @@ 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). */
@@ -5097,6 +5208,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
@@ -5821,6 +5934,11 @@ ScrStr *scr_bytes_to_str_checked_range(const ScrBytes *b, const ScrStr *enc, dou
  * 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);
@@ -5891,6 +6009,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
@@ -7305,6 +7427,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_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;
 }