@scriptc/cli-darwin-x64 0.2.3 → 0.2.5

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);
 
@@ -1030,7 +1032,7 @@ typedef struct ScrArr {
   void (*elem_release)(void *);
   ScrTraceFn elem_trace;
   uint64_t *data;
-  uint8_t *present; /* one ScrArrState per dense slot */
+  uint8_t *present; /* one state per dense slot; heap arrays share data allocation */
   struct ScrArrSparseSlot *sparse;
   size_t sparse_len;
   size_t sparse_cap;
@@ -1109,6 +1111,13 @@ void scr_arr_copy_range(ScrArr *dst, size_t dst_start, const ScrArr *src,
 void scr_arr_copy_range_ex(ScrArr *dst, size_t dst_start, const ScrArr *src,
                            size_t src_start, size_t count, bool reverse,
                            bool materialize_holes);
+/* Mutating indexed operations borrow the receiver and value, preserve
+ * sparse presence, and return the receiver retained. */
+ScrArr *scr_arr_copy_within(ScrArr *a, double target, double start, double end);
+ScrArr *scr_arr_fill_f64(ScrArr *a, double value, double start, double end);
+ScrArr *scr_arr_fill_bool(ScrArr *a, bool value, double start, double end);
+ScrArr *scr_arr_fill_ref(ScrArr *a, void *value, double start, double end);
+ScrArr *scr_arr_fill_undefined(ScrArr *a, double start, double end);
 /* Math.max(...xs) / Math.min(...xs) over an f64-element array: the JS
  * fold (NaN poisons, ±0 by the JS preferences, empty → ∓Infinity). */
 double scr_math_max_arr(ScrArr *a);
@@ -1168,6 +1177,10 @@ ScrArr *scr_arr_with_undefined(ScrArr *a, double index);
 double scr_arr_push_f64(ScrArr *a, double v);
 double scr_arr_push_bool(ScrArr *a, bool v);
 double scr_arr_push_ref(ScrArr *a, void *v);
+/* Compiler-built slot buffers do not alias array storage. Both operations
+ * move ownership of every slot and preserve the evaluated argument order. */
+double scr_arr_push_many(ScrArr *a, size_t count, const uint64_t *slots);
+double scr_arr_unshift_many(ScrArr *a, size_t count, const uint64_t *slots);
 /* Append a same-element-kind array through the JS iterator contract: holes
  * become present undefined states. The source is borrowed and self-spread
  * duplicates the original indexed state. */
@@ -1321,10 +1334,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
@@ -1351,13 +1364,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
@@ -1380,7 +1397,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;
@@ -1388,12 +1405,21 @@ typedef struct ScrMap {
   size_t nlive;    /* live entries (Map.size) */
   size_t ecap;     /* entries capacity */
   ScrMapEntry *entries;
-  size_t nbuckets;  /* power of two; >= 2 * ecap so probes terminate */
+  size_t nbuckets;  /* zero for small linear maps; otherwise power of two >= 2 * nentries */
   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);
@@ -1426,9 +1452,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);
 
@@ -1438,6 +1466,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);
@@ -1452,6 +1483,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);
@@ -1467,6 +1501,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);
@@ -1484,6 +1519,7 @@ 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);
@@ -3397,6 +3433,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 */
@@ -3655,7 +3692,7 @@ typedef struct ScrJsval ScrJsval; /* opaque island cell (C11 repeat; the
  * result as an owned (+1) dyn value. `args` entries are BORROWED. */
 typedef ScrDyn *(*ScrDynThunk)(ScrClosure *clo, ScrDyn *const *args, size_t argc);
 
-/* Object member. Keys are malloc'd UTF-8 bytes (NUL-terminated for
+/* Object member. Keys own shared immutable UTF-8 bytes (NUL-terminated for
  * convenience; key_len excludes the NUL) — duplicate keys were already
  * collapsed at parse time (later wins, like JS JSON.parse). */
 typedef struct {
@@ -3664,13 +3701,22 @@ typedef struct {
   ScrDyn *value; /* owned */
   ScrDyn *getter; /* owned when this is an accessor property */
   ScrDyn *setter; /* owned when this is an accessor property */
-  bool accessor;
+  bool accessor : 1;
+  /* Snapshot written by trace before visiting children. Collected teardown
+   * must not inspect the value: an earlier cycle member may already be freed.
+   * Ordinary mutations need not maintain this collector-only decision. */
+  bool value_traced : 1;
   /* Ordinary object insertion sets all three attributes true. */
   bool writable;
   bool enumerable;
   bool configurable;
 } ScrDynEntry;
 
+_Static_assert(sizeof(ScrDynEntry) == (sizeof(void *) == 8 ? 48 : 24),
+               "LLVM checked-object readers use the target entry stride");
+_Static_assert(offsetof(ScrDynEntry, value) == 2 * sizeof(void *),
+               "LLVM checked-object readers use the third pointer-sized field");
+
 struct ScrDyn {
   size_t rc; /* SIZE_MAX = immortal (unused for dyn; kept per convention) */
   ScrDynKind kind;
@@ -3713,6 +3759,7 @@ struct ScrDyn {
        * interfaces may request a fresh snapshot with the true arm. */
       void *source_identity;
       ScrDyn *(*source_access)(void *, bool materialize);
+      struct ScrDynObjectIndex *index; /* optional wide-object lookup; owns no values */
     } obj; /* owned */
     /* SCR_DYN_FUNC: the boxed closure (owned) + its call descriptor. `sig`
      * and `name` are static compiler-emitted literals (never freed); name
@@ -3899,6 +3946,12 @@ void scr_dyn_install_async_iterator_symbol(ScrDyn *key);
 ScrDyn *scr_dyn_array_values_function(void);
 ScrDyn *scr_dyn_array_from_iterator(const ScrDyn *value);
 ScrDyn *scr_dyn_iterator_result(ScrDyn *value);
+/* Internal consumption of a captured builtin next method. Check can_step
+ * once before entering the loop. step returns an owned ordinary value;
+ * read step_done immediately afterward, before running any user code. */
+bool scr_dyn_iterator_can_step(const ScrDyn *iterator, const ScrDyn *next);
+ScrDyn *scr_dyn_iterator_step(const ScrDyn *iterator);
+bool scr_dyn_iterator_step_done(const ScrDyn *iterator);
 /* The ordinary object snapshot plus a retained typed source. source_access
  * releases that source when materialize=false and returns a fresh snapshot
  * when true. */
@@ -4498,6 +4551,8 @@ typedef struct {
 } ScrJsonBuf;
 
 void scr_jb_init(ScrJsonBuf *b);
+/* Append a borrowed byte span verbatim, including embedded NUL bytes. */
+void scr_jb_write(ScrJsonBuf *b, const char *s, size_t n);
 /* Append one borrowed runtime string verbatim (no JSON quoting). */
 void scr_jb_put_str(ScrJsonBuf *b, const ScrStr *s);
 /* Push a container onto the circular-detection stack before serializing
@@ -5793,9 +5848,10 @@ ScrBytes *scr_array_buffer_view_dv(ScrDyn *, ScrDyn *, ScrDyn *);
 /* Native callback boundary: exact owned u8 copy. NULL with len == 0 is an
  * empty span. */
 ScrBytes *scr_bytes_from_data(const uint8_t *data, size_t len); /* +1 */
+ScrBytes *scr_bytes_take_data(uint8_t *data, size_t len); /* +1, consumes malloc storage */
 
-/* `new Uint8Array(src)` / Buffer.from(u8): a same-elem-kind copy (the
- * compiler fences cross-kind construction). Borrows src. Never throws. */
+/* Same-element-kind copy, preserving the raw representation. Cross-kind
+ * construction uses scr_bytes_convert. Borrows src. Never throws. */
 ScrBytes *scr_bytes_copy(const ScrBytes *src); /* +1 */
 
 /* `new Uint8Array([1, 2, 3])` / Buffer.from(number[]): each f64 element
@@ -5959,6 +6015,7 @@ ScrStr *scr_text_decode_legacy(const ScrBytes *b, double encoding);
  * "utf16le" writes LE code units, surrogate pairs included. Borrows
  * both; +1 u8 result. Never throws. */
 ScrBytes *scr_bytes_from_str(const ScrStr *s, const ScrStr *enc);
+ScrBytes *scr_bytes_from_str_checked(const ScrStr *s, const ScrStr *enc);
 
 /* Buffer.byteLength(string, enc) — enc NORMALIZED like from_str — and
  * Buffer.isEncoding(name) (case-insensitive over Node's alias set).