Repository navigation
chore(deps): update dependency octane to ^0.3.0 - #8517
Merged
Merged
Conversation
chenjiahan
approved these changes
Sep 21, 2026
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
This PR contains the following updates:
^0.2.10→^0.3.0Release Notes
octanejs/octane (octane)
v0.3.0Compare Source
Minor Changes
a6d7f49: Remove the legacyContext.Provideralias from client, server, and native contexts. Provide values with<Context value={value}>orcreateElement(Context, { value }, children)instead. The compiler rejects statically recognized legacy Provider access with migration guidance, and Octane bindings now use contexts directly. Binding peer ranges accept Octane 0.3 alongside their previously supported runtime lines.Patch Changes
debd7df: Specialize nonescaping function-local const roots in production JavaScript and TypeScript entries when every render uses an imported compiled void component. Keep writable component exports on the generic rendering path so authored replacements can return ordinary renderable values.873f4d2: Move native signal transition coordination behind the signals model capability so ordinary client applications no longer retain its preparation, retry, and publication policy. Preserve signals imported after an async Action awaits and atomic updates to consumers that receive signal handles through props.The model entry now retains this coordinator, increasing standalone signals and signal-using SSR bundle sizes.
68a6690: Preserve explicit signal ownership when native event handlers are installed by components without signal bindings, including handlers adopted during hydration. Refresh ownership when bare or compiler-lifted handlers publish changed callbacks or captures, while keeping the committed authority if a suspended update is abandoned. Keep already queued native callbacks under their original authority when an earlier listener publishes a replacement. Avoid extra publication calls during ordinary mounting and updates that keep the same scope authority, and record rollback without per-handler undo closures.c32e76b: Keep fixed scalar inline styles on their ordinary writers inside modules that use signals, while preserving reactive reads and native bindings for handles, spreads and accessors.14fd908: Allow text and attribute signal bindings to omit unused form-control writer andhydration adoption policies from production bundles. Keep the compiler helper
ABI, scalar caches, live subscriptions, and native control behavior unchanged.
893cc83: Specialize production function-local roots created or hydrated with stable same-module compiled void components when their complete lifetime uses only proven void bodies. Preserve generic roots for escaping roots, writable component bindings, unknown initial or later render targets, development and alternate renderer modes.v0.2.16Compare Source
Patch Changes
2049fa7: Keep native-only DOM presentation initialization separate from control and grouped-projection capabilities, so initializer-only compiled views do not retain unrelated host-operation helpers. Preserve initialization order, early edits, and older mount/adoption capability overrides.80d5fb6: Preserve scoped CSS selectors in split Hydrate children when production builds compile mutable parser ASTs. Deferred and independent activation now inject the same scoped stylesheet that matches the server DOM.3814f71: Preserve control-flow guards when inferring hook dependencies. Property reads behind a condition, an early return, or exception handling inspect own data values without invoking getters during render. Accessors and inherited properties track their receiver, while stable own fields and callbacks retain precise dependencies across fresh props and store snapshots. Optional receivers and guarded getters therefore retain their authored behavior.b519670: Resolve independent Hydrate captures by their lexical binding and reject aliases or wrappers of parent-owned hook state. Unrelated same-name locals no longer reject valid standalone data or hide invalid captures; nested independent extraction also plans module moves before manifests are available.ac02371: Avoid activating document-wide signal ownership for opaque scalar bindings and preserve proven primitive values through extracted JSX fragments. Register model Action frames from the signal graph so applications without signals can omit that implementation, while retaining late-loaded signals and atomic native presentation.2049fa7: ExposegetLeadingHydrationListRangefromoctane/hydrationto resolve an ownedSSR host's leading list through canonical wrapper ranges while preserving its
binding receipt and rejecting incomplete or malformed boundaries.
2049fa7: Diagnose reservedon*attributes in native binding views as unsupported attributes rather than event handlers. Keep native camelCase event recognition, explicit unbound ownership and inline-event attribute safeguards unchanged.2049fa7: Allow scalar native-parent hydration handoffs to retain independently owneddata-*,aria-*, andtabIndexbindings alongside class and style. Keep opaque children and their controls outside the parent lease, preserve native attribute removal semantics, and retain the existing collision, cancellation, and host identity checks. Keep explicitly unbound lowercase native event handlers under normal renderer ownership.9b22cff: Keep explicit keys distinct from implicit positions and nested array paths in host-only children, preserving the correct input nodes and typed values when keyed children reorder.02e0946: Activate independent Hydrate widgets using load() when their server sidecars are registered, and resume pending activation after a paused document becomes active again. Preserve the existing server DOM when independent widgets activate beneath parents that return JSX. Preserve the enclosing component's parallel use() warm plan when compiling nested templates.358b5d4: Fix automatically inferred async creation dependencies to respect lexical scope and erased TypeScript syntax. Preserve safe evaluation oftypeofguards and their value reads for absent globals, and refresh requests when callback parameter defaults reference changed outer values.c988ad1: Preserve native Undo/Redo grouping when a writable textarea signal echoes anaccepted native edit. Different programmatic values still update the textarea's
reset baseline, and scalar or read-only values keep controlled-value mirroring.
v0.2.15Compare Source
Patch Changes
42a07b4: Preserve accepted scalar DOM-binding updates when hydrating older server-rendered state.Compile scalar text leaves and mixed structural/scalar projections independently,
retain the current bound text, attributes, classes, and style properties during
hydration, and release their ownership when the binding is disposed or aborted.
Unrelated DOM mutations still receive normal hydration diagnostics and repair.
v0.2.14Compare Source
Patch Changes
44bd89f: Allow a compiler-proven native host to transfer its class and known-provider style bindings to normal hydration while its opaque children retain their own rendering and control ownership. Keep the early layout active during suspension or refusal, preserve the current presentation during accepted transfer, and validate the host and its source before publishing the successor.Keep the early scalar adapter's handoff symbol in the existing control registry so accessing the capability does not make cold renderer and event-lease helpers an eager dependency.
Retry skipped native effects through the existing native-read scheduler when their surviving render has already completed, without weakening stale-publication checks or reviving disposed owners. Preserve suspended-island ownership and held-transition priority.
Traverse lightweight DOM-context ancestors without treating them as hook-bearing blocks when locating a preserved hydration owner, so native effect retries remain safe while another island is suspended.
de270e3: Support explicit handoff of a standalone textarea signal value alongside an adopted native presentation. Hydration preserves live input and selection, transfers control ownership only at accepted publication, and keeps early bindings active when takeover is declined or suspended. Known-provider unbound style spreads retain direct compiled property bindings.Keep early ownership intact when preparing a successor subscription fails, and avoid masking interrupted mounts with a secondary ref-cleanup error.
Release all prepared value successors when a later control invalidates presentation publication, preserving the original error and preventing stale input or model writers from being reclaimed by that root.
Reject competing presentation bindings for fields supplied by an unbound known-provider spread, including
class/classNamealiases.Type-check explicit scalar text intent against a signal handle's value in DOM templates, preserving direct bindings without application-side reads or unsafe casts.
Transfer direct scalar text signals through presentation hydration using the existing prepared binding lifecycle, including initially empty text ranges and live updates after acceptance.
44bd89f: Mark streamed signal selection and result scripts as renderer-owned transport so hydration can adopt the server HTML without reporting leftover protocol scripts as mismatched component output.v0.2.13Compare Source
Patch Changes
5ead1ff: AllowadoptBindings(element, View, source)to resolve an eligible composite view that returns another view through exact adjacent compiler-owned wrappers. Preserve native node identity and existing binding lifetimes while rejecting ambiguous, mismatched, or sibling-containing ranges.5ead1ff: Add owner-bound signal declarations, async derivations and keyed streams, direct native signal bindings, and independent hydration infrastructure. Add request-local server-call context, bounded streamed RPC, and explicitly batched independent reads. Preserve operation identity and cancellation boundaries across navigation and uncertain acknowledgements.Allow a later widget activation to retry a failed framework-loaded stylesheet
without discarding queued interactions or revealing the widget before CSS loads.
Support renderer-free global signal and streamed-state activation for hosts that
retain server-owned HTML. Adopt initial document seeds before behavior reads,
preserve early edits, bind native control properties without reconciliation, and
let envelope owners emit the early capture script before interactive markup
without duplicating it in rendered fragments.
Catalog the new core runtime diagnostics while preserving their error classes,
and verify the published streaming bootstrap subpath and inline script export.
Keep individual and batched server calls on the page's origin when an authored
base element points to another origin.
Keep reusable DOM, CSS, and component prop types scalar while allowing direct
signal bindings at native JSX sites, preserving existing binding consumers.
Use scalar public props for Zag's state-machine normalization results and
to-print's imperative iframe options.
5ead1ff: Specialize renderer-free child bindings to explicit caller prop shapes, allowing a proven destructured rest parameter to forward supported native properties. Preserve ordered shape identity through imported binding requests and share normal SSR annotation allocation without restricting the ordinary component API. Unknown spreads and unsupported native ownership conflicts still fail clearly.Allow proven conditional, child-view, slot, and primitive-text regions to transfer from early bindings to normal hydration without replacing their native nodes. Keep early interactions active through suspended or discarded attempts, validate the current presentation before publication, and retain explicit refusal for unsupported regions and writers.
5ead1ff: Support flat destructured props, aliases, primitive literal defaults, and rest bindings in renderer-free authored views. Prepare parameter bindings once per snapshot so projection, event, and ref reads preserve JavaScript destructuring semantics. Keep unsupported patterns and arbitrary native spreads explicit errors.5ead1ff: Allow renderer-free authored views to use canonical signal-handle checks, bounded native value projections, and named native event and ref callbacks. Keep callback bodies deferred until their native lifecycle, preserve committed captures and stable ref attachment, and allow explicit ref-prop forwarding through child views.5ead1ff: Extend compiler-owned native presentation to authored text, conditional content,keyed lists, pure child views, and explicit mounting without loading the renderer.
Preserve SSR identity, early native controls, focus and composition, and native
ref lifetimes. Add fixed-shape imported attribute factory contracts so style
adapters can preserve one ordered merge without repeated spread evaluation.
Connect direct signal-valued native channels to the existing signal graph,
without rerunning unrelated presentation projections.
5ead1ff: Move explicit declaration keys to trailing options:signal$(initial, { key }),derived$(compute, { key }), andquery$(select, load, { key }). This replaces their positional authored-key overloads; update existing callers when adopting this beta API change. Compiler-generated identities and explicitcreateScopemethods retain their existing ownership behavior.5ead1ff: Keep transition orchestration out of early signal and control module dependencies so split-chunk builds can defer it with the renderer. Native input and transition behavior are unchanged.5ead1ff: Allow explicitly adopted, compiler-proven fixed native views to transfer their early DOM bindings tohydrateRootthroughbindingLeases. Keep early presentation and native commands active while hydration is pending, publish current values before refs, and retire old ownership without replaying already handled commands. Native updates beneath a suspended hydration boundary now retain that boundary's pending capture instead of publishing a child independently.The early entry remains renderer-free; normal hydration still requires explicitly loading the renderer. Structural regions, dynamic text, writable controls, and unsupported writers are not eligible for this optional handoff.
Retire displaced early bindings only after staged DOM publication, suppress refs from hydration attempts that never commit, and support fixed native views using fresh array/object class values. Hydration-lease errors use the standard production error-code catalog.
5ead1ff: Preserve event-time command payloads through an optional synchronous behavior capture hook, and support authoritative revision comparison for optimistic action receipts so older successful responses settle without replacing newer authority.5ead1ff: Reconcile explicitly undefined native attributes when hydrating existing server markup. Direct attributes and native prop spreads now remove stale SSR values on the first client render instead of treating an empty client cache as an unchanged value. Preserve the adopted node and unrelated server attributes.5ead1ff: Keep early whole-style bindings from sharing a module with renderer-only attribute and namespace tables. CSS serialization, units, caches, and existing helper exports remain unchanged.5ead1ff: Allow trustedknownAttributeSpreadscontracts to opt into signal-aware style objects withstyle: 'object'. Renderer-free bindings reuse the existing style capability, while contracts without this option retain CSS-text behavior.5ead1ff: Keep query implementation out of signal-only owner bundles and remove the legacyscope.asyncSignal$method. Explicit-owner callers now importcreateResource(scope, key, describe); nativequery$declarations are unchanged.createScoperemains optional, and synchronous signals, draft edit receipts,request isolation, streaming ownership and historical adoption retain their contracts.
Discard compiler-proven unused signal declarations without dropping initializer
effects or diagnostics, and reduce repeated plain-data conversions when accepting
SSR signal seeds. No runtime capability loader or extra initialization phase is added.
Add
bootstrapStreamedSignalResultsfor hosts that accept streamed signal resultswhile owning their HTML placement. It shares the full receiver's authority,
bounded delivery and lifecycle handling without retaining DOM placement code.
The existing
bootstrapStreamedSignalHydrationand region-registration API remainavailable unchanged.
5ead1ff: Reduce renderer-free signal startup dependencies by separating native-control capture from optional island activation and keeping server stream observation mirrors out of the browser request engine. Preserve early input, stream cancellation, and per-consumer backpressure without changing author-facing APIs.5ead1ff: Preserve grouped nativesxprojections through nested local components in renderer-free bindings, including reactive updates, keyed rows, and cleanup.5ead1ff: Add opt-in nativesxauthoring with signal-aware StyleX arguments. Normal rendering and renderer-free bindings share a native projection that prepares class, style, and metadata together, preserves SSR adoption and source ownership, and skips unchanged DOM writes. StyleX remains responsible for style composition, units, and extracted CSS.Expose a shared StyleX compiler contract and a TSRX type-check provider so supported native
sxexpressions can sample signal arguments without widening ordinary StyleX function parameters or component props. Forward native attribute contracts through the application Vite plugin.5ead1ff: Open failed server signal result channels before sending their sanitized error, preserving query error adoption when a promise rejects or an iterator cannot be constructed.5ead1ff: Select keyed-list support only for renderer-free binding programs that can use it, including inactive branches, imported children, and caller-owned slots. Preserve older compiled descriptors through compatible runtime entry points.5ead1ff: Start compiler-proven independentquery$andderived$reads together in complete static native JSX output, as well as adjacent local declarations. Preserve lazy declarations, branch reachability, original error and suspension boundaries, and ordered handling of opaque values. Unknown receivers, mixed text/renderable holes, dynamic host behavior, and resource-loading elements remain conservative boundaries.5ead1ff: Start compiler-proven independent query and asynchronous derivation reads together while retaining strict read order, actual data dependencies, cancellation, and lazy conditional work. This does not add transactional signal publication or delay native input updates.Avoid speculative signal owners and eagerly serialized invocation paths in ordinary rendering. Preserve late signal activation and retired event ownership, and align keyed component identities between server rendering and hydration.
Retain pending component queries across rendering retries, releasing obsolete work on replacement, cancellation, and unmount. Support checked dynamic projection functions in immutable imported-factory configurations and imported string-token style keys in renderer-free views, preserving ordered attribute merges and property ownership.
Release native control leases when their exact signal owner retires, independent of application page-cleanup order. Initial dead-owner reads and genuine computation errors still fail; ordinary signal subscribers retain their final invalidation.
5ead1ff: Select host-spread hydration preparation only for components that use it, allowing simpler early-binding handoff components to omit generic spread and form machinery. Preserve the same adoption proofs, native ownership, and normal renderer behavior.5ead1ff: Preserve streamed query delivery when a query waits for another query beforestarting. Dependent streams remain attached to the original SSR response and
hydration adopts their delivered results without starting duplicate requests.
Preserve pending dependency snapshots in implicit derived signals and carry
dependency refresh and stream-completion activity through async derivations.
Reuse the empty SSR list-key context between components while preserving copied
keyed paths and request-local signal identity.
5ead1ff: Stage native signal writes made in transitions until their affected renderer and renderer-free presentations are ready. Keep committed values and public notifications unchanged while a query or derived result is pending, preserve urgent edits, and transfer accepted producer and binding subscriptions without restarting them. Reuse the existing transition journals and optional visibility driver for pending cues, timeout fallbacks, and cleanup.5ead1ff: Complete renderer-free authored controls and whole/spread styles using the existing signal ownership and native style protocols. Preserve sampled one-way values, early edits, keyed controls, radio input ordering, CSS declaration order, and cleanup. Keep binding-only activation modules free of the renderer, accept the BindingSource callback contract, and support conservative chained string projections.Preserve unchanged scalar text during native rendering and ViewTransitions by retaining its compiler-owned raw-value cache. This keeps text selection intact and avoids activating unchanged nested transition scopes without hiding signal pending/error recovery.
5ead1ff: Reuse the resolved server signal owner when invoking a component, avoiding a duplicate instance lookup while preserving nested request ownership.5ead1ff: Let renderer-free structural bindings omit control, grouped-style/class, and native-initialization orchestration when their compiled view cannot use it. Preserve existing behavior for views that need these features and for older compiled descriptors.5ead1ff: Select the compiled DOM binding adopter directly and share identical local child plans, reducing renderer-free startup code without changing view authoring or ownership.5ead1ff: Share eligible compiled StyleX recipe constants between normal components and renderer-free binding artifacts in production browser builds. Preserve local StyleX optimization, style precedence, extracted CSS, and authored source maps. Expose the build-time sharing plugin for custom compiler adapters; leave development, server, and unsupported definitions on their existing paths.5ead1ff: Export signal-handle predicates directly from their lightweight protocol module so a capability check alone does not retain signal-owner initialization or the signal engine. Predicate behavior and identity are unchanged.5ead1ff: Derive direct signal binding and writable-control identities from authored source positions rather than generated component helper names. This fixes server/client identity mismatches for controls nested in conditional fragments, loops, and switch branches. Rebuild and deploy matching server and client output together because the compiler site-identity version changes.5ead1ff: Preserve global signal SSR identities and activation metadata in plain modules that also use memo hooks when production inline memo optimization is enabled.5ead1ff: Add compiler-backed adoption of fixed server-rendered DOM views throughadoptBindingsfromoctane/behavior. Opted-in views synchronously project an owned snapshot onto existing native elements without loading the renderer, replacing nodes, or taking over application event handlers. Unsupported structural authoring fails explicitly.5ead1ff: Let compiler-proven scalar signal derivations omit general async computationmachinery. Avoid repeated owner resolution on cached signal reads while preserving
request isolation, historical reads, and retirement checks.
v0.2.12Compare Source
Patch Changes
ede01de: Accept native signal handles in DOM styles, including individual CSS properties and whole style values. Direct template styles update without rerunning component setup, and preserve signal cleanup, Suspense, server rendering, and hydration. ExportSignalCSSPropertiesfor signal-aware style objects while keepingCSSPropertiescompatible with ordinary CSS consumers.Keep binding CSS compatibility aliases pointed at plain
CSSPropertieswhen their layout helpers consume ordinary CSS values.Expose the signal style regression benchmark through the MCP benchmark tool.
248af4e: Avoid redundant hydration lookups when updating existing conditional and switch branches.cece195: Reuse unchanged populated SSR replay snapshots and pending streaming settlementrecorders across retry waves. Preserve metadata rollback, promise identity,
cancellation, and request cleanup. Add the SSR replay and streaming benchmark
suite to repository automation.
03dacb7: Stamp each block's context-dependency maps with the context epoch they were recorded or verified at, so memo and implicit bailouts skip per-entry version scans whenever no provider has committed a change; stale restamps and pending propagations still force the scans, preserving refresh behavior.7d4dc4f: Reduce universal renderer prop-shape churn, materialization allocations, repeated feature scans, and unnecessary compact-list traversal while preserving keyed identity, transactional callbacks, and transport contracts. Expose the universal measurement suites through MCP.277c10c: Compile fixed trailing style properties after leading object spreads into guarded per-property updates. Preserve spread evaluation, overrides, removals, and hydration, with complete object diffing when a spread preinserts a trailing key.1198cdc: Skip the per-rowupdateSurvivorcall in keyed reconciliation when a compiler-pure list row is provably unchanged — same item reference, same body, same position — so a stable keyed update no longer pays the survivor-update machinery for every no-op row. Moved, added, removed, index-shifted, non-pure, and de-opt rows still take the full survivor path, preserving render, journal, and rollback behavior.Preserve
import.metaandnew.targetsyntax when collecting dependencies for memoizeduse()arguments and server-rendered component props.Reduce repeated runtime work on the client and server. Empty descriptor hosts skip
child-list scratch arrays, passive-effect batches reuse their scheduling callback,
and identical server styles reuse their records and replay snapshots.
Expose the runtime-style-dedup, empty-host-children, and passive-scheduling
benchmark suites through the MCP benchmark tool.
fe1b2b7: Avoid rebuilding complete style objects on repeated spread-key collisions. Preserve inherited setters, read-only properties, and transitions back to per-property updates.733c98d: Key SSR scoped child-segment and occurrence counters by the frame-relative scope suffix instead of the fullASYNC_SCOPEpath. Every component child re-scanned the shared path prefix during counter lookup, so SSR render cost grew with tree depth — measured ~53% faster on an arm-heavy SSR workload and ~16% faster on a plain nested-component tree, with byte-identical rendered output. Async identity, arm segment numbering,use()occurrence keys, replay, streaming, and hydration seed behavior are unchanged.13604b9: Avoid temporary boundary-collection copies during streaming SSR completion,error and abort scans, and reuse immutable CSS/head snapshots for completed
boundaries. Extend the benchmark catalog with the final SSR and client coverage
investigations from the runtime performance audit.
527358c: Complete the remaining Strong compiler checks for fetch-driven effects, effect chains, prop-derived initial state, explicit and null dependencies, manual memo hooks, JSX list mapping, index keys, suppression props, trusted HTML, and compatibility imports. Preserve equivalent dependency arrays as hints and report them without failing strict CLI analysis. Add compiler-owned declaration caching for Strong authoring, thetrustHTML/TrustedHTMLAPI, and nominal Strong JSX types while preserving compatibility modules.Strong opt-in intentionally changes generated code for eligible hook-input declarations: their identities are cached in development and production until inferred inputs change. It also normalizes proven built-in hook aliases and infers dependencies for unshadowed
undefinedplaceholders. This applies to both the directive and the globalstrong: trueoption. Ordinary callbacks and mutable values retain their authored evaluation and lifetime. The keyed@formigration applies to.tsrx; keyed JSX mapping remains supported in.tsx.CLI JSON reports include the hint count even when it is zero, and MDX diagnostic types represent errors, warnings, and hints.
The eager prop-state check covers both
useState(value)anduseReducer(reducer, value). A lazy state initializer or explicit third reducer initializer declares a deliberate initial capture. Subscription and timer callbacks keep their event-driven semantics and are excluded from effect-chain writes.bb11d0b: Upgrade to TSRX core 0.2 and the renamed native parser, @tsrx/oxc 0.13. Lazy destructuring (&{ ... }and&[ ... ]) is no longer accepted by the compiler or editor tooling. Use ordinary object and array destructuring instead.Support property-specific kebab-case CSS names in
CSSProperties, including signal-backed HTML and SVG styles. Preserve Octane's numeric length support:width: 400still means400px. Runtime style handling is unchanged.777cef3: Align ViewTransition with React 19.3: fix activation classes, type maps, authoredstyle restoration, mutation and layout detection, nested sharing, instance refs,
and callback cleanup at animation finish. Forward native transition types, keep
unanimated controls interactive, and wait for relevant resources and navigation.
Animate streamed Suspense reveals with coordinated hydration and client updates.
Prepare ViewTransition renders with staged DOM commits so snapshot activation uses the finished boundary props while preserving existing node identity and committed lifecycle visibility.
Keep ordinary DOM operations on an inline native receiver path to avoid per-node staging helper calls when no ViewTransition is active.
Skip inactive staging calls during effect and scope cleanup, including Activity and Suspense deactivation after a ViewTransition has completed.
Add opt-in
scope="element"boundaries with local names and pseudo-element handles,independent sibling and nested animations, coordinated streamed reveals, and
normal DOM commits when native element transitions are unavailable.
Expose the ViewTransition bundle and native-work benchmark through the MCP benchmark tools.
v0.2.11Compare Source
Patch Changes
fdb790a: Keep nested scoped JSX responsive to context changes, isolate hooks and memo caches across independently compiled render bodies, and invalidate stale output when lazy bodies change. Preserve component ownership across mixed compilation modes. Expose the production body-ownership benchmark through MCP.1bc1926: Resolve the renderer-region owner with a single lookup at the top of the block chain instead of a WeakMap read per ancestor on every provider-less context read, preserving context defaults and foreign-renderer routing.2789eab: Read descriptor list keys directly during reconciliation without creating a key callback for each list render, while preserving keyed identity and hydration behavior.Keep mapped component slots compatible when rendering switches between native array mapping and a custom map implementation, preserving hydrated inputs and component identity.
8e5ca22: Preserve accepted scoped descriptor children when Providers change host/component child shapes. Reuse known descriptor event names and reduce delegation arrays, child traversal, redundant persistent host writes, repeated form source resolution, and select option reads while preserving live DOM, event, and form-control behavior. Expose the descriptor-renderer benchmark suite through the MCP server.fa11c10: Reuse wrapper-path serialization for nested explicitly keyed children while preserving key identity, hydration, and custom key conversion behavior.ade5be8: Reduce compiler-generated handler, branch capture, and server rendering overhead while preserving event, branch, and SSR evaluation semantics.Expose the compiler-output benchmark suite through the MCP benchmark tool.
1e12db7: Reduce hook path resolution, optional-argument handling, state getter lookups, and warm-plan bookkeeping. Reuse external-store subscription dependencies when the subscriber is unchanged. Add deterministic Hooks performance diagnostics to the benchmark catalog.6284156: Reduce scheduler batch bookkeeping and skip ref sorting for sibling-only attachment queues, preserving update ordering, effect lifecycle checks, and render-loop limits. Expose deterministic scheduling benchmarks through the MCP benchmark catalog.239dab0: Invalidate cached output when a retained Context Provider switches compiled child bodies, so returning to an earlier body renders its current content while preserving mounted DOM and hook state.3c1cc55: Restore enumerable symbol values when a root render suspends and preserve keyedrow state when an urgent update shares a batch with a suspended removal. Reduce row
input and retirement bookkeeping, and reuse the live DOM value already read
when journaling descriptor text updates. Expose the root transaction benchmark
suite through the MCP server.
23b6a75: Speed up server rendering by picking the escape pre-scan by string length inescapeHtml: a stateless non-global regexp test for short strings, threeindexOfscans for long ones.The previous global regexp paid
lastIndexbookkeeping on every call; thelength split keeps the cheaper scan in each regime. ~20% faster median render
on the 500-card SSR benchmark with byte-identical output.
68d1ea1: Reduce per-node SSR bookkeeping cost in the emission hot path: frame-local scoped counters (per-arm child ordinals and per-siteuse()occurrences) now live in a flat pair list — comparing scope strings directly instead of hashing them into aMap— and promote to aMaponly past eight distinct keys.process.env.NODE_ENVis sampled once per synchronous render pass rather than read on every attribute/style emission check, with public entry points still reading it directly so out-of-pass calls never see a stale sample.68d1ea1: Reduce per-component SSR bookkeeping allocation: replay snapshots now share immutable empty collections instead of copying emptyMap/Set/array state, stream boundary ancestor/owner key lists reuse a shared empty, andHookPasshook/occurrence maps are allocated lazily on first stateful or native hook call. Component-heavy server renders allocate roughly half the bookkeeping garbage they did before, with identical streamed output and unchanged render-phase replay semantics.58da344: Keep compiler memo caches off scope slot arrays, stabilize internal hook, host,list, and render-capture records, and initialize memo and template caches without
sparse namespace entries. Preserve memo identity, staged hook values, keyed DOM
reuse, and commit-time cleanup behavior.
8a45222: Reduce DOM attribute, spread-prop, template mounting, metadata, and delegated-event work while preserving hydration, rollback, native event descriptors, and custom-element connection behavior.Expose the DOM attribute, template mount, and spread host benchmark suites through the MCP benchmark tool.
Configuration
📅 Schedule: (UTC)
* 0-3 * * 1)🚦 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.
This PR was generated by Mend Renovate. View the repository job log.