fix(ci): libwebkitgtk-6.0-dev for ubuntu doc-tests-gtk4 (v0.5.848)

v0.5.842's libwebkit2gtk-4.1-dev / libjavascriptcoregtk-4.1-dev names
were wrong — webkit6 = "=0.4" needs the 6.0 .pc files. Ubuntu 24.04
ships libwebkitgtk-6.0-dev which provides both webkitgtk-6.0.pc and
javascriptcoregtk-6.0.pc.

Author: proggeramlug

.github/workflows/test.yml

@@ -699,18 +699,18 @@ jobs:
           # found in the pkg-config search path". gstreamer-base is the
           # transitive dep gstreamer-base-sys needs for the playbin element
           # that perry/media wraps.
-          # libjavascriptcoregtk-4.1-dev added for the perry/ui-gtk4 WebView
-          # feature (Phases 1-5 + v2 follow-ups, #658): javascriptcore6-sys
-          # in the dep tree of webkit2gtk-6.0 needs `javascriptcoregtk-6.0.pc`
-          # findable via pkg-config. Without it doc-tests-gtk4 fails the
-          # cargo build step with "Package javascriptcoregtk-6.0 was not found
-          # in the pkg-config search path". libwebkit2gtk-4.1-dev pulls
-          # libjavascriptcoregtk-4.1-dev as a transitive dep on ubuntu-24.04.
+          # libwebkitgtk-6.0-dev added for the perry/ui-gtk4 WebView
+          # feature (Phases 1-5 + v2 follow-ups, #658): the `webkit6` crate
+          # (0.4 series) and its transitive `javascriptcore6-sys` need
+          # `webkitgtk-6.0.pc` AND `javascriptcoregtk-6.0.pc` findable via
+          # pkg-config. Ubuntu 24.04 (noble) ships libwebkitgtk-6.0-dev
+          # which provides BOTH .pc files (the old libwebkit2gtk-4.1-dev
+          # name only ships the 4.1 .pc and that's not what webkit6 wants).
           sudo apt-get install -y \
             libgtk-4-dev libadwaita-1-dev xvfb pkg-config \
             libpulse-dev \
             libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev \
-            libwebkit2gtk-4.1-dev libjavascriptcoregtk-4.1-dev
+            libwebkitgtk-6.0-dev
 
       - name: Surface Android NDK location (for cross-compile)
         if: matrix.os == 'macos-14' || matrix.os == 'ubuntu-24.04'

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 Detailed changelog for Perry. See CLAUDE.md for concise summaries.
 
+## v0.5.848 — fix(ci): swap to `libwebkitgtk-6.0-dev` for ubuntu-24.04 doc-tests-gtk4. v0.5.842 added `libwebkit2gtk-4.1-dev libjavascriptcoregtk-4.1-dev` to the gtk4 doc-test apt step, but `webkit6 = "=0.4"` (perry-ui-gtk4 #658 WebView) pulls `javascriptcore6-sys` which needs `javascriptcoregtk-6.0.pc` AND `webkitgtk-6.0.pc` (the API rename — 4.1 dropped the "2"). Ubuntu 24.04 noble ships `libwebkitgtk-6.0-dev` which provides both .pc files. Pure CI-config; no runtime change.
+
 ## v0.5.847 — fix(runtime,codegen): two numeric-coercion-at-the-boundary bugs surfaced together while probing real-app patterns. **Bug 1 — `isNaN("1")` returned `true`, `Number.isFinite("1")` returned `true`.** Both forms of these globals exist (`isNaN` / `Number.isNaN` and `isFinite` / `Number.isFinite`); they differ in coercion: the bare global coerces via ToNumber, the `Number.`-prefixed variant is strict (any non-Number → false). Pre-fix the codegen at `crates/perry-codegen/src/expr.rs:5186` lowered `Expr::IsNaN` to an inline `fcmp uno x, x` (true iff either operand is NaN by IEEE 754 unordered compare). That idiom is correct for raw numbers, but every NaN-boxed Perry value (strings, pointers, undefined, null) HAS a NaN bit pattern by construction — `isNaN(any-non-number)` was unconditionally true. Separately the `Expr::IsFinite | Expr::NumberIsFinite` arm at line 5594 merged both forms and called `js_is_finite` (coercing), even though the runtime already had a separate strict `js_number_is_finite` (`builtins.rs:1755-1769`) that codegen never called. **Bug 2 — `"abc".padStart(-1, "_")` allocated 4+ GiB of underscores before OOM-killing the process.** Same shape, different boundary: the codegen at `crates/perry-codegen/src/lower_string_method.rs:387` lowered the target-length f64 via `fptosi(DOUBLE → I32)` — LLVM's `fptosi` is undefined behavior on NaN/Infinity and varies by platform; on macOS aarch64 a literal `NaN` constant-folded to a positive INT_MAX-ish value. The runtime signature took the result as `u32`, so any negative i32 (`-1`) reinterpreted to `0xFFFFFFFF` (~4 billion), the `current_len >= target_len` guard fell through unconditionally, and the loop ran 4 billion iterations of `push_char`. **Fixes.** (a) Split the merged `Expr::IsFinite | Expr::NumberIsFinite` arm into two arms; route `IsFinite` → `js_is_finite` (coercing), `NumberIsFinite` → `js_number_is_finite` (strict). (b) Rewrite the `Expr::IsNaN` arm to call `js_is_nan` (coercing) instead of the inline `fcmp uno`. `Expr::NumberIsNaN` was already correct. (c) Change `js_string_pad_start` and `js_string_pad_end` runtime sigs from `u32` to `f64`; drop the codegen `fptosi`+I32 step and forward the DOUBLE through. New runtime helper `to_length_clamped` applies ToLength semantics: NaN / ≤ 0 → 0, Infinity / huge values → a 1 MiB cap (saner than the spec's 2^53-1 — protects against pathological inputs without breaking real-app use). **Validation.** Probes byte-identical to Bun: 15-case `/tmp/probe_isfinite.ts` (all four isNaN/isFinite variants × number/NaN/Infinity/string/bool/null/undefined inputs); 7-case `/tmp/probe_pad_neg.ts` + 3-case `/tmp/probe_pad_nan.ts` (literal/dynamic neg/NaN/Infinity for both padStart and padEnd). 26/28 gap parity tests pass. Same worktree branch as v0.5.838 (`worktree-claude-array-followups`); renumbered through v0.5.842→843→844→845→847 on successive rebases as Ralph's CI / perf / msg_send! / cargo-fmt commits kept landing in parallel.
 
 ## v0.5.846 — fix(ci): cargo fmt drift in `crates/perry-transform/src/generator.rs:1566`. v0.5.845's Tests-workflow lint job failed on `let throw_id = throw_closure_expr.as_ref().map(|_| alloc_local(next_local_id));` — CI's stable rustfmt wants the method chain broken across three lines once the expression exceeds the width budget. Single-file fix; no semantic change. Pre-tag CI prep.

CLAUDE.md

@@ -8,7 +8,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 Perry is a native TypeScript compiler written in Rust that compiles TypeScript source code directly to native executables. It uses SWC for TypeScript parsing and LLVM for code generation.
 
-**Current Version:** 0.5.847
+**Current Version:** 0.5.848
 
 
 ## TypeScript Parity Status

Cargo.toml

@@ -188,7 +188,7 @@ opt-level = "s"       # Optimize for size in stdlib
 opt-level = 3
 
 [workspace.package]
-version = "0.5.847"
+version = "0.5.848"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/PerryTS/perry"

crates/perry-codegen/src/expr.rs

@@ -8058,6 +8058,26 @@ pub(crate) fn lower_expr(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
             Ok(nanbox_pointer_inline(blk, &promise_handle))
         }
 
+        // -------- #691 Phase 2: current step closure (self-ref) ----
+        // Reads the live step closure pointer from INLINE_TRAP.current_step
+        // TLS and NaN-boxes it. Only safe inside a step body or any
+        // code wrapped by js_async_first_call.
+        Expr::CurrentStepClosure => {
+            let blk = ctx.block();
+            let step_handle = blk.call(I64, "js_get_current_step_closure", &[]);
+            Ok(nanbox_pointer_inline(blk, &step_handle))
+        }
+
+        // -------- #691 Phase 2: first invocation with TLS setup -----
+        // Runtime helper takes the NaN-boxed closure pointer, saves
+        // the previous INLINE_TRAP, sets current_step, calls
+        // js_closure_call2(closure, undefined, false), then restores.
+        Expr::AsyncFirstCall { step_closure } => {
+            let step_box = lower_expr(ctx, step_closure)?;
+            let blk = ctx.block();
+            Ok(blk.call(DOUBLE, "js_async_first_call", &[(DOUBLE, &step_box)]))
+        }
+
         // -------- Object.getOwnPropertyNames(obj) --------
         // Returns ALL own keys (including non-enumerable ones from
         // defineProperty), unlike Object.keys which skips them.

crates/perry-codegen/src/lower_call.rs

@@ -488,6 +488,33 @@ pub(crate) fn lower_call(ctx: &mut FnCtx<'_>, callee: &Expr, args: &[Expr]) -> R
         }
     }
 
+    // #691 Phase 2: calling the current step closure via TLS.
+    // `build_async_step_driver_direct` emits this for the catch arm's
+    // `__step(e, true)` recursive re-entry — there's no captured
+    // local to refer to anymore, so the callee is read out of TLS.
+    // Dispatches through the same `js_closure_call<N>` family.
+    if matches!(callee, Expr::CurrentStepClosure) {
+        let recv_box = lower_expr(ctx, callee)?;
+        let mut lowered_args: Vec<String> = Vec::with_capacity(args.len());
+        for a in args {
+            lowered_args.push(lower_expr(ctx, a)?);
+        }
+        if lowered_args.len() > 16 {
+            bail!(
+                "perry-codegen Phase D.1: CurrentStepClosure call with {} args (max 16)",
+                lowered_args.len()
+            );
+        }
+        let blk = ctx.block();
+        let closure_handle = unbox_to_i64(blk, &recv_box);
+        let runtime_fn = format!("js_closure_call{}", lowered_args.len());
+        let mut call_args: Vec<(crate::types::LlvmType, &str)> = vec![(I64, &closure_handle)];
+        for v in &lowered_args {
+            call_args.push((DOUBLE, v.as_str()));
+        }
+        return Ok(blk.call(DOUBLE, &runtime_fn, &call_args));
+    }
+
     // Closure-typed local call: `counter()` where `counter` is a
     // local of `Type::Function(...)`. Dispatch through the runtime
     // `js_closure_call<N>` family — the runtime extracts the function

crates/perry-codegen/src/runtime_decls.rs

@@ -2336,6 +2336,14 @@ pub fn declare_stdlib_ffi(module: &mut LlModule) {
     // Promise (INLINE_TRAP_NEXT) when called from inside the microtask
     // runner dispatching this same step closure.
     module.declare_function("js_async_step_done", I64, &[DOUBLE, I64]);
+    // #691 Phase 2: returns the live step closure pointer from
+    // INLINE_TRAP.current_step TLS. Codegen NaN-boxes the result.
+    module.declare_function("js_get_current_step_closure", I64, &[]);
+    // #691 Phase 2: wrap the wrapper's initial step invocation with
+    // TLS setup so `js_get_current_step_closure` inside the body sees
+    // the right pointer on the very first state. Saves/restores
+    // INLINE_TRAP across the call for nested-async composition.
+    module.declare_function("js_async_first_call", DOUBLE, &[DOUBLE]);
 
     // ========== Slugify ==========
     module.declare_function("js_slugify", I64, &[I64]);

crates/perry-hir/src/ir.rs

@@ -1318,6 +1318,32 @@ pub enum Expr {
         step_closure: Box<Expr>,
     },
 
+    /// #691 Phase 2. Returns the currently-running step closure as a
+    /// NaN-boxed pointer (read from `INLINE_TRAP.current_step` TLS).
+    /// Used by `build_async_step_driver_direct` to replace the
+    /// `step_id` self-capture inside the step body — eliminates the
+    /// per-invocation `js_box_alloc` for the self-reference and
+    /// shrinks the step closure by one capture slot. Codegen also
+    /// recognizes it as a callee in `Expr::Call` so the catch arm's
+    /// `__step(e, true)` recursive re-entry works without the
+    /// captured local.
+    /// Only emitted by `build_async_step_driver_direct` — never by
+    /// user code.
+    CurrentStepClosure,
+
+    /// #691 Phase 2. Invokes a freshly-built step closure with
+    /// (undefined, false) and the proper `CURRENT_STEP_CLOSURE` TLS
+    /// setup. Used at the bottom of the async-step wrapper in place
+    /// of a direct `__step(undefined, false)` call so that
+    /// `Expr::CurrentStepClosure` inside the body returns the right
+    /// pointer on the very first state transition. The runtime
+    /// helper saves and restores the previous trap state so nested
+    /// async calls compose.
+    /// Only emitted by `build_async_step_driver_direct`.
+    AsyncFirstCall {
+        step_closure: Box<Expr>,
+    },
+
     // Crypto operations
     CryptoRandomBytes(Box<Expr>), // crypto.randomBytes(size) -> string (hex)
     CryptoRandomUUID,             // crypto.randomUUID() -> string

crates/perry-hir/src/walker.rs

@@ -738,6 +738,10 @@ where
             f(value);
             f(step_closure);
         }
+        Expr::CurrentStepClosure => {}
+        Expr::AsyncFirstCall { step_closure } => {
+            f(step_closure);
+        }
 
         // ─── Buffer family ───────────────────────────────────────────────
         Expr::BufferFrom { data, encoding } => {
@@ -1886,6 +1890,10 @@ where
             f(value);
             f(step_closure);
         }
+        Expr::CurrentStepClosure => {}
+        Expr::AsyncFirstCall { step_closure } => {
+            f(step_closure);
+        }
         Expr::BufferFrom { data, encoding } => {
             f(data);
             if let Some(e) = encoding {

crates/perry-runtime/src/promise.rs

@@ -1479,6 +1479,56 @@ pub extern "C" fn js_async_step_done(value: f64, step_closure: ClosurePtr) -> *m
     }
 }
 
+/// #691 Phase 2 helper. Returns the currently-dispatching step
+/// closure as a raw `*mut ClosureHeader`. Codegen NaN-boxes the
+/// result. Lets the async-to-generator transform emit
+/// `Expr::CurrentStepClosure` inside the step body in place of a
+/// captured `step_id` self-reference — saves one `js_box_alloc` per
+/// async-fn invocation and shrinks the step closure by one capture
+/// slot. Safe to call only from inside a step body (or from any code
+/// known to run inside `Task::AsyncStep` dispatch or
+/// `js_async_first_call`); returns null otherwise.
+#[no_mangle]
+pub extern "C" fn js_get_current_step_closure() -> *mut crate::closure::ClosureHeader {
+    let trap = INLINE_TRAP.with(|c| c.get());
+    trap.current_step as *mut crate::closure::ClosureHeader
+}
+
+/// #691 Phase 2 helper. Invoke a freshly-built step closure for the
+/// very first state transition of an async-fn activation. The wrapper
+/// emits this in place of `__step(undefined, false)` so that
+/// `CURRENT_STEP_CLOSURE` TLS is set before the body runs — without
+/// this setup, `js_get_current_step_closure` inside the body would
+/// observe whatever the previous `Task::AsyncStep` left (or null on
+/// cold entry). Saves and restores the previous trap state so nested
+/// async-fn calls compose correctly.
+///
+/// Takes the closure NaN-boxed (the HIR caller passes it via a
+/// regular Expr) and returns the closure's own return value
+/// (typically a Promise pointer NaN-boxed by the step body).
+#[no_mangle]
+pub extern "C" fn js_async_first_call(step_closure_nanbox: f64) -> f64 {
+    let ptr = crate::value::js_nanbox_get_pointer(step_closure_nanbox)
+        as *mut crate::closure::ClosureHeader;
+    let prev = INLINE_TRAP.with(|c| {
+        let old = c.get();
+        c.set(InlineTrap {
+            trap_next: old.trap_next,
+            current_step: ptr as usize,
+        });
+        old
+    });
+    let result = unsafe {
+        crate::closure::js_closure_call2(
+            ptr,
+            f64::from_bits(0x7FFC_0000_0000_0001), // TAG_UNDEFINED
+            f64::from_bits(0x7FFC_0000_0000_0003), // TAG_FALSE
+        )
+    };
+    INLINE_TRAP.with(|c| c.set(prev));
+    result
+}
+
 // Thread-local single-slot cache for async-step thunks. Keyed by the
 // step closure pointer. When the same step closure is used across
 // multiple promise-of-promise awaits (the simple-probe shape), we