@scriptc/cli-darwin-arm64 0.2.2 → 0.2.4

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

@@ -50,12 +50,12 @@ static const struct {
     {"node:tls",
      "connect,createServer,createSecureContext,TLSSocket,rootCertificates"},
     {"node:diagnostics_channel",
-     "channel,subscribe,unsubscribe,hasSubscribers,tracingChannel"},
+     "channel,subscribe,unsubscribe,hasSubscribers,tracingChannel,Channel"},
     {"node:module",
      "createRequire,builtinModules,isBuiltin,syncBuiltinESMExports,register,findSourceMap"},
     {"node:url",
-     "URL,URLSearchParams,fileURLToPath,pathToFileURL,parse,format,resolve,domainToASCII,domai"
-     "nToUnicode,urlToHttpOptions"},
+     "URL,URLSearchParams,fileURLToPath,fileURLToPathBuffer,pathToFileURL,parse,format,resolve"
+     ",domainToASCII,domainToUnicode,urlToHttpOptions"},
     {"node:buffer",
      "Buffer,SlowBuffer,INSPECT_MAX_BYTES,kMaxLength,kStringMaxLength,constants,isAscii,isUtf8"
      ",atob,btoa,Blob,File,transcode,resolveObjectURL"},
@@ -130,7 +130,10 @@ static const struct {
     {"node:stream/consumers",
      "text,buffer,arrayBuffer,json,blob"},
     {"node:stream/web",
-     "ReadableStream,TransformStream,TextDecoderStream"},
+     "ReadableStream,TransformStream,TextDecoderStream,WritableStream,WritableStreamDefaultWri"
+     "ter,WritableStreamDefaultController,CountQueuingStrategy,ByteLengthQueuingStrategy,Trans"
+     "formStreamDefaultController,TextEncoderStream,ReadableStreamDefaultReader,ReadableStream"
+     "DefaultController"},
     {"node:crypto",
      "createHash,createHmac,hash,Hash,Hmac,randomBytes,randomFillSync,randomFill,randomInt,ran"
      "domUUID,getRandomValues,timingSafeEqual,pbkdf2,pbkdf2Sync,getHashes,getCiphers,getCurves"
@@ -141,9 +144,10 @@ static const struct {
      "c,X509Certificate,Certificate,checkPrime,checkPrimeSync,generatePrime,generatePrimeSync,"
      "secureHeapUsed,setEngine,setFips,getFips"},
     {"node:util",
-     "parseEnv,format,formatWithOptions,inspect,inherits,promisify,callbackify,deprecate,debug"
-     "log,debug,types,isDeepStrictEqual,stripVTControlCharacters,styleText,parseArgs,toUSVStri"
-     "ng,_extend,TextEncoder,TextDecoder,isArray"},
+     "getSystemErrorName,getSystemErrorMessage,getSystemErrorMap,parseEnv,format,formatWithOpt"
+     "ions,inspect,inherits,promisify,callbackify,deprecate,debuglog,debug,types,isDeepStrictE"
+     "qual,stripVTControlCharacters,styleText,parseArgs,toUSVString,_extend,TextEncoder,TextDe"
+     "coder,MIMEType,MIMEParams,isArray"},
     {"node:util/types",
      "isAnyArrayBuffer,isArrayBufferView,isArgumentsObject,isArrayBuffer,isAsyncFunction,isBig"
      "Int64Array,isBigUint64Array,isBooleanObject,isBoxedPrimitive,isBigIntObject,isCryptoKey,"

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

@@ -57,6 +57,7 @@ static void scr_json_oom(void) {
 
 static SCR_TL ScrDyn *scr_iterator_symbol;
 static SCR_TL ScrDyn *scr_async_iterator_symbol;
+static SCR_TL ScrDyn *scr_to_primitive_symbol;
 static bool scr_dyn_generator(const ScrDyn *value) {
   return value && value->kind == SCR_DYN_TYPED_REF &&
     (!strncmp(value->v.typed_ref.type_key, "generator<", 10) || !strncmp(value->v.typed_ref.type_key, "async-generator<", 16));
@@ -104,6 +105,17 @@ static void scr_async_iterator_symbol_cleanup(void) {
   scr_async_iterator_symbol = NULL;
 }
 
+static void scr_to_primitive_symbol_cleanup(void) {
+  scr_dyn_release(scr_to_primitive_symbol);
+  scr_to_primitive_symbol = NULL;
+}
+
+void scr_dyn_install_to_primitive_symbol(ScrDyn *key) {
+  if (scr_to_primitive_symbol) return;
+  scr_to_primitive_symbol = scr_dyn_retain(key);
+  scr_atexit(scr_to_primitive_symbol_cleanup);
+}
+
 void scr_dyn_install_async_iterator_symbol(ScrDyn *key) {
   if (scr_async_iterator_symbol) return;
   scr_async_iterator_symbol = scr_dyn_retain(key);
@@ -1027,12 +1039,20 @@ ScrDyn *scr_dyn_undefined(void) {
   return &undef;
 }
 
-ScrDyn *scr_dyn_new_null(void) { return scr_dyn_alloc(SCR_DYN_NULL); }
+/* Primitive nodes have no mutable properties or observable box identity.
+ * As with undefined, SIZE_MAX keeps them out of RC and cycle bookkeeping;
+ * callers retain the ordinary owned-result and ownership-transfer contracts. */
+ScrDyn *scr_dyn_new_null(void) {
+  static ScrDyn value = { .rc = SIZE_MAX, .kind = SCR_DYN_NULL };
+  return &value;
+}
 
 ScrDyn *scr_dyn_new_bool(bool b) {
-  ScrDyn *d = scr_dyn_alloc(SCR_DYN_BOOL);
-  d->v.b = b;
-  return d;
+  static ScrDyn values[2] = {
+    { .rc = SIZE_MAX, .kind = SCR_DYN_BOOL, .v.b = false },
+    { .rc = SIZE_MAX, .kind = SCR_DYN_BOOL, .v.b = true },
+  };
+  return &values[b ? 1 : 0];
 }
 
 ScrDyn *scr_dyn_new_bigint(ScrBigInt *value) {
@@ -1902,6 +1922,56 @@ bool scr_dyn_typed_array_is(const ScrDyn *d, int elem) {
   return d && d->kind == SCR_DYN_BYTES && !d->v.bytes->is_data_view && d->v.bytes->elem == (ScrBytesElem)elem;
 }
 
+/* Node util.types reads internal brands, never user properties or prototypes. */
+bool scr_dyn_util_type_is(const ScrDyn *value, const ScrStr *probe) {
+  if (!value) return false;
+  if (value->kind == SCR_DYN_JSVAL) return scr_dyn_jsval_ops()->type_probe(value->v.jsval.cell, probe);
+#define PROBE(name) (probe->len == sizeof(name) - 1 && memcmp(probe->data, name, sizeof(name) - 1) == 0)
+  if (PROBE("isAnyArrayBuffer") || PROBE("isArrayBuffer")) return scr_array_buffer_is(value);
+  if (PROBE("isArrayBufferView")) return value->kind == SCR_DYN_BYTES;
+  if (PROBE("isDataView")) return value->kind == SCR_DYN_BYTES && value->v.bytes->is_data_view;
+  if (PROBE("isTypedArray")) return value->kind == SCR_DYN_BYTES && !value->v.bytes->is_data_view;
+  if (PROBE("isUint8Array")) return scr_dyn_typed_array_is(value, SCR_BYTES_U8);
+  if (PROBE("isUint8ClampedArray")) return scr_dyn_typed_array_is(value, SCR_BYTES_U8C);
+  if (PROBE("isUint16Array")) return scr_dyn_typed_array_is(value, SCR_BYTES_U16);
+  if (PROBE("isUint32Array")) return scr_dyn_typed_array_is(value, SCR_BYTES_U32);
+  if (PROBE("isInt8Array")) return scr_dyn_typed_array_is(value, SCR_BYTES_I8);
+  if (PROBE("isInt16Array")) return scr_dyn_typed_array_is(value, SCR_BYTES_I16);
+  if (PROBE("isInt32Array")) return scr_dyn_typed_array_is(value, SCR_BYTES_I32);
+  if (PROBE("isFloat32Array")) return scr_dyn_typed_array_is(value, SCR_BYTES_F32);
+  if (PROBE("isFloat64Array")) return scr_dyn_typed_array_is(value, SCR_BYTES_F64);
+  if (PROBE("isMap")) return value->kind == SCR_DYN_HANDLE && value->v.handle.tag == SCR_DYNH_MAP;
+  if (PROBE("isSet")) return value->kind == SCR_DYN_HANDLE && value->v.handle.tag == SCR_DYNH_SET;
+  if (PROBE("isWeakMap")) return value->kind == SCR_DYN_HANDLE && value->v.handle.tag == SCR_DYNH_WEAK_MAP;
+  if (PROBE("isWeakSet")) return value->kind == SCR_DYN_HANDLE && value->v.handle.tag == SCR_DYNH_WEAK_SET;
+  if (PROBE("isRegExp")) return value->kind == SCR_DYN_HANDLE && value->v.handle.tag == SCR_DYNH_REGEXP;
+  if (PROBE("isPromise")) return value->kind == SCR_DYN_PROMISE;
+  if (PROBE("isProxy")) return value->kind == SCR_DYN_PROXY;
+  if (PROBE("isAsyncFunction")) return value->kind == SCR_DYN_FUNC && (value->v.fn.clo->function_kind & 2) != 0;
+  if (PROBE("isGeneratorFunction")) return value->kind == SCR_DYN_FUNC && (value->v.fn.clo->function_kind & 1) != 0;
+  if (PROBE("isGeneratorObject")) return scr_dyn_generator(value);
+  if (PROBE("isNativeError")) {
+    ScrError *error = scr_errdyn_err_of(value);
+    if (!error) return false;
+    scr_error_release(error);
+    return true;
+  }
+#undef PROBE
+  return false;
+}
+
+/* Node's JavaScript wrappers have names/arity; engine-native probes are
+ * anonymous with length zero. Keep their native closure identity intact. */
+ScrDyn *scr_dyn_util_type_value(const ScrDyn *value, const ScrStr *probe) {
+  static const char *const named[] = { "isTypedArray", "isUint8Array", "isUint8ClampedArray", "isUint16Array", "isUint32Array",
+    "isInt8Array", "isInt16Array", "isInt32Array", "isFloat32Array", "isFloat64Array" };
+  const char *name = "";
+  if (probe->len == 17 && memcmp(probe->data, "isArrayBufferView", 17) == 0) name = "isView";
+  for (size_t i = 0; i < sizeof named / sizeof named[0]; i++)
+    if (probe->len == strlen(named[i]) && memcmp(probe->data, named[i], probe->len) == 0) name = named[i];
+  return scr_dyn_new_func(scr_closure_retain(value->v.fn.clo), value->v.fn.thunk, *name ? 1 : 0, value->v.fn.sig, name);
+}
+
 bool scr_dyn_bytes_is(const ScrDyn *d, int elem) {
   return d && d->kind == SCR_DYN_BYTES && d->v.bytes->elem == (ScrBytesElem)elem;
 }
@@ -2352,7 +2422,9 @@ const char *scr_dyn_specific_type(const ScrDyn *cb, char *detail, size_t cap) {
   }
   case SCR_DYN_NUM: {
     char num[32];
-    size_t n = scr_f64_to_str(cb->v.num, num);
+    size_t n;
+    if (cb->v.num == 0 && signbit(cb->v.num)) { memcpy(num, "-0", 3); n = 2; }
+    else n = scr_f64_to_str(cb->v.num, num);
     snprintf(detail, cap, "type number (%.*s)", (int)n, num);
     break;
   }
@@ -4550,7 +4622,16 @@ ScrStr *scr_dyn_string_coerce_js(const ScrDyn *d) {
     for (int i = 0; i < 2; i++) {
       const ScrDyn *owner = scr_dyn_property_owner(d, hint[i], strlen(hint[i]));
       ScrDyn *m = owner ? scr_dyn_obj_read(d, hint[i], strlen(hint[i])) : NULL;
+      if (scr_exc_pending()) { scr_dyn_release(m); return NULL; }
       if (!m && i == 0 && scr_dyn_has_object_prototype(d)) {
+        // Checked Error values retain their Error.prototype formatter even
+        // when their fields are exposed through the cached object view.
+        ScrError *error = scr_errdyn_err_of(d);
+        if (error) {
+          ScrStr *text = scr_error_to_string(error);
+          scr_error_release(error);
+          return text;
+        }
         return scr_str_new("[object Object]", 15);
       }
       if (!m || m->kind != SCR_DYN_FUNC) { scr_dyn_release(m); continue; }
@@ -4576,6 +4657,65 @@ ScrStr *scr_dyn_string_coerce_js(const ScrDyn *d) {
   return scr_dyn_string_coerce(d);
 }
 
+ScrStr *scr_util_to_usv_string(const ScrDyn *input) {
+  const ScrDyn *value = input ? input : scr_dyn_undefined();
+  /* Native string producers already replace unpaired surrogate code units.
+   * Preserve ToString's object protocol before using that storage invariant. */
+  if (scr_to_primitive_symbol && scr_iterator_object(value)) {
+    ScrDyn *method = scr_dyn_reflect_get((ScrDyn *)value, scr_to_primitive_symbol, (ScrDyn *)value);
+    if (!method) return NULL;
+    if (method->kind != SCR_DYN_UNDEF && method->kind != SCR_DYN_NULL) {
+      if (!scr_dyn_is_callable(method)) {
+        ScrJsonBuf buffer;
+        scr_jb_init(&buffer);
+        if (scr_iterator_object(method)) scr_jb_puts(&buffer, "object");
+        else {
+          ScrStr *type = scr_dyn_typeof(method);
+          scr_jb_put_str(&buffer, type);
+          scr_str_release(type);
+          if (method->kind != SCR_DYN_SYMBOL && method->kind != SCR_DYN_BIGINT) scr_jb_puts(&buffer, " ");
+          if (method->kind == SCR_DYN_STR) {
+            scr_jb_puts(&buffer, "\"");
+            scr_jb_put_str(&buffer, method->v.str);
+            scr_jb_puts(&buffer, "\"");
+          }
+          else if (method->kind != SCR_DYN_SYMBOL && method->kind != SCR_DYN_BIGINT) {
+            ScrStr *text = scr_dyn_string_coerce(method);
+            scr_jb_put_str(&buffer, text);
+            scr_str_release(text);
+          }
+        }
+        scr_jb_puts(&buffer, " is not a function");
+        ScrStr *message = scr_jb_finish(&buffer);
+        scr_throw_error_msg(SCR_ERR_TYPE, message->data, message->len);
+        scr_str_release(message);
+        scr_dyn_release(method);
+        return NULL;
+      }
+      ScrStr *hint = scr_str_new("string", 6);
+      ScrDyn *argument = scr_dyn_new_str(hint);
+      scr_str_release(hint);
+      scr_dyn_this_push_dyn(value);
+      ScrDyn *primitive = scr_dyn_call(method, &argument, 1, "Symbol.toPrimitive");
+      scr_dyn_this_pop();
+      scr_dyn_release(argument);
+      scr_dyn_release(method);
+      if (!primitive) return NULL;
+      if (scr_dyn_to_primitive_result_is_object(primitive)) {
+        static const char message[] = "Cannot convert object to primitive value";
+        scr_throw_error_msg(SCR_ERR_TYPE, message, sizeof message - 1);
+        scr_dyn_release(primitive);
+        return NULL;
+      }
+      ScrStr *text = scr_dyn_string_coerce(primitive);
+      scr_dyn_release(primitive);
+      return text;
+    }
+    scr_dyn_release(method);
+  }
+  return scr_dyn_string_coerce_js(value);
+}
+
 /* JS ToNumber over a checked-dynamic value, including OrdinaryToPrimitive's
  * NUMBER hint for object snapshots. This is the numeric twin of
  * scr_dyn_string_coerce_js above: valueOf precedes toString, inherited
@@ -5881,19 +6021,15 @@ static ScrDyn *scr_json_value(ScrJsonP *p) {
   }
   if (c == 't') {
     if (!scr_json_lit(p, "true", 4)) return NULL;
-    ScrDyn *d = scr_dyn_alloc(SCR_DYN_BOOL);
-    d->v.b = true;
-    return d;
+    return scr_dyn_new_bool(true);
   }
   if (c == 'f') {
     if (!scr_json_lit(p, "false", 5)) return NULL;
-    ScrDyn *d = scr_dyn_alloc(SCR_DYN_BOOL);
-    d->v.b = false;
-    return d;
+    return scr_dyn_new_bool(false);
   }
   if (c == 'n') {
     if (!scr_json_lit(p, "null", 4)) return NULL;
-    return scr_dyn_alloc(SCR_DYN_NULL);
+    return scr_dyn_new_null();
   }
   if (c == '-' || (c >= '0' && c <= '9')) return scr_json_number(p);
   scr_json_throw_token(p);
@@ -9207,7 +9343,8 @@ 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) {
   if (!(map ? scr_dyn_native_map_is(value) : scr_dyn_native_set_is(value))) return false;
   const ScrMap *storage = value->v.handle.ptr;
-  return type ? storage->dyn_ops && strcmp(storage->dyn_ops->type, type) == 0 : !storage->dyn_ops;
+  // A generic checked view uses dyn_ops to box/unbox the same live storage.
+  return !type || (storage->dyn_ops && strcmp(storage->dyn_ops->type, type) == 0);
 }
 
 ScrMap *scr_dyn_native_collection_check(const ScrDyn *value, int map, const char *type, const ScrDynPath *path) {