fix(events,fs,globals): node v26 parity — events.on async iterator, fs watch buffering, four globals diffs

crates/perry-runtime/src/array/generic.rs

@@ -1071,7 +1071,13 @@ pub extern "C" fn js_arraylike_slice(
     } else {
         clamp_index(start, len)
     };
-    let e = if has_end == 0 {
+    // ECMA-262 §23.1.3.25 step 4: an `end` of `undefined` (whether omitted OR
+    // passed explicitly, e.g. `Array.prototype.slice.call(arr, 1, undefined)`)
+    // means "to the end" (relativeEnd = len). Only a present, non-undefined
+    // `end` is run through ToIntegerOrInfinity. `clamp_index` maps the
+    // TAG_UNDEFINED bit pattern (a NaN) to 0, which would wrongly empty the
+    // slice — so special-case it here.
+    let e = if has_end == 0 || end.to_bits() == crate::value::TAG_UNDEFINED {
         len
     } else {
         clamp_index(end, len)

crates/perry-runtime/src/atomics.rs

@@ -475,11 +475,12 @@ pub extern "C" fn js_atomics_load(_closure: *const ClosureHeader, view: f64, ind
 
 #[no_mangle]
 pub extern "C" fn js_atomics_is_lock_free(_closure: *const ClosureHeader, size: f64) -> f64 {
-    // ToIntegerOrInfinity(size) (runs `valueOf`/`toString`, so `'1'`, `true`,
-    // `{valueOf:()=>1}` and `3.14`→3 all behave like Node), then a membership
-    // test over the lock-free element widths.
-    let n = numeric_arg(size);
-    nanbox_bool(matches!(n as i64, 1 | 2 | 4 | 8))
+    // ToNumber(size) (runs `valueOf`/`toString`, so `'4'`→4 behaves like Node),
+    // then an EXACT membership test over the lock-free element widths. Node/V8
+    // compares the raw number, so `4.9` is NOT floored to 4 — it is simply not a
+    // valid element width and returns false.
+    let n = number_arg(size);
+    nanbox_bool(n == 1.0 || n == 2.0 || n == 4.0 || n == 8.0)
 }
 
 #[no_mangle]

crates/perry-runtime/src/builtins/globals.rs

@@ -281,9 +281,26 @@ pub extern "C" fn js_decode_uri_component(value: f64) -> i64 {
 const ESCAPE_UNESCAPED: &[u8] =
     b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@*_+-./";
 
+/// `ToString(value)` throws a TypeError for a Symbol argument. `escape` /
+/// `unescape` (and the URI family) apply ToString to their input, so a Symbol
+/// must reject rather than coerce to a `"Symbol(x)"` description string.
+fn throw_if_symbol(value: f64) {
+    if (value.to_bits() & 0xFFFF_0000_0000_0000) == crate::value::POINTER_TAG
+        && crate::symbol::is_registered_symbol(
+            (value.to_bits() & crate::value::POINTER_MASK) as usize,
+        )
+    {
+        let msg = b"Cannot convert a Symbol value to a string";
+        let msg_str = js_string_from_bytes(msg.as_ptr(), msg.len() as u32);
+        let err = crate::error::js_typeerror_new(msg_str);
+        crate::exception::js_throw(crate::value::js_nanbox_pointer(err as i64));
+    }
+}
+
 /// escape(string) -> string (legacy, ES Annex B B.2.1.1)
 #[no_mangle]
 pub extern "C" fn js_escape(value: f64) -> i64 {
+    throw_if_symbol(value);
     let input = extract_str_from_nanbox(value);
     let mut result = String::with_capacity(input.len() * 3);
     let mut buf = [0u16; 2];
@@ -310,6 +327,7 @@ pub extern "C" fn js_escape(value: f64) -> i64 {
 /// unescape(string) -> string (legacy, ES Annex B B.2.1.2)
 #[no_mangle]
 pub extern "C" fn js_unescape(value: f64) -> i64 {
+    throw_if_symbol(value);
     let input = extract_str_from_nanbox(value);
     let chars: Vec<char> = input.chars().collect();
     // Reassemble into UTF-16 code units, then decode, so `%uD835%uDFD8`-style

crates/perry-runtime/src/fs/dir_glob_watch.rs

@@ -1522,7 +1522,10 @@ fn start_promise_watcher(id: usize, state: &mut PromiseWatchState) {
     if state.active || state.closed {
         return;
     }
-    state.snapshot = snapshot_watch_target(&state.path, state.recursive).unwrap_or_default();
+    // Keep the creation-time baseline (seeded in `js_fs_promises_watch`) rather
+    // than re-snapshotting here — re-snapshotting would discard any events that
+    // occurred between `watch()` and this first `.next()` pull, which Node
+    // delivers (it buffers from FSWatcher creation, not from first iteration).
     let timer_callback = poll_closure_value(promise_watcher_poll_impl as *const u8, id);
     let timer_id = crate::timer::setInterval(timer_callback as i64, FS_WATCH_POLL_INTERVAL_MS);
     if !state.persistent {
@@ -2207,11 +2210,19 @@ pub extern "C" fn js_fs_promises_watch(path_value: f64, options_value: f64) -> f
         Ok(signal) => signal,
         Err(err) => crate::exception::js_throw(err),
     };
-    if let Err(err) = snapshot_watch_target(&path, recursive) {
-        unsafe {
+    // Capture the directory state at creation time. Node registers the
+    // FSWatcher synchronously in `watch()` and buffers events emitted before
+    // the first `.next()` pull, so a file written between `watch()` and the
+    // first iteration is still delivered. Perry's watcher is poll-based and
+    // previously took its baseline snapshot lazily at the first `.next()`,
+    // which silently dropped those pre-iteration events. Seed the baseline
+    // here so the first poll diffs against the creation-time state.
+    let initial_snapshot = match snapshot_watch_target(&path, recursive) {
+        Ok(snapshot) => snapshot,
+        Err(err) => unsafe {
             crate::exception::js_throw(build_fs_error_value(&err, "watch", &path));
-        }
-    }
+        },
+    };
     let id = next_watch_id();
     let object_value = build_promise_watcher_object(id);
     let abort_listener = signal
@@ -2235,7 +2246,7 @@ pub extern "C" fn js_fs_promises_watch(path_value: f64, options_value: f64) -> f
                 timer_id: 0,
                 persistent,
                 active: false,
-                snapshot: WatchSnapshot::new(),
+                snapshot: initial_snapshot,
                 queue: VecDeque::new(),
                 pending: VecDeque::new(),
                 signal: signal_value,

crates/perry-runtime/src/promise/async_step.rs

@@ -48,22 +48,17 @@ pub extern "C" fn js_promise_resolved(value: f64) -> *mut Promise {
     // Issue #586: ECMAScript thenable assimilation. The async-to-generator
     // transform rewrites every `await x` into `Promise.resolve(x).then(...)`
     // — which means thenable assimilation has to happen here, not in the
-    // codegen-side `Expr::Await` lowering. `js_assimilate_thenable` returns
-    // a fresh Promise wrapper that follows the thenable's `.then(resolve,
-    // reject)` callbacks; chain its eventual state into our outer promise
-    // via the same `js_promise_resolve_with_promise` pattern as the real-
-    // Promise arm above. Drizzle's `QueryPromise` (`then` triggers the SQL
-    // round-trip) is the load-bearing motivating case (#488).
-    let assim = js_assimilate_thenable(value);
-    if assim.to_bits() != value.to_bits() && js_value_is_promise(assim) != 0 {
-        let inner = crate::value::js_nanbox_get_pointer(assim) as *mut Promise;
-        if !inner.is_null() && inner != promise {
-            js_promise_resolve_with_promise(promise, inner);
-            return promise;
-        }
-    }
-
-    js_promise_resolve(promise, value);
+    // codegen-side `Expr::Await` lowering. `promise_resolve_assimilating`
+    // implements the spec PromiseResolveThenableJob: a thenable's `.then` is
+    // invoked from a SCHEDULED microtask, never synchronously during resolve.
+    // This matters for `Promise.race`/`Promise.any` over a thenable, where Node
+    // does not call the thenable's `then` until the job runs (so the count of
+    // synchronous `then` invocations stays 0). Primitives (fast path above) and
+    // native Promises (short-circuit above) never reach here, so the per-await
+    // steady state is untouched; only real thenables (drizzle's `QueryPromise`,
+    // object literals with `then`) defer by one microtask — which the await
+    // loop drains, leaving the resolved value identical.
+    super::combinators::promise_resolve_assimilating(promise, value);
     promise
 }