Update dependency Jint to 4.14.0

[renovate]

ℹ️ Note

This PR body was truncated due to platform limits.

This PR contains the following updates:

Package	Change	Age	Confidence
Jint	4.10.0 → 4.14.0

---

Release Notes

sebastienros/jint (Jint)

v4.14.0

Jint 4.14.0 is an interop-focused performance release: CLR arrays now cross into script as live views instead of copies, recently wrapped host objects reuse their wrappers, single-candidate interop method calls dispatch through compiled invokers, and JSON.parse interns repeated keys and values. Host collection traversal is 10.9× faster than 4.13.0. Two interop defaults changed in this release — read the first two highlights if you pass CLR arrays to scripts or rely on per-crossing conversion behavior; everything else needs no code changes to benefit.

Highlights

CLR arrays are live views by default (behavior change). Options.Interop.ArrayConversion now defaults to ArrayConversionMode.LiveView (#​2721, #​2728, #​2735): a single-rank T[] crossing into script becomes a live, fixed-size view over the underlying array — the way wrapped List<T> already behaves — instead of being copied into a new JS array on every read. Writes go through in both directions, and arrays exposed through read-only-declared members (e.g. IReadOnlyList<T>) produce read-only views. Iteration, Array.prototype methods, JSON serialization, index-key enumeration (Object.keys / for..in yield "0".."n-1") and undefined for out-of-range reads all behave array-like, but Array.isArray returns false, and because CLR arrays are fixed-size, resizing operations (push/pop/length writes) throw a TypeError like integer-indexed exotic objects do — shift/splice may move elements before their length change throws, as for typed arrays. Set Options.Interop.ArrayConversion = ArrayConversionMode.Copy to restore the 4.13 behavior.

Recently wrapped CLR objects reuse their wrappers (behavior change). The new Options.Interop.CacheRecentObjectWrappers defaults to true (#​2734): a small bounded ring (8 entries, keyed by reference identity and exposed type) reuses wrappers for host objects that repeatedly cross into script. Wrapper identity becomes stable (host.Obj === host.Obj), script-attached state (freeze, defineProperty, expandos) survives crossings, and the per-crossing wrapper allocation disappears. Under Copy array conversion this also means repeated reads of the same CLR array reuse the first JsArray snapshot while it stays cached — CLR-side mutations are not re-copied; set the option to false for the pre-4.14 fresh-snapshot-per-crossing behavior. Engine.Dispose() releases the ring.

Interop fast lanes. Single-candidate method calls run through a compiled invoker that binds and invokes without argument arrays or boxing (#​2733), with per-parameter binding flags precomputed (#​2719). Resolved ObjectWrapper members get a per-call-site inline cache (#​2722) and the member-call fast path covers primitive string receivers (#​2717). Array-like wrapper creation is a cached factory call with lazily materialized length (#​2730), primitive elements convert without boxing on both indexed reads and Array.prototype iteration (#​2731, #​2735), the wrapper identity caches cover CLR arrays (#​2716), and implicitly implemented interface methods are deduplicated in member resolution (#​2711).

JSON. JSON.parse interns property keys and string values within a parse, parses numbers off the span with an exactly-rounded fast path and scans string content in bulk (#​2718, #​2725, #​2732) — the json-parse-modern comparison row is 6% faster with 23% less allocation than 4.13.0. Parsing is also aligned with the JSON grammar (#​2738): malformed numbers like -09 and 1. are now rejected as in V8, while raw U+2028/U+2029 in strings and escaped control characters in keys — both valid JSON — are now accepted.

Strings. Chained slice/substring and split segments stay zero-copy views (#​2720), whole-string substring/substr return the receiver, and mismatched-length comparisons no longer materialize views (#​2740).

Execution constraints at host boundaries. Timeouts and cancellation are re-checked when control returns from host CLR code, so detection latency is bounded by one host call instead of a statement-count window, without adding per-statement cost — gated on execution depth so host-side reads of wrapped objects on an idle engine never observe a stale timer (#​2713, #​2714, #​2715). Execution-context depth stays balanced when constraint exceptions unwind generator/async frames, and a host callback that re-enters the engine no longer resets the outer script's budget (#​2736).

Correctness (including a pre-release review). A review of everything since 4.13.0 fixed: spurious TDZ when a for-header reads a name the loop body shadows (#​2709) and stale closure captures from destructuring defaults in for-loop headers (#​2739); the compiled-invoker lane now defers to custom ITypeConverters and preserves reflection exception types (#​2737); and the new wrapper defaults were hardened — declared-type contracts for arrays (an IReadOnlyList<T>-typed member no longer yields a writable view), a static type-mapper poisoning crash, Engine.Dispose releasing the wrapper caches, and JS-array in/enumeration/out-of-range semantics on array views (#​2735). Closure reads memoize slot-cache chain reachability (#​2726).

On the engine comparison benchmarks, Jint 4.14.0 beats ClearScript (native V8) by 7.1×–9.1× on every script ↔ host interop row — host collection traversal went from last to second among all engines at 15,597 → 1,433 µs with 99% less allocation — while remaining the fastest managed engine on 10 of 12 pure-JS scripts and the fastest interpreter on all 12, and now leading array-stress and dromaeo-object-array, rows V8 narrowly led at 4.13.0.

What's Changed

• Refresh EngineComparison benchmarks for 4.13.0 by @​lahma in #​2704
• Fix spurious TDZ when a for-header reads a name the loop body shadows by @​svenrog in #​2709
• Bump the testing group with 1 update by @​dependabot[bot] in #​2710
• Add tests for using modules from script code run via Evaluate by @​lahma in #​2712
• Deduplicate implicitly implemented interface methods in member resolution by @​lahma in #​2711
• Re-check amortized constraints at interpreter/host-code boundaries by @​lahma in #​2713
• Add ClearScript V8 to engine comparison benchmarks, trim suite, add script-to-host interop suite by @​viceice in #​1775
• Gate host-boundary constraint checks on active evaluation and harden coverage by @​lahma in #​2714
• Key the host-boundary constraint gate on execution depth and close remaining lanes by @​lahma in #​2715
• Cover CLR arrays with the interop identity caches by @​lahma in #​2716
• Extend the member-call fast path to primitive string receivers by @​lahma in #​2717
• Intern object property keys within a single JSON parse by @​lahma in #​2718
• Precompute per-parameter interop binding flags by @​lahma in #​2719
• Keep slice-of-slice and split segments zero-copy by @​lahma in #​2720
• Add opt-in ClrArrayConversion.LiveView interop mode for CLR arrays by @​lahma in #​2721
• Cache resolved ObjectWrapper members per member-expression node by @​lahma in #​2722
• Refresh engine comparison README after the V8-gap campaign by @​lahma in #​2723
• Bulk string scanning and a simple-number fast path for JSON.parse by @​lahma in #​2725
• Memoize slot-cache chain reachability for closure reads by @​lahma in #​2726
• Refresh engine comparison tables after the second campaign round by @​lahma in #​2727
• Default Interop.ArrayConversion to LiveView for 4.14 by @​lahma in #​2728
• Cache array-like wrapper factories and materialize length lazily by @​lahma in #​2730
• Convert primitive array-like wrapper elements without boxing by @​lahma in #​2731
• Add a compiled-invoker fast lane for single-candidate interop method calls by @​lahma in #​2733
• Intern JSON.parse string values and parse numbers off the span by @​lahma in #​2732
• Default Interop.CacheRecentObjectWrappers to true for 4.14 by @​lahma in #​2734
• Harden LiveView array wrappers and interop wrapper caches for 4.14 by @​lahma in #​2735
• Keep execution-context depth balanced under raw constraint exceptions by @​lahma in #​2736
• Decline the compiled-invoker fast lane for custom type converters and foreign receivers by @​lahma in #​2737
• Align JSON.parse with the JSON grammar for numbers, line separators and keys by @​lahma in #​2738
• Decline for-loop environment reuse when a pattern default embeds a closure by @​lahma in #​2739
• Skip materialization on mismatched-length string compares and whole-string substrings by @​lahma in #​2740
• Refresh engine comparison benchmarks for 4.14.0 by @​lahma in #​2741

Full Changelog: sebastienros/jint@v4.13.0...v4.14.0

v4.13.0

Jint 4.13.0 is a performance- and correctness-focused release. It brings a Proxy overhaul — trap dispatch rebuilt to forward with near-zero allocation, plus a new public API for implementing traps in .NET — extends the unboxed interpreter fast lanes to more operators and loop shapes, and cuts allocations on for..of, nested-function calls and array enumeration. A thorough pre-release review of everything since 4.12.0 also fixed several correctness bugs. No code changes are required to benefit.

Highlights

Proxy overhaul, and a CLR trap API. Proxy trap dispatch was rebuilt around a shared skeleton with lazy argument construction and pooled arrays, so a proxy with no matching trap forwards to its target with effectively zero allocation (#​2674, #​2675, #​2676). Proxies can now be implemented from .NET: Engine.Advanced.CreateProxy / CreateRevocableProxy accept a ProxyHandler whose virtual methods are the traps, with the same invariant enforcement as JavaScript handlers (#​2678). Several Proxy spec fixes came along — getPrototypeOf / setPrototypeOf with null prototypes (#​2668), the construct trap's argument array (#​2670), capturing [[Construct]] at creation (#​2669), and the get trap firing for a property named revoke (#​2667) — and the ObjectWrapper iterator helpers are hardened against foreign and revoked receivers (#​2681).

Interpreter fast lanes. New unboxed operand lanes for the arithmetic binary operators (#​2664) and an int32 fast lane for remainder (#​2671) remove per-iteration boxing; flag-proven casts use Unsafe.As on the hot paths (#​2673) and JsNumber.Create avoids a native fmod (#​2662). Strict-equality guards against undefined / null / typeof are fused (#​2658), member-expression identifier reads route through the identifier caches (#​2660), and the identifier slot cache is restructured hop-0-first (#​2689). The tight-loop fast lane now covers while and do-while bodies (#​2688).

Lower allocations. for..of over an array no longer allocates an iterator-result object per element (#​2700); per-call nested-function instantiation is allocation-free (#​2684); for-in over arrays enumerates dense indices lazily without materializing a key list (#​2656); and observation-only constraint checks are amortized so tight loops stay fast under a timeout (#​2672).

RegExp. Quantified groups without capture or lookaround hazards prefer the .NET Regex engine (#​2682), reused .NET adaptations adaptively upgrade to RegexOptions.Compiled (#​2690), and the custom engine's match timeout is enforced by an inline deadline rather than a thread-pool timer (#​2686).

Correctness (including a pre-release review). A review of everything since 4.12.0 fixed: a regex routing regression that silently truncated matches for nullable non-capturing quantified groups (#​2694) and a custom-engine bug dropping iterations for multi-atom quantified groups (#​2699); Proxy trap dispatch is now atomic against a mid-dispatch revoke (#​2696); top-level await of a .NET Task in a module (#​2665), plus prompt cancellation of the await drain (#​2697); the arguments object escaping a short-circuiting logical compound assignment un-materialized (#​2698); for-in now includes inherited enumerable index properties on Array.prototype (#​2655); and the memory limit stays exact in tight loops (#​2695).

Across the managed JavaScript engines for .NET, Jint 4.13.0 is the fastest engine on 17 of the 21 comparison scripts — and the fastest interpreter on all 21 — while allocating far less memory than the other engines; dromaeo-3d-cube is ~9% faster and dromaeo-string-base64 ~10% faster than 4.12.0. See the engine comparison benchmarks for the full table.

What's Changed

• Drop Jurassic from engine comparison benchmarks, add Okojo by @​lahma in #​2653
• Add benchmark lanes for for-in over arrays, holey-array traversal and large-chunk string concat by @​lahma in #​2654
• Fix for-in missing inherited enumerable index properties placed on Array.prototype by @​lahma in #​2655
• for-in over arrays: enumerate dense indices lazily without materializing a key list by @​lahma in #​2656
• Harden the known wall-clock test flakes by @​lahma in #​2657
• Fuse strict-equality guards: x === undefined/null and typeof x === "literal" by @​lahma in #​2658
• Skip the prototype walk for array hole reads when the chain is provably clean by @​lahma in #​2659
• Route member-expression identifier-object reads through identifier caches by @​lahma in #​2660
• Avoid native fmod in JsNumber.Create(double) integral detection by @​lahma in #​2662
• Add unboxed operand lane for arithmetic binary operators by @​lahma in #​2664
• Fix top-level await of a .NET Task in a module failing with "Pending" by @​lahma in #​2665
• Add Proxy trap dispatch benchmarks by @​lahma in #​2666
• Fix Proxy get trap being bypassed for properties named "revoke" by @​lahma in #​2667
• Add int32 fast lane to the raw-double remainder sites by @​lahma in #​2671
• Fix Proxy getPrototypeOf/setPrototypeOf traps with null prototypes by @​lahma in #​2668
• Capture Proxy [[Construct]] at creation per ProxyCreate by @​lahma in #​2669
• Replace flag-proven casts with Unsafe.As on hot arithmetic paths by @​lahma in #​2673
• Fix Proxy construct trap receiving Array-constructor-mangled arguments by @​lahma in #​2670
• Amortize observation-only constraint checks and keep tight loops armed under timeouts by @​lahma in #​2672
• Refactor Proxy trap dispatch into a shared skeleton with lazy argument construction by @​lahma in #​2674
• Pool Proxy trap argument arrays by @​lahma in #​2675
• Slim allocations in Proxy ownKeys trap validation by @​lahma in #​2676
• Give every Proxy invariant violation a descriptive TypeError message by @​lahma in #​2677
• Add ProxyHandler for implementing Proxy traps in .NET code by @​lahma in #​2678
• Guard default RevocableProxy instances with a clear exception by @​lahma in #​2679
• Add CLR ProxyHandler lanes to ProxyBenchmark by @​lahma in #​2680
• Harden ObjectWrapper iterator helpers against foreign and revoked receivers by @​lahma in #​2681
• Let branchy constructors with static this-stores shape from instance three by @​lahma in #​2685
• Prefer .NET Regex for quantified groups without capture or lookaround hazards by @​lahma in #​2682
• Skip covariant store checks when populating exact JsValue arrays by @​lahma in #​2683
• Enforce custom regex-engine timeout via an inline deadline instead of a thread-pool timer by @​lahma in #​2686
• Make per-call nested function instantiation allocation-free by @​lahma in #​2684
• CI: cross-OS Test262 suite cache + action/tool version bumps by @​lahma in #​2687
• Extend the tight-loop lane to while and do-while statements by @​lahma in #​2688
• Restructure identifier slot-cache hot paths as hop-0-first by @​lahma in #​2689
• Adaptively upgrade reused .NET regex adaptations to RegexOptions.Compiled by @​lahma in #​2690
• Update dependencies to latest version by @​lahma in #​2692
• Update Test262 suite to f2d1435 and drop now-fixed exclusion by @​lahma in #​2693
• Fix nullable non-capturing quantified regex groups mis-routed to .NET Regex by @​lahma in #​2694
• Keep the memory limit exact instead of amortizing it in tight loops by @​lahma in #​2695
• Make Proxy trap dispatch atomic against mid-dispatch revoke; guard ToObject() by @​lahma in #​2696
• Observe cancellation during the top-level-await event-loop drain by @​lahma in #​2697
• Materialize arguments escaping a short-circuiting logical compound assignment by @​lahma in #​2698
• Fix custom regex engine dropping iterations for a multi-atom quantified group by @​lahma in #​2699
• Skip per-element IteratorResult allocation in value-kind array for-of by @​lahma in #​2700
• Add value-producing slot fast path for identifier ++/-- expressions by @​lahma in #​2703
• Fuse x == null / x == undefined loose-equality guards by @​lahma in #​2702
• Compose &&/|| and ! through unboxed GetBooleanValue in boolean contexts by @​lahma in #​2701

Full Changelog: sebastienros/jint@v4.12.0...v4.13.0

v4.12.0

Jint 4.12.0 is a performance- and correctness-focused release. It completes the move to hidden-class shapes across the whole object model, extends the unboxed interpreter fast lanes to more operators and call shapes, and adds a layer of per-engine caching so re-executed scripts and re-created functions reuse their compiled metadata and environments. A pre-release review of everything since 4.11.0 also fixed several correctness regressions. No code changes are required to benefit.

Highlights

Object model — shapes everywhere. The hidden-class shape model now backs the built-in prototypes and constructors, TypedArrays, the global object, and Intl / Temporal (#​2580, #​2581, #​2582, #​2590, #​2595, #​2597). JSON.parse builds its result objects as shapes, so an array of like-shaped records costs one allocation per record instead of a property dictionary each (#​2634). Object literals inside generator/async frames and object spread {...src} adopt shapes too (#​2596, #​2648, #​2635), and a provably-simple constructor shapes its instances from the third construction (#​2636).

Interpreter fast lanes. New unboxed operand lanes for equality, bitwise, modulo-equality and sum-of-products expressions remove per-iteration boxing (#​2602, #​2604, #​2611, #​2628), and comparison operands are served from the validated global-descriptor cache (#​2603). Expression-only and if/else for-loop bodies run through a tight per-iteration cycle with a member-bound loop test (i < arr.length) (#​2605, #​2617, #​2623), env-less leaf calls run against the captured environment directly (#​2627), and functions that cannot observe their this skip this-binding (#​2626).

Caching & reuse. Nested-scope global reads and writes are served from a validated global-binding cache (#​2584, #​2625); hoisted function and class definitions, and the top-level statement handler tree, are reused across re-evaluations on an engine (#​2613, #​2615, #​2649); and for-of / for-in reuse a fixed-slot per-iteration environment, skipping per-iteration TDZ re-init where it is provably safe (#​2586, #​2632).

Lower allocations. A coverage campaign added benchmarks for common patterns the suite did not exercise and then closed the hotspots they surfaced (#​2630): resolved await chains and engine-internal promise reactions (#​2639), for-in enumeration (#​2640), throw/catch (#​2641), primitive number/boolean/bigint methods (no wrapper object, #​2642), and tagged templates (#​2638) all allocate far less.

Correctness. Fixes for sticky + global [Symbol.match] returning wrong results (#​2600), an unlabeled break escaping a labeled switch (#​2607), -0 in integer multiplication (#​2620), and raw property writes on shaped hosts (#​2591, #​2601). A pre-release review (#​2651) additionally fixed for-in re-enumerating a shadowed key (a mid-loop delete and a pooled-iterator reuse case), mapped-arguments writes being lost after the call returns (and duplicate-parameter mapping now follows the spec), and hardened the object-literal and built-in-shape paths.

Across the managed JavaScript engines for .NET, Jint 4.12.0 is the fastest engine on 17 of the 21 comparison scripts — and the fastest interpreter on all 21 — leading by up to ~5.4× over the next-fastest engine while allocating 2×–63× less memory than the closest competitor. See the engine comparison benchmarks for the full table.

What's Changed

• Built-in shapes for prototypes and constructors: composable storage, accessors, aliases by @​lahma in #​2580
• Shape Number/%TypedArray% constructors and %TypedArray%.prototype; add [JsInstanceSlot] by @​lahma in #​2581
• Shape TypedArray constructors; modernize element codecs with BinaryPrimitives by @​lahma in #​2582
• Trim per-iteration block ceremony; slot lane for lexical declaration initialization by @​lahma in #​2583
• Serve nested-scope global reads and writes from the global-binding cache by @​lahma in #​2584
• Probe own-property existence/enumerability without materializing descriptors by @​lahma in #​2585
• Keep builtin-shape deopt lazy: unmaterialized function slots stay deferred by @​lahma in #​2588
• Serve arguments reads virtually; defer property materialization by @​lahma in #​2589
• Reuse a fixed-slot per-iteration environment in for-of/for-in by @​lahma in #​2586
• Bump the analyzers group with 3 updates by @​dependabot[bot] in #​2575
• BuiltinShape Factory slots: shape-path intrinsic references and throwers; flip Function.prototype by @​lahma in #​2590
• Fix raw SetProperty on builtin-shaped hosts landing in an invisible dictionary by @​lahma in #​2591
• Build the yield argument handler once, not per evaluation by @​lahma in #​2593
• Allocation-free for-in key enumeration by @​lahma in #​2592
• Extend prepared-script engine-retention test to newer env cache shapes by @​lahma in #​2594
• Shape-backed object literals inside generator/async frames when values cannot suspend by @​lahma in #​2596
• Flip Intl, Temporal and %AsyncFromSyncIteratorPrototype% to builtin shapes by @​lahma in #​2597
• GlobalObject joins the builtin-shape system via hybrid shape+overflow storage by @​lahma in #​2595
• Refresh engine comparison benchmark results by @​lahma in #​2598
• Update Test262 suite to latest commit; drop issue-5066 slice exclusion by @​lahma in #​2599
• Fix sticky+global [Symbol.match] .NET fast path returning wrong results by @​lahma in #​2600
• Make raw SetProperty before lazy initialization survive Initialize by @​lahma in #​2601
• Add unboxed slot-number lane to equality operators by @​lahma in #​2602
• Run expression-only for-loop bodies through a tight per-iteration cycle by @​lahma in #​2605
• Serve comparison-lane operands from the validated global-descriptor cache by @​lahma in #​2603
• Add dense-array append fast path for computed-index writes by @​lahma in #​2608
• Mark dead completion values at script/eval top level by @​lahma in #​2606
• Fused modulo-equality lane; admit const bindings to comparison-lane reads by @​lahma in #​2604
• Construct new Date() from clock ticks without intermediate conversions by @​lahma in #​2609
• Fix unlabeled break escaping a labeled switch statement by @​svenrog in #​2607
• Flatten eligible loop-body lexicals into the pooled loop environment by @​lahma in #​2610
• Evaluate sum-of-products assignments on raw doubles, boxing once by @​lahma in #​2611
• Refresh engine comparison benchmark results by @​lahma in #​2612
• Reuse hoisted function definitions across re-evaluations on an engine by @​lahma in #​2613
• Reuse class member definitions across class re-evaluations by @​lahma in #​2615
• Add decorator hook for CLR interop resolution errors by @​lahma in #​2614
• Fix ForBencmark class name typo by @​lahma in #​2618
• Re-resolve slot locations when a shared handler tree changes function instance by @​lahma in #​2616
• Member-bound loop test lane for i < arr.length / i < s.length by @​lahma in #​2617
• Add [JsSymbolAlias] for symbol-keyed function-identity aliases by @​lahma in #​2619
• Preserve -0 in integer multiplication fast paths by @​lahma in #​2620
• Refresh engine comparison benchmark results by @​lahma in #​2621
• Reduce per-call ceremony: thread FDI state, collapse suspendable probes by @​lahma in #​2622
• Extend for-loop tight-body lane to if/else chains and variable declarations by @​lahma in #​2623
• Add call-site constructor cache with zero-arg leaf fast path for new Date() by @​lahma in #​2624
• Memoize nested-scope global reads behind chain identity and an injection epoch by @​lahma in #​2625
• Skip OrdinaryCallBindThis for functions that cannot observe their this-binding by @​lahma in #​2626
• Run env-less leaf calls against the captured environment directly by @​lahma in #​2627
• Add unboxed operand lane for bitwise operators over identifiers by @​lahma in #​2628
• Refresh engine comparison benchmark results by @​lahma in #​2629
• Add benchmark coverage for common JS patterns missing from the suite by @​lahma in #​2630
• Migrate remaining symbol-alias tails to [JsSymbolAlias] by @​lahma in #​2631
• Source-generate function capture fields (CaptureField on [JsFunction]/[JsSymbolFunction]) by @​lahma in #​2633
• Skip per-iteration TDZ re-init for loop bodies proven init-before-use by @​lahma in #​2632
• Build JSON.parse objects as hidden-class shapes; serialize shaped objects via slot walk by @​lahma in #​2634
• Return the tag reference to the pool; fix tagged-template this-binding by @​lahma in #​2638
• Spread string primitives in object literals via ToObject per CopyDataProperties by @​lahma in #​2637
• Resolve number/boolean/bigint primitive methods without allocating a wrapper by @​lahma in #​2642
• Allocate no function objects for engine-internal promise reactions and resolving functions by @​lahma in #​2639
• Cut for-in allocation: memoized key strings, pooled loop-var reference and iterator by @​lahma in #​2640
• Reduce error allocation: lazy stack, virtual message slot, pooled catch env by @​lahma in #​2641
• Seed spread/rest/fromEntries/assign targets as shape-building objects by @​lahma in #​2635
• Shape statically-clean constructor instances from the third construction by @​lahma in #​2636
• Refresh engine comparison benchmark results by @​lahma in #​2646
• Bump NodaTime from 3.3.2 to 3.3.3 by @​dependabot[bot] in #​2645
• Bump the analyzers group with 1 update by @​dependabot[bot] in #​2643
• Bump Verify.NUnit to 31.24.0 and force LF line endings for snapshot files by @​lahma in #​2647
• Adopt the source shape when spreading a shaped object by @​lahma in #​2648
• Cache the top-level statement list per engine for re-executed scripts by @​lahma in #​2649
• Update Test262 suite to d1d583d by @​lahma in #​2650
• 4.12.0 release prep: correctness fixes from pre-release review + benchmark refresh by @​lahma in #​2651

Full Changelog: sebastienros/jint@v4.11.0...v4.12.0

v4.11.0

Jint 4.11.0 is a performance-focused release. It completes the move to a hidden-class shape model for the object system and adds a family of unboxed interpreter fast lanes, so the most common patterns — object and array construction, property access, tight numeric loops, and eval — do less work and allocate far less memory, with no change to behavior.

Highlights

• Object model. Object literals, hot constructor instances, and the built-in prototypes now use hidden-class shapes, and small objects store their properties inline in a single allocation (#​2548, #​2552, #​2553, #​2554, #​2555, #​2556, #​2557, #​2559). Property reads and writes are served by inline caches (#​2546, #​2558).
• Interpreter fast lanes. Relational tests and plain/compound assignments against slot-stored numbers now run unboxed, removing per-iteration boxing from loops (#​2550, #​2566, #​2574, #​2577, #​2578). Strict eval runs in slot-backed environments (#​2565), direct-recursive calls pool their environments (#​2549), and Function-constructor instances reuse a definition-level environment (#​2579).
• Lower memory. Function.prototype.toString source-text retention is now opt-in (#​2562), and the changes above cut allocations across the board — direct recursion, for example, allocates up to ~99% less.
• Correctness. Fixes for async parameter binding after await (#​2567), Map iteration during mutation (#​2570), and ShadowRealm evaluation of super / new.target (#​2573).

Across the managed JavaScript engines for .NET, Jint 4.11.0 is the fastest on most object, string and regex workloads — 1.7–5× over the next-fastest engine — while allocating 2–63× less memory than the closest competitor. See the engine comparison benchmarks for the full table.

[!WARNING]
Function.prototype.toString() no longer returns source text by default. To cut memory use (#​2560), the engine no longer retains each parsed function's source string, so toString() now returns a function name() { [native code] } placeholder instead of the original source. If your scripts — or a library you host — depend on toString() returning real source, re-enable it with new Engine(options => options.RetainFunctionSourceText()) (equivalently Options.RetainFunctionSourceText = true, or the matching RetainFunctionSourceText flag on ScriptParsingOptions / ModuleParsingOptions and prepared scripts).

Performance caveat: turning it back on restores the previous memory behavior — every parsed function pins its full source string, so caching many or large prepared scripts can retain hundreds of MB of duplicated source (the retention that #​2560 was filed to fix). Enable it only when you actually need the source text.

What's Changed

• Add write-side inline cache for property assignment (obj.prop = value) by @​lahma in #​2546
• Zero-copy SlicedString search (indexOf/startsWith/endsWith/includes) by @​lahma in #​2547
• Pool environments for direct-recursive functions (fib(30): -99.75% allocation) by @​lahma in #​2549
• Unboxed fast path for plain numeric assignment (s = a op b) by @​lahma in #​2550
• Build small object literals in O(1) with cached keys, no extra allocation by @​lahma in #​2548
• Bump the analyzers group with 1 update by @​dependabot[bot] in #​2551
• Hidden-class shapes for object literals (−50/72% literal allocation) by [@&Update dorny/test-reporter action to v3 #8

✂ Note

PR body was truncated to here.

---

Configuration

📅 Schedule: (UTC)

• Branch creation
  • At any time (no schedule defined)
• Automerge
  • At any time (no schedule defined)

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

---

• If you want to rebase/retry this PR, check this box

---

This PR was generated by Mend Renovate. View the repository job log.