@scriptc/cli-darwin-arm64 0.2.2 → 0.2.3

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

@@ -719,6 +719,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 +1112,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

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

@@ -818,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
@@ -911,11 +916,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 +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. */
@@ -1466,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
@@ -2615,7 +2636,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 +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);
@@ -2655,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);
@@ -3203,7 +3249,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 +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 */
@@ -3928,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
@@ -4133,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);
@@ -4194,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);
@@ -4298,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);
@@ -5151,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
@@ -5950,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
@@ -7364,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;
 }