@scriptc/cli-darwin-arm64 0.2.1 → 0.2.3

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

@@ -18,12 +18,18 @@ struct ScrUrl {
   ScrStr *query;    /* "" or "?..." */
   ScrStr *fragment; /* "" or "#..." */
   bool has_authority;
+  /* Node 24 preserves the /. serialization escape when a host setter
+   * enters port state from a host-less // path; pathname excludes it. */
+  bool host_path_escape;
   /* The LIVE searchParams view (NULL until first read). NON-owning: the
    * view retains its URL, so a URL with a live view never dies; the view
    * clears this back-pointer when it releases. Every `u.searchParams`
    * read answers the SAME view — Node's cached-object identity — and
    * view mutations write back into `query` (sp_sync_owner). */
   struct ScrSearchParams *sp_cache;
+  /* Installed by the optional params unit; setters can refresh a cached
+   * list without making params-free URL programs link that unit. */
+  void (*sp_reload)(struct ScrSearchParams *sp, ScrStr *query);
 };
 
 #endif /* SCR_URL_INTERNAL_H */

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

@@ -371,12 +371,22 @@ ScrSearchParams *scr_sp_with(ScrSearchParams *sp, ScrStr *name, ScrStr *value) {
   return scr_sp_retain(sp);
 }
 
+static void sp_reload(ScrSearchParams *sp, ScrStr *query) {
+  for (size_t i = 0; i < sp->len; i++) {
+    scr_str_release(sp->names[i]);
+    scr_str_release(sp->vals[i]);
+  }
+  sp->len = 0;
+  if (query->len > 1) sp_parse_into(sp, query->data + 1, query->len - 1);
+}
+
 ScrSearchParams *scr_url_search_params(ScrUrl *u) {
   if (u->sp_cache) return scr_sp_retain(u->sp_cache);
   ScrSearchParams *sp = sp_alloc();
   if (u->query->len > 1) sp_parse_into(sp, u->query->data + 1, u->query->len - 1);
   sp->owner = scr_url_retain(u);
   u->sp_cache = sp;
+  u->sp_reload = sp_reload;
   return sp;
 }
 

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

@@ -0,0 +1,222 @@
+#include "scr_runtime.h"
+
+#include <string.h>
+
+/* Node 24 strict comparison for values whose checked representation retains
+ * their observable shape. Never materialize an opaque native object as an
+ * ordinary record: doing so would discard its intrinsic brand/prototype. */
+typedef struct ScrDeepFrame {
+  const ScrDyn *a, *b;
+  const struct ScrDeepFrame *parent;
+} ScrDeepFrame;
+
+static bool util_deep_refused(const char *kind) {
+  ScrJsonBuf message;
+  scr_jb_init(&message);
+  scr_jb_puts(&message, "util.isDeepStrictEqual over ");
+  scr_jb_puts(&message, kind);
+  scr_jb_puts(&message, " is not supported yet");
+  ScrStr *text = scr_jb_finish(&message);
+  scr_throw_error_msg_code(SCR_ERR_TYPE, text->data, text->len, "SC2020");
+  scr_str_release(text);
+  return false;
+}
+
+static bool util_deep_equal(const ScrDyn *, const ScrDyn *, bool, const ScrDeepFrame *);
+
+static size_t util_deep_key_count(const ScrDyn *table) {
+  size_t count = 0;
+  if (table) for (size_t i = 0; i < table->v.obj.len; i++) count += table->v.obj.entries[i].enumerable;
+  return count;
+}
+
+static bool util_deep_same_keys(const ScrDyn *a, const ScrDyn *b) {
+  if (util_deep_key_count(a) != util_deep_key_count(b)) return false;
+  if (a) for (size_t i = 0; i < a->v.obj.len; i++) {
+    const ScrDynEntry *e = &a->v.obj.entries[i];
+    if (e->enumerable && (!b || !scr_dyn_obj_enumerable(b, e->key, e->key_len))) return false;
+  }
+  return true;
+}
+
+static ScrDyn *util_deep_constructor(const ScrDyn *value) {
+  for (const ScrDyn *p = value; p; p = p->prototype) {
+    const ScrDyn *table = p->kind == SCR_DYN_OBJ ? p : p->kind == SCR_DYN_ARR ? p->v.arr.properties : NULL;
+    if (table) for (size_t i = 0; i < table->v.obj.len; i++) {
+      const ScrDynEntry *e = &table->v.obj.entries[i];
+      if (e->key_len == 11 && !memcmp(e->key, "constructor", 11)) {
+        if (e->accessor) { util_deep_refused("native accessor properties"); return NULL; }
+        if (p == value && e->value->kind == SCR_DYN_FUNC) {
+          util_deep_refused("native own constructor functions"); return NULL;
+        }
+        return scr_dyn_retain(e->value);
+      }
+    }
+    if (!p->prototype) {
+      if (p->null_proto) return scr_dyn_retain(scr_dyn_undefined());
+      // Object.prototype is an internal identity token here; general
+      // Object.prototype reflection retains its existing native boundary.
+      return p->kind == SCR_DYN_ARR ? scr_dyn_array_constructor() : scr_dyn_object_prototype();
+    }
+  }
+  return scr_dyn_retain(scr_dyn_undefined());
+}
+
+static ScrDyn *util_deep_tag(const ScrDyn *value) {
+  bool has_symbols = false;
+  for (const ScrDyn *p = value; p; p = p->prototype) has_symbols |= p->symbol_properties != NULL;
+  if (!has_symbols) return scr_dyn_retain(scr_dyn_undefined());
+  ScrStr *name = scr_str_new("toStringTag", 11);
+  ScrSym *symbol = scr_sym_well_known(name);
+  ScrDyn *key = scr_dyn_new_symbol(symbol);
+  scr_str_release(name); scr_sym_release(symbol);
+  for (const ScrDyn *p = value; p; p = p->prototype) {
+    const ScrDyn *keys = p->symbol_keys;
+    if (!keys) continue;
+    for (size_t i = 0; i < keys->v.arr.len; i++) {
+      if (!scr_dyn_same_value(keys->v.arr.items[i], key)) continue;
+      // General native getters retain an explicit boundary, including
+      // non-enumerable Symbol.toStringTag descriptors read by Node.
+      for (size_t j = 0; j < p->symbol_properties->v.obj.len; j++) {
+        if (p->symbol_properties->v.obj.entries[j].accessor) {
+          scr_dyn_release(key); util_deep_refused("native accessor properties"); return NULL;
+        }
+      }
+      ScrDyn *result = scr_dyn_symbol_key_get(p, key, false);
+      scr_dyn_release(key);
+      return result;
+    }
+  }
+  scr_dyn_release(key);
+  return scr_dyn_retain(scr_dyn_undefined());
+}
+
+static bool util_deep_properties(const ScrDyn *a, const ScrDyn *b, bool skip,
+                                  const ScrDeepFrame *frame) {
+  if (util_deep_key_count(a) != util_deep_key_count(b)) return false;
+  if (!a) return true;
+  for (size_t i = 0; i < a->v.obj.len; i++) {
+    const ScrDynEntry *x = &a->v.obj.entries[i];
+    if (!x->enumerable) continue;
+    const ScrDynEntry *y = NULL;
+    if (b) for (size_t j = 0; j < b->v.obj.len; j++) {
+      const ScrDynEntry *candidate = &b->v.obj.entries[j];
+      if (candidate->enumerable && candidate->key_len == x->key_len &&
+          !memcmp(candidate->key, x->key, x->key_len)) { y = candidate; break; }
+    }
+    if (!y) return false;
+    if (x->accessor || y->accessor) return util_deep_refused("native accessor properties");
+    // Materializing a cyclic typed child can refresh its ancestor table.
+    // Retain the values before that refresh replaces descriptor storage.
+    ScrDyn *xv = scr_dyn_retain(x->value), *yv = scr_dyn_retain(y->value);
+    bool same = util_deep_equal(xv, yv, skip, frame);
+    scr_dyn_release(xv); scr_dyn_release(yv);
+    if (!same) return false;
+  }
+  return true;
+}
+
+static bool util_deep_equal(const ScrDyn *a, const ScrDyn *b, bool skip,
+                             const ScrDeepFrame *parent) {
+  if (scr_dyn_same_value(a, b)) return true;
+  if (a->kind == SCR_DYN_PROXY || b->kind == SCR_DYN_PROXY)
+    return util_deep_refused("native Proxy values");
+  if (a->kind == SCR_DYN_JSVAL || b->kind == SCR_DYN_JSVAL) {
+    scr_dyn_isl_fence(a->kind == SCR_DYN_JSVAL ? a : b, "util.isDeepStrictEqual");
+    return false;
+  }
+  if (a->kind == SCR_DYN_TYPED_REF || b->kind == SCR_DYN_TYPED_REF) {
+    const ScrDyn *inputs[] = { a, b };
+    for (size_t i = 0; i < 2; i++) {
+      const ScrDyn *v = inputs[i];
+      if (v->kind == SCR_DYN_TYPED_REF &&
+          strncmp(v->v.typed_ref.type_key, "record:", 7) &&
+          strncmp(v->v.typed_ref.type_key, "array<", 6))
+        return util_deep_refused("opaque native references");
+    }
+    ScrDyn *x = a->kind == SCR_DYN_TYPED_REF ? scr_dyn_typed_ref_materialize(a) : scr_dyn_retain((ScrDyn *)a);
+    ScrDyn *y = !scr_exc_pending() ? (b->kind == SCR_DYN_TYPED_REF ? scr_dyn_typed_ref_materialize(b) : scr_dyn_retain((ScrDyn *)b)) : NULL;
+    bool equal = !scr_exc_pending() && util_deep_equal(x, y, skip, parent);
+    scr_dyn_release(x); scr_dyn_release(y);
+    return equal;
+  }
+  if (a->kind == SCR_DYN_HANDLE || b->kind == SCR_DYN_HANDLE)
+    return util_deep_refused("native handles");
+  ScrError *error = scr_errdyn_err_of(a);
+  if (!error) error = scr_errdyn_err_of(b);
+  if (error) { scr_error_release(error); return util_deep_refused("native Error values"); }
+  if (a->kind != b->kind) return false;
+  if (a->kind != SCR_DYN_OBJ && a->kind != SCR_DYN_ARR && a->kind != SCR_DYN_BYTES) return false;
+  if (!skip) {
+    if (a->kind == SCR_DYN_BYTES) {
+      if (a->buffer != b->buffer || a->prototype != b->prototype) return false;
+    } else {
+      ScrDyn *x = util_deep_constructor(a);
+      ScrDyn *y = !scr_exc_pending() ? util_deep_constructor(b) : NULL;
+      const ScrDyn *table = a->kind == SCR_DYN_OBJ ? a : a->v.arr.properties;
+      bool inherited = !table || !scr_dyn_obj_get(table, "constructor", 11);
+      bool compare_constructor = !scr_exc_pending() && x->kind != SCR_DYN_UNDEF && inherited;
+      bool same = compare_constructor && scr_dyn_same_value(x, y);
+      scr_dyn_release(x); scr_dyn_release(y);
+      if (scr_exc_pending()) return false;
+      if (!compare_constructor) {
+        x = scr_dyn_get_prototype((ScrDyn *)a);
+        y = !scr_exc_pending() ? scr_dyn_get_prototype((ScrDyn *)b) : NULL;
+        same = !scr_exc_pending() && scr_dyn_same_value(x, y);
+        scr_dyn_release(x); scr_dyn_release(y);
+      }
+      if (!same) return false;
+    }
+  }
+  if (a->kind != SCR_DYN_BYTES) {
+    ScrDyn *x = util_deep_tag(a);
+    ScrDyn *y = !scr_exc_pending() ? util_deep_tag(b) : NULL;
+    bool same = !scr_exc_pending() && scr_dyn_strict_eq(x, y);
+    if (!same && !scr_exc_pending() && a->kind == SCR_DYN_OBJ &&
+        (x->kind == SCR_DYN_UNDEF || y->kind == SCR_DYN_UNDEF)) {
+      const ScrDyn *tag = x->kind == SCR_DYN_UNDEF ? y : x;
+      same = tag->kind != SCR_DYN_STR || (tag->v.str->len == 6 && !memcmp(tag->v.str->data, "Object", 6));
+    }
+    scr_dyn_release(x); scr_dyn_release(y);
+    if (!same) return false;
+  }
+  if (a->kind == SCR_DYN_ARR && a->v.arr.len != b->v.arr.len) return false;
+  if (a->kind == SCR_DYN_BYTES) {
+    const ScrBytes *x = a->v.bytes, *y = b->v.bytes;
+    if (x->elem != y->elem || x->len != y->len) return false;
+    size_t length = x->len * scr_bytes_elem_size(x->elem);
+    if (length && memcmp(x->data, y->data, length)) return false;
+  }
+  const ScrDyn *props_a = a->kind == SCR_DYN_OBJ ? a : a->kind == SCR_DYN_ARR ? a->v.arr.properties : NULL;
+  const ScrDyn *props_b = b->kind == SCR_DYN_OBJ ? b : b->kind == SCR_DYN_ARR ? b->v.arr.properties : NULL;
+  if (!util_deep_same_keys(props_a, props_b) || !util_deep_same_keys(a->symbol_properties, b->symbol_properties)) return false;
+  /* Match Node 24's shallow pair fast path, then its ancestor-set cycle
+   * rule. These are path-local: repeated acyclic children remain structural. */
+  if (parent && !parent->parent) {
+    if (parent->a == a) return parent->b == b;
+    if (parent->b == b) return false;
+  } else if (parent) {
+    bool seen_a = false, seen_b = false;
+    for (const ScrDeepFrame *p = parent; p; p = p->parent) {
+      seen_a |= a == p->a || a == p->b;
+      seen_b |= b == p->a || b == p->b;
+    }
+    if (seen_a || seen_b) return seen_a && seen_b;
+  }
+  ScrDeepFrame frame = { a, b, parent };
+  if (a->kind == SCR_DYN_ARR) {
+    for (size_t i = 0; i < a->v.arr.len; i++) {
+      bool present = scr_dyn_arr_has_index(a, i);
+      if (present != scr_dyn_arr_has_index(b, i)) return false;
+      if (present && !util_deep_equal(a->v.arr.items[i], b->v.arr.items[i], skip, &frame)) return false;
+    }
+    if (!util_deep_properties(a->v.arr.properties, b->v.arr.properties, skip, &frame)) return false;
+  } else if (a->kind == SCR_DYN_OBJ) {
+    if (!util_deep_properties(a, b, skip, &frame)) return false;
+  }
+  return util_deep_properties(a->symbol_properties, b->symbol_properties, skip, &frame);
+}
+
+bool scr_util_is_deep_strict_equal(const ScrDyn *a, const ScrDyn *b, const ScrDyn *skip) {
+  return util_deep_equal(a, b, scr_dyn_truthy(skip), NULL);
+}

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

@@ -0,0 +1,337 @@
+#include "scr_runtime.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* Standard Node 24 inspect colors, including its non-enumerable aliases.
+ * Native inspect.colors mutation has no static surface. */
+typedef struct ScrTextStyle { const char *name; unsigned open, close; } ScrTextStyle;
+static const ScrTextStyle util_text_styles[] = {
+  { "reset", 0, 0 },
+  { "bold", 1, 22 },
+  { "dim", 2, 22 },
+  { "italic", 3, 23 },
+  { "underline", 4, 24 },
+  { "blink", 5, 25 },
+  { "inverse", 7, 27 },
+  { "hidden", 8, 28 },
+  { "strikethrough", 9, 29 },
+  { "doubleunderline", 21, 24 },
+  { "black", 30, 39 },
+  { "red", 31, 39 },
+  { "green", 32, 39 },
+  { "yellow", 33, 39 },
+  { "blue", 34, 39 },
+  { "magenta", 35, 39 },
+  { "cyan", 36, 39 },
+  { "white", 37, 39 },
+  { "bgBlack", 40, 49 },
+  { "bgRed", 41, 49 },
+  { "bgGreen", 42, 49 },
+  { "bgYellow", 43, 49 },
+  { "bgBlue", 44, 49 },
+  { "bgMagenta", 45, 49 },
+  { "bgCyan", 46, 49 },
+  { "bgWhite", 47, 49 },
+  { "framed", 51, 54 },
+  { "overlined", 53, 55 },
+  { "gray", 90, 39 },
+  { "redBright", 91, 39 },
+  { "greenBright", 92, 39 },
+  { "yellowBright", 93, 39 },
+  { "blueBright", 94, 39 },
+  { "magentaBright", 95, 39 },
+  { "cyanBright", 96, 39 },
+  { "whiteBright", 97, 39 },
+  { "bgGray", 100, 49 },
+  { "bgRedBright", 101, 49 },
+  { "bgGreenBright", 102, 49 },
+  { "bgYellowBright", 103, 49 },
+  { "bgBlueBright", 104, 49 },
+  { "bgMagentaBright", 105, 49 },
+  { "bgCyanBright", 106, 49 },
+  { "bgWhiteBright", 107, 49 },
+  { "grey", 90, 39 },
+  { "blackBright", 90, 39 },
+  { "bgGrey", 100, 49 },
+  { "bgBlackBright", 100, 49 },
+  { "faint", 2, 22 },
+  { "crossedout", 9, 29 },
+  { "strikeThrough", 9, 29 },
+  { "crossedOut", 9, 29 },
+  { "conceal", 8, 28 },
+  { "swapColors", 7, 27 },
+  { "swapcolors", 7, 27 },
+  { "doubleUnderline", 21, 24 },
+};
+
+static ScrDyn *util_style_view(const ScrDyn *value) {
+  return value->kind == SCR_DYN_TYPED_REF ? scr_dyn_typed_ref_materialize(value)
+                                         : scr_dyn_retain((ScrDyn *)value);
+}
+
+static ScrDyn *util_style_member(const ScrDyn *value, const char *key) {
+  if (value->kind == SCR_DYN_UNDEF || value->kind == SCR_DYN_NULL)
+    return scr_dyn_retain(scr_dyn_undefined());
+  ScrDyn *view = util_style_view(value);
+  if (!view) return NULL;
+  ScrDyn *result = scr_dyn_obj_read(view, key, strlen(key));
+  scr_dyn_release(view);
+  return result;
+}
+
+static const ScrTextStyle *util_style_lookup(const ScrDyn *key) {
+  if (key->kind == SCR_DYN_SYMBOL) return NULL;
+  ScrStr *name = scr_dyn_string_constructor(key);
+  if (!name) return NULL;
+  const ScrTextStyle *result = NULL;
+  for (size_t i = 0; i < sizeof util_text_styles / sizeof util_text_styles[0]; i++) {
+    if (name->len == strlen(util_text_styles[i].name) &&
+        !memcmp(name->data, util_text_styles[i].name, name->len)) {
+      result = &util_text_styles[i]; break;
+    }
+  }
+  scr_str_release(name);
+  return result;
+}
+
+static bool util_style_none(const ScrDyn *key) {
+  return key->kind == SCR_DYN_STR && key->v.str->len == 4 &&
+         !memcmp(key->v.str->data, "none", 4);
+}
+
+static void util_style_invalid(const ScrDyn *key) {
+  ScrDyn *view = util_style_view(key);
+  if (!view) return;
+  ScrStr *shown = scr_insp_dyn(view, 0, 2);
+  scr_dyn_release(view);
+  if (!shown) return;
+  ScrJsonBuf message;
+  scr_jb_init(&message);
+  scr_jb_puts(&message, "The argument 'format' must be one of: ");
+  for (size_t i = 0; i < sizeof util_text_styles / sizeof util_text_styles[0]; i++) {
+    if (i) scr_jb_puts(&message, ", ");
+    scr_jb_putc(&message, '\'');
+    scr_jb_puts(&message, util_text_styles[i].name);
+    scr_jb_putc(&message, '\'');
+  }
+  scr_jb_puts(&message, ". Received ");
+  scr_jb_put_str(&message, shown);
+  ScrStr *text = scr_jb_finish(&message);
+  scr_throw_error_msg_code(SCR_ERR_TYPE, text->data, text->len, "ERR_INVALID_ARG_VALUE");
+  scr_str_release(text); scr_str_release(shown);
+}
+
+/* Reopen an outer style when a nested fragment closes it. Bold and dim
+ * share 22, so preserve that reset before restoring either attribute.
+ * A close at the very end is kept intact, matching Node's replacement. */
+static void util_style_putn(ScrJsonBuf *buffer, const char *data, size_t length) {
+  for (size_t i = 0; i < length; i++) scr_jb_putc(buffer, data[i]);
+}
+
+static ScrStr *util_style_replace(const ScrStr *text, const char *close,
+                                  const char *open, bool keep_close) {
+  size_t close_len = strlen(close), at = 0;
+  ScrJsonBuf result;
+  scr_jb_init(&result);
+  for (size_t i = 0; i + close_len < text->len;) {
+    if (!memcmp(text->data + i, close, close_len)) {
+      util_style_putn(&result, text->data + at, i - at);
+      if (keep_close) scr_jb_puts(&result, close);
+      scr_jb_puts(&result, open);
+      i += close_len; at = i;
+    } else i++;
+  }
+  util_style_putn(&result, text->data + at, text->len - at);
+  return scr_jb_finish(&result);
+}
+
+static bool util_style_env_nonempty(const char *name) {
+  const char *value = getenv(name);
+  return value && *value;
+}
+
+/* Node recognizes structural stream implementations as well as branded
+ * instances. Keep that valid shape outside the native stdio boundary. */
+static bool util_style_custom_stream(const ScrDyn *stream) {
+  static const char *const keys[] = { "_readableState", "_writableState", "write", "on", "pipe", "pipeThrough", "getReader", "cancel", "getWriter", "abort" };
+  ScrDyn *members[sizeof keys / sizeof keys[0]] = {0};
+  bool result = false;
+  for (size_t i = 0; i < sizeof keys / sizeof keys[0]; i++) {
+    members[i] = util_style_member(stream, keys[i]);
+    if (!members[i] || scr_exc_pending()) goto done;
+  }
+  result = scr_dyn_truthy(members[0]) || scr_dyn_truthy(members[1]) ||
+    (members[3]->kind == SCR_DYN_FUNC && (members[2]->kind == SCR_DYN_FUNC || members[4]->kind == SCR_DYN_FUNC)) ||
+    (members[5]->kind == SCR_DYN_FUNC && members[6]->kind == SCR_DYN_FUNC && members[7]->kind == SCR_DYN_FUNC) ||
+    (members[8]->kind == SCR_DYN_FUNC && members[9]->kind == SCR_DYN_FUNC);
+done:
+  for (size_t i = 0; i < sizeof keys / sizeof keys[0]; i++) scr_dyn_release(members[i]);
+  return result;
+}
+
+/* styleText only needs the color/no-color distinction, rather than the
+ * full 4/8/24-bit depth. Follow the ordering of Node 24 internal/tty. */
+static bool util_style_terminal_colors(void) {
+  const char *force = getenv("FORCE_COLOR");
+  if (force) {
+    bool enabled = !strcmp(force, "") || !strcmp(force, "true") ||
+      !strcmp(force, "1") || !strcmp(force, "2") || !strcmp(force, "3");
+    static SCR_TL bool warned = false;
+    const char *disabled = util_style_env_nonempty("NO_COLOR") ? "NO_COLOR" :
+      util_style_env_nonempty("NODE_DISABLE_COLORS") ? "NODE_DISABLE_COLORS" : NULL;
+    if (enabled && disabled && !warned) {
+      ScrJsonBuf message;
+      scr_jb_init(&message);
+      scr_jb_puts(&message, "The '"); scr_jb_puts(&message, disabled);
+      scr_jb_puts(&message, "' env is ignored due to the 'FORCE_COLOR' env being set.");
+      ScrStr *text = scr_jb_finish(&message);
+      scr_emit_warning("Warning", NULL, text);
+      scr_str_release(text); warned = true;
+    }
+    return enabled;
+  }
+  const char *term = getenv("TERM");
+  if (util_style_env_nonempty("NO_COLOR") || util_style_env_nonempty("NODE_DISABLE_COLORS") ||
+      (term && !strcmp(term, "dumb"))) return false;
+#ifdef _WIN32
+  return true;
+#endif
+  if (util_style_env_nonempty("TMUX")) return true;
+  if (getenv("TF_BUILD") && getenv("AGENT_NAME")) return true;
+  if (getenv("CI")) {
+    static const char *const ci[] = { "APPVEYOR", "BUILDKITE", "CIRCLECI", "DRONE", "GITEA_ACTIONS", "GITHUB_ACTIONS", "GITLAB_CI", "TRAVIS" };
+    for (size_t i = 0; i < sizeof ci / sizeof ci[0]; i++) if (getenv(ci[i])) return true;
+    const char *name = getenv("CI_NAME");
+    return name && !strcmp(name, "codeship");
+  }
+  const char *teamcity = getenv("TEAMCITY_VERSION");
+  if (teamcity) {
+    const char *p = teamcity;
+    if (!strncmp(p, "9.", 2)) {
+      p += 2; while (*p == '0') p++;
+      if (*p < '1' || *p > '9') return false;
+      while (*p >= '0' && *p <= '9') p++;
+      return *p == '.';
+    }
+    while (*p >= '0' && *p <= '9') p++;
+    return p - teamcity >= 2 && *p == '.';
+  }
+  const char *program = getenv("TERM_PROGRAM");
+  if (program && (!strcmp(program, "iTerm.app") || !strcmp(program, "HyperTerm") ||
+                  !strcmp(program, "MacTerm") || !strcmp(program, "Apple_Terminal"))) return true;
+  const char *colorterm = getenv("COLORTERM");
+  if (colorterm && (!strcmp(colorterm, "truecolor") || !strcmp(colorterm, "24bit"))) return true;
+  if (term) {
+    if (strstr(term, "truecolor") || !strncmp(term, "xterm-256", 9)) return true;
+    char *lower = malloc(strlen(term) + 1);
+    if (!lower) abort();
+    for (size_t i = 0; i <= strlen(term); i++) lower[i] = term[i] >= 'A' && term[i] <= 'Z' ? term[i] + ('a' - 'A') : term[i];
+    static const char *const terminals[] = { "eterm", "cons25", "console", "cygwin", "dtterm", "gnome", "hurd", "jfbterm", "konsole", "kterm", "mlterm", "mosh", "putty", "st", "rxvt-unicode-24bit", "terminator", "xterm-kitty" };
+    bool found = false;
+    for (size_t i = 0; i < sizeof terminals / sizeof terminals[0]; i++) found |= !strcmp(lower, terminals[i]);
+    found |= strstr(lower, "ansi") || strstr(lower, "color") || strstr(lower, "linux") || strstr(lower, "direct") ||
+      !strncmp(lower, "rxvt", 4) || !strncmp(lower, "screen", 6) || !strncmp(lower, "xterm", 5) ||
+      !strncmp(lower, "vt100", 5) || !strncmp(lower, "vt220", 5);
+    if (!strncmp(lower, "con", 3)) {
+      const char *p = lower + 3;
+      while (*p >= '0' && *p <= '9') p++;
+      if (*p == 'x' && p[1] >= '0' && p[1] <= '9') found = true;
+    }
+    free(lower);
+    if (found) return true;
+  }
+  return colorterm && *colorterm;
+}
+
+ScrStr *scr_util_style_text(const ScrDyn *format, const ScrDyn *text, const ScrDyn *options) {
+  ScrDyn *validate = util_style_member(options, "validateStream");
+  if (!validate) return NULL;
+  if (validate->kind == SCR_DYN_UNDEF || validate->kind == SCR_DYN_NULL) {
+    scr_dyn_release(validate); validate = scr_dyn_new_bool(true);
+  }
+  const ScrTextStyle *fast = NULL;
+  if (!scr_dyn_truthy(validate) && format->kind == SCR_DYN_STR && text->kind == SCR_DYN_STR) {
+    if (util_style_none(format)) { scr_dyn_release(validate); return scr_str_retain(text->v.str); }
+    fast = util_style_lookup(format);
+  }
+  bool colorize = true;
+  ScrDyn *view = NULL, *stream = NULL;
+  ScrStr *result = NULL, *processed = NULL;
+  if (!fast) {
+    if (text->kind != SCR_DYN_STR) { scr_dyn_arg_type_fail("text", "of type string", text); goto done; }
+    view = util_style_view(options);
+    if (!view) goto done;
+    if (view->kind != SCR_DYN_UNDEF && view->kind != SCR_DYN_OBJ) {
+      scr_dyn_arg_type_fail("options", "of type object", view); goto done;
+    }
+    if (validate->kind != SCR_DYN_BOOL) {
+      scr_dyn_prop_type_fail("options.validateStream", "of type boolean", validate); goto done;
+    }
+    if (validate->v.b) {
+      stream = util_style_member(options, "stream");
+      if (!stream) goto done;
+      if (stream->kind == SCR_DYN_TYPED_REF && !strncmp(stream->v.typed_ref.type_key, "record:", 7)) {
+        ScrDyn *native = util_style_view(stream);
+        scr_dyn_release(stream); stream = native;
+        if (!stream) goto done;
+      }
+      double fd = 1;
+      if (stream->kind != SCR_DYN_UNDEF && stream->kind != SCR_DYN_NULL) {
+        if (stream->kind == SCR_DYN_HANDLE && stream->v.handle.tag == SCR_DYNH_STDIO) {
+          ScrStr *key = scr_str_new("fd", 2);
+          ScrDyn *value = scr_dyn_handle_key_get(stream, key);
+          scr_str_release(key);
+          if (!value) goto done;
+          fd = value->v.num; scr_dyn_release(value);
+        } else if (stream->kind == SCR_DYN_HANDLE || stream->kind == SCR_DYN_TYPED_REF ||
+                   (stream->kind == SCR_DYN_OBJ && util_style_custom_stream(stream))) {
+          static const char message[] = "util.styleText over native custom streams is not supported yet";
+          scr_throw_error_msg_code(SCR_ERR_TYPE, message, sizeof message - 1, "SC2020"); goto done;
+        } else {
+          if (scr_exc_pending()) goto done;
+          scr_dyn_arg_type_fail("stream", "an instance of ReadableStream, WritableStream, or Stream", stream); goto done;
+        }
+      }
+      colorize = getenv("FORCE_COLOR") ? util_style_terminal_colors() :
+        scr_process_is_tty(fd) && util_style_terminal_colors();
+    }
+  }
+  scr_dyn_release(view); view = util_style_view(format);
+  if (!view) goto done;
+  processed = scr_str_retain(text->v.str);
+  ScrJsonBuf opens, closes;
+  scr_jb_init(&opens); scr_jb_init(&closes);
+  size_t count = view->kind == SCR_DYN_ARR ? view->v.arr.len : 1;
+  for (size_t i = 0; i < count; i++) {
+    const ScrDyn *key = view->kind == SCR_DYN_ARR ? view->v.arr.items[i] : view;
+    if (util_style_none(key)) continue;
+    const ScrTextStyle *style = util_style_lookup(key);
+    if (!style) {
+      if (!scr_exc_pending()) util_style_invalid(key);
+      scr_str_release(scr_jb_finish(&opens)); scr_str_release(scr_jb_finish(&closes)); goto done;
+    }
+    char open[16], close[16];
+    snprintf(open, sizeof open, "\x1b[%um", style->open);
+    snprintf(close, sizeof close, "\x1b[%um", style->close);
+    scr_jb_puts(&opens, open);
+    size_t n = strlen(close);
+    scr_jb_puts(&closes, close);
+    /* Prepend each closing sequence so the outer formats close last. */
+    memmove(closes.data + n, closes.data, closes.len - n);
+    memcpy(closes.data, close, n);
+    ScrStr *next = util_style_replace(processed, close, open, style->open == 1 || style->open == 2);
+    scr_str_release(processed); processed = next;
+  }
+  if (colorize) {
+    scr_jb_put_str(&opens, processed);
+    util_style_putn(&opens, closes.data, closes.len);
+    result = scr_jb_finish(&opens);
+  } else { scr_str_release(scr_jb_finish(&opens)); result = scr_str_retain(text->v.str); }
+  scr_str_release(scr_jb_finish(&closes));
+done:
+  scr_dyn_release(validate); scr_dyn_release(view); scr_dyn_release(stream);
+  scr_str_release(processed);
+  return result;
+}