Skip to content

chore(deps): update dependency solid-js to v2 - #656

Merged
chenjiahan merged 1 commit into
mainfrom
renovate/solid-js-2.x
Nov 18, 2026
Merged

chenjiahan merged 1 commit into
mainfrom
renovate/solid-js-2.x

Conversation

@renovate

@renovate renovate Bot commented Nov 18, 2026

Copy link
Copy Markdown
Contributor

Note

This PR body was truncated due to platform limits.

This PR contains the following updates:

Package Change Age Confidence
solid-js (source) ^1.9.19 → ^2.0.0 age confidence

Release Notes

solidjs/solid (solid-js)

v2.0.0

Major Changes
  • c3e5e78: Async everywhere

  • 2645436: Update to R3 based signals

  • e855fcb: Fix dual runtime package type resolution for CommonJS consumers.

    Add CJS-specific declaration outputs for dual-runtime packages and stop exporting legacy dist/* entrypoints in favor of the supported public package surface.

  • 2a7c6a5: Move JSX type ownership from solid-js to renderer packages.

  • a4c833d: Update to new package layout, signals implementation, compiler

Minor Changes
  • f0c3692: Point-of-pain discovery for diagnostics: DEV.diagnostics.setConsoleFooter(fn) registers a footer printed once per diagnostic code after that code's first console report. solid-js registers a footer in dev pointing at its shipped repair skill (node_modules/solid-js/skills/reactivity-diagnostics/SKILL.md), so anyone — human or agent — hitting a diagnostic warning learns where the prescribed fix lives without prior knowledge of the skill system.

  • ce8e46b: SSR support for loadingValue / seedLoadingValue — the server flushes commit #​0 and the client hydrates with it. A loading-value memo (or seeded derived store) never suspends on the server: markup renders from the loading value (the boundary never trips), the landing streams to the client as data, and the hydrating node is born committed with the same loading value, so the claim walk matches the server markup by construction; the serialized landing then closes the window on both sides right after hydration. The first-value lock generalizes to commit #​0: HTML-visible reads stay at the loading value for the whole response (later renders in the same stream can't tear against already-flushed placeholder markup), and every landing after the placeholder flushed ships as data — including synchronous landings after a NotReady retry, the one exception to "sync results are never serialized". On the client, a settled serialized landing is handed to the async runtime as a thenable instead of unwrapping synchronously, so commit #​0 also serves through the claim walk when the response was fully loaded before hydration began. ssrSource: "client" sources flush the loading value too, matching the prev-serving hydration wrapper on the client.

  • ad7d1f5: Move pre-release tag from experimental to beta

  • 8d249c7: Patch-mode list driver: keyed <For> over a store array is offered to the
    runtime's row-ops driver (create/bind at op-apply, LIS moves, node removal —
    no mapArray, no per-row owners, no DOM-side reconcile). For carries $ll
    metadata on a lazy classic accessor so unaware renderers and declined lists
    (non-store subject, impure rows proven by a bind-time owner probe, fallback
    or index usage) fall through to today's mapArray path unchanged. Array
    identity swaps keep keyed semantics by raw-identity matching. Adds
    ownerIsBlank (signals) for the purity probe and driveList (web, rxcore
    seam) for the runtime.

  • 1b94264: Question-scoped pending model and the affects() primitive (supersedes the optimistic mask)

    isPending is re-derived from one rule: a read is pending iff a value change is in flight for it that has not yet revealed, or it carries a live affects() mark.

    • Same-question re-asks are silent. refresh(), polling, and confirm refetches whose tracked inputs are value-stable no longer read as pending — the fresh value reveals silently.
    • New questions pend monotonically. An input value change in flight pends every read under the source until its answer reveals, and nothing can silence it.
    • Optimistic writes are verdict-inert. An active override displays without decreeing settlement: it neither reads pending on its own slot (only a differing held correction re-opens the verdict) nor masks anything else. The store-wide optimistic mask (A21) and node mask (A20) are removed.
    • New affects(target, ...keys) primitive (re-exported from solid-js). Declares that in-flight work will change the targeted data: the named slots (a store record, specific record keys, or a source accessor) read pending from the declaration until the surrounding transaction settles or reverts. affects(x); refresh(x) is the declared-reload idiom.
  • 536dec5: Require a declared commit #​0 for ssrSource: "client" (#​2981). The server cannot run a client source, so the author must say what the pre-compute window renders: loadingValue on signal-family sources (createMemo, function-form createSignal/createOptimistic; an explicit loadingValue: undefined is a valid declaration — put the undefined in the type and branch on it), seedLoadingValue: true on store-family sources (createProjection, derived createStore/createOptimisticStore; the seed is what the window shows). Effects are exempt — nothing renders from them.

    Enforced at the type level (the bare "client" overloads are gone) and with a runtime error naming the fix — behind the dev flag on the client (zero production bytes; prod falls back to the previous gate behavior), always-on in the single-build server entry, where the implicit promotion would flush into markup. Portal's internal client-sourced memos now declare loadingValue: undefined ("server renders nothing" is their honest commit #​0).

  • 159d204: Add Reveal component SSR support with streaming fragment coordination, collapsed fallback mode, and nested composite slots

  • 75eebc2: feat: snapshot-based boundary-local hydration safety (Goal 4)

    Signal writes during hydration are now safe by construction. Each Loading boundary gets its own snapshot scope — computations created during hydration read snapshot values (matching server DOM) while writes update only the current value. After a boundary's sync hydration walk completes, its snapshot scope is released and stale computations rerun with current values.

    Key changes:

    • Add markTopLevelSnapshotScope/releaseSnapshotScope plumbing to all hydrated primitives
    • Extract createBoundaryTrigger() helper for internal trigger signals excluded from snapshot capture
    • Add resumeBoundaryHydration() with isDisposed guard, per-boundary scope management, and flush
    • Add onCleanup for cleanupFragment to handle orphaned streaming content on navigation
    • Remove deferHydration option (no longer needed with snapshots)
    • Remove isHydrating/onHydrationEnd from public API (snapshots make hydration timing transparent)
    • Update @​solidjs/signals to ^0.10.7, dom-expressions to 0.41.0-next.6
  • 75eebc2: feat(ssr): implement ssrSource, async iterable streaming, and client hydration (Goal 2d)

    Adds the ssrSource option (4 modes: "server", "hybrid", "initial", "client") controlling how computations serialize and hydrate. Server-side async iterable streaming via processResult tap wrapper with patch-based projection serialization. Client-side async iterable hydration with synchronous first-value consumption from seroval and scheduleIteratorConsumption for remaining values. Includes isHydrating/onHydrationEnd lifecycle APIs, deferHydration option, and subFetch updates for generator dependency capture.

Patch Changes
  • 4b4c2cb: A server <Loading> whose creating pass is disposed (an <Errored> retry re-rendering its children) now stops retrying instead of looping until "did not converge". A boundary re-created under the same fragment id owns the fragment, so the abandoned instance never settles it with blank markup; with no successor, the abandoned instance releases its fragment so the response still ends.

  • 7b8fd28: until's signal option types as the global AbortSignal when the DOM lib or @types/node declares one, and as the minimal abort surface until uses otherwise, so the published declarations type-check with neither lib under skipLibCheck: false (previously TS2304).

  • a85c889: New package @solidjs/diagnostics: agent-consumable diagnostics harness. captureArtifact() runs a scenario with the dev-mode diagnostic and attribution channels open and folds both into a serializable artifact; assertion helpers (expectNoDiagnostics, expectDiagnostic, expectRerunBudget, expectNoWaste) and scenario budgets (assertBudget, checked-in budget files) gate correctness, update granularity, and wasted recomputes; Vitest matchers via @solidjs/diagnostics/vitest; a browser bridge (@solidjs/diagnostics/browser) plus a structurally-typed Playwright adapter (@solidjs/diagnostics/playwright) capture the same artifacts from real pages, with live whyDidRun/costs queries against an open session; @solidjs/diagnostics/protocol publishes the wire types for the vite-plugin dev-server endpoint; artifactToJSONL() provides line-oriented egress for offline/agent analysis. solid-js now ships a skills/reactivity-diagnostics repair guide mapping every diagnostic code to its fix.

  • 729a5e1: Add a dev-only solid-js/refresh subpath entry hosting the HMR component-swap runtime (ported from the standalone solid-refresh package). Compiled HMR wrappers keep the frozen $$registry/$$component/$$refresh/$$decline ABI and the hot.data protocol; the production build resolves to inert stubs. The "cannot hot-swap" bail path is now configurable via configureRefresh({ invalidate }) instead of hardcoding window.location.reload().

  • 500d484: Narrow affects() to a single optional key: affects(target, key?). The variadic form read like a 1.x store path (affects(state, "user", "name") suggests state.user.name but marked two sibling slots) — mark multiple slots with multiple calls, or target the nested record directly. Passing more than one key now throws in dev.

  • 512fd5e: update signals to 0.3.0

  • 3d8a8a9: Point JSDoc @description links at the 2.0 reference docs (v2.solidjs.com), document isPending, point the console footer, diagnostics guide and cheatsheet links at the next branch, and replace the stale onMount advice in the server-side client-only API error.

  • 59dd11f: Docs prep for the 2.0 reference auto-generation pass: backfill JSDoc examples on previously-undocumented public APIs (getObserver, isDisposed, createRenderEffect, onCleanup, createErrorBoundary, createLoadingBoundary, createRevealOrder, flatten, enableExternalSource, NotReadyError, NoHydration, Hydration, isServer, isDev); normalize inline JSDoc code fences to @example tags on the JSX components (<For>, <Repeat>, <Switch>, <Errored>, <Reveal>, dynamic, <Dynamic>); and tag cross-package wiring / compiler-emitted exports with @internal so the doc generator can hide them from the user-facing surface (getContext, setContext, createOwner, getNextChildId, peekNextChildId, enforceLoadingBoundary, sharedConfig, enableHydration, NoHydrateContext, $DEVCOMP, $PROXY, $REFRESH, $TRACK, $TARGET, $DELETED, ssr* helpers, escape, resolveSSRNode, mergeProps, ssrHandleError, ssrRunInScope). Also extends the equals field JSDoc on SignalOptions / MemoOptions to mention isEqual as the default.

  • 9015b12: AI-readiness docs/JSDoc pass — continued from the initial pass shipped earlier on this branch. Targets the failure modes surfaced while authoring the kitchen-sink TodoMVC example.

    Cheatsheet (solid-js/CHEATSHEET.md)

    • New "Props" section leading with "props are reactive values, not accessors". Covers the two failure modes that dominated the audit: passing filter={filter} instead of filter={filter()}, and destructuring props in the child (function Comp({ value })) which unwraps reactivity once and breaks tracking. The footgun list now points at this section.
    • Reframed onSettled as the canonical lifecycle primitive for component-level setup/teardown (return a cleanup function from the body); demoted onCleanup to advanced.
    • Store/setter/projection entries reframed to match the JSDoc precision below.

    createStore, createOptimisticStore, createProjection

    • StoreSetter<T> is mutation-first; the return form is shallow (arrays index-replace + length-adjust, objects top-level diff) and is not keyed reconciliation. Keyed reconciliation belongs to the projection-function return path (createStore(fn, …, { key }), createProjection, createOptimisticStore(fn, …)), where the function's return is reconciled by options.key (default "id").
    • createStore JSDoc gained a paragraph against putting signal accessors as store property values — the proxy already tracks reads per-property; nesting () => signal() inside a store property gives you a getter that won't track when called.
    • createOptimisticStore / createProjection — explicit note that options.key defaults to "id" and is only worth specifying for non-id identity fields. Replaced the imperative draft.length = 0; draft.push(...) example with a return …filter(...) form that names the keyed-reconcile guarantee, plus a per-property mutation example.
    • Added a setStore(s => s.list.filter(...)) line to createStore and a removeTodo filter-return action to createOptimisticStore.

    <Loading>

    • Added a sentence on scoping: place the boundary around the data-dependent slot, not the surrounding shell, so revalidation doesn't replace layout chrome with the fallback.

    Hydration wrappers (solid-js)

    • The hydration-aware re-exports of createMemo, createSignal, createOptimistic, createProjection, createStore, createOptimisticStore, createRenderEffect, createEffect, and createErrorBoundary previously had no docs at the wrapper site — hovering them in solid-js showed only the type signature. Each wrapper now carries the canonical primitive description plus a short Hydration paragraph pointing at the new HydrationSsrFields type, which centrally documents the ssrSource modes ("server" / "hybrid" / "client") and deferStream.
    • HydrationProjectionOptions (used by createProjection, the projection form of createStore, and createOptimisticStore) gets its own JSDoc explaining the ssrSource extension over ProjectionOptions.

    @solidjs/universal README

    • 2.0 banner added matching the @solidjs/web pattern — names the solid-js/universal → @solidjs/universal rename and the new deferred-mount semantics in the wrapped createRenderer.render (top-level mount goes through the effect queue and drains with a tail flush(); uncaught top-level async holds the initial commit on the active transition).
    • Custom-renderer example fixed: import path corrected to @solidjs/universal, the destructured use (1.x relic) replaced with applyRef, ref to match the actual dom-expressions/universal.js return shape, and the forwarded control-flow list updated to 2.0 names — For, Repeat, Show, Switch, Match, Errored, Loading, Reveal instead of For, Show, Suspense, SuspenseList, Switch, Match, Index, ErrorBoundary.

    JSDoc/example/docs only — no runtime or type-signature changes.

  • fb2e43b: Docs and JSDoc pass for AI-assisted code generation: rewrite root, solid-js, and @solidjs/web READMEs for the 2.0 beta; ship a one-page CHEATSHEET.md inside the solid-js npm package; audit and add @example blocks to the high-traffic public exports across solid-js, @solidjs/web, and @solidjs/signals. No runtime changes.

  • 845b6bb: Drop the solid-side support machinery for dom-expressions' old
    memo(accessor, true) wrap in insert(). That wrap has been replaced in
    dom-expressions with a conditionally nested render-effect pattern that
    splits the accessor's creation scope from its read scope — fixing stale
    reads and transition-ownership regressions (the Sierpinski hover freeze)
    without reintroducing the #​2610 sibling re-render.

    Solid-side companion cleanup:

    • @solidjs/web memo helper collapses to createMemo(() => fn()) and
      drops the coreMemo import; the transparent branch and $r
      short-circuit are no longer reachable.
    • @solidjs/signals accessor() no longer tags the returned function
      with $r.
    • @solidjs/web drops @solidjs/signals from peerDependencies and
      devDependencies — it reaches signals transitively through
      solid-js.

    No public API changes. Coordinates with a forthcoming dom-expressions
    release.

  • 215de3b: Align store overloads across the signals, client, and server entry points. Plain stores share StoreOptions, projection forms share ProjectionOptions, plain optimistic stores expose their existing options argument, and derived optimistic stores are typed as refreshable.

  • df3f514: Align with dom-expressions: add MathML support to Dynamic/createElement, consolidate namespaces, remove deprecated isSvg/Properties/SVGNamespace

  • 34c65b8: CSR: async reads without a Loading ancestor no longer throw. The root mount now participates in transitions — when uncaught async surfaces during initial render, the root DOM attach is withheld until all pending settles and then attaches atomically. On the no-async happy path, render() still attaches synchronously before returning (via an internal tail flush()).

    New schedule option on effects

    @solidjs/signals exposes a new schedule?: boolean option on EffectOptions. When true, the initial effect callback is enqueued through the effect queue (the same path user effects already take) instead of running synchronously at creation. This lets the initial run participate in transitions — if any source bails during the compute phase, the callback is held until the transition settles.

    createRenderEffect(
      () => source(),
      v => {
        /* runs after flush, deferred by any pending transition */
      },
      { schedule: true }
    );

    @solidjs/web's render() uses this option internally for its top-level insert, which is what enables permissive top-level async in CSR.

    Dev diagnostic

    ASYNC_OUTSIDE_LOADING_BOUNDARY is now a non-halting console.warn (severity downgraded from error to warn). With deferred-mount the runtime is correct; the diagnostic is an informative FYI rather than a correctness failure. The warning only fires during the synchronous body of render() / hydrate() — post-mount transitions (including lazy route changes) run under their own transitions with the guard off and do not emit this warning.

    Placing a Loading boundary remains the right tool when you want explicit fallback UI or partial progressive mount.

    Known limitation: multi-phase async

    Multi-phase async flows — for example, a lazy() component whose resolved body reads a second pending async memo — may still reveal partial DOM between waves. This is because the scheduler currently nulls activeTransition before running the completing flush's restored queues; a new transition started by recomputes during that phase does not re-stash already-restored callbacks. Single-wave nested async (including static siblings alongside a pending descendant) commits atomically. The multi-phase case is tracked as a follow-up; the recommended workaround today is to place a Loading boundary around multi-phase async subtrees.

  • 2a0da2f: fix(web): refuse an async memo that resolves to an element (#​4242)

    On the server, an async memo (or async iterable source) whose value is rendered output — JSX, a component's result, a <Loading>/<Errored> boundary — can no longer reach the hydration serializer. A boundary's output failed in seroval, so its record never resolved and the hydrating client waited on the memo forever (streamed, the boundary reverted to its fallback); a template object crossed as data, duplicating the markup, and streamed the client could not insert it (UNRECOGNIZED_INSERT_VALUE). The memo now rejects where its value lands, with the new diagnostic ASYNC_MEMO_ELEMENT (recorded on the observe channel; the dev message says what to do instead, other tiers carry the code), and its boundary contains the error like any render error: the nearest <Errored> renders its fallback and the client hydrates it; with none, the <Loading> fragment rejects and the client renders the subtree. Return data from the async memo and render the JSX from it. Ordinary data is never refused (only plain objects in the SSR template shape, boundary outputs and fragment arrays holding them count as rendered output), and content that never hydrates (<NoHydration>) is untouched.

    Also, a fragment failing while a boundary registered under an undefined key (one created inside an async memo's continuation) is pending no longer fails the whole request in renderToStream.

  • 8bf04ea: New dev diagnostic ASYNC_STORE_SETTER: a store setter callback that returns a Promise now throws in dev (through the diagnostics channel) instead of being silently ignored. A store setter is a synchronous transaction — the draft closes when the callback returns — so setStore(async d => …) committed only the writes before its first await and lost the rest. Covers every store family with a user setter (createStore, createOptimisticStore, the derived store's manual setter); a derived store's own async compute is not affected. Store-specific: a signal may legitimately hold a promise, so setSignal has no such rule. Production is unchanged.

    Docs: the OBSERVE.exclude guidance in RFC 08 no longer suggests runWithOwner(panelRoot, …) for panel writes (that is a write in an owned scope, see #​3512); the store's own nodes carry the excluded owner.

  • fd36d37: attribution.enable(opts) now returns the release of the hold it takes (idempotent, like subscribe), and options combine across holds by the most demanding request per key (the log prints while any holder wants it, a check runs while any holder wants it at the most sensitive threshold asked for, historyLimit is the largest), so a hold adds to what the engine does and never takes away what another asked for — a track enabled with log: false beside a console session leaves its log alone, in either order — instead of every call rebuilding the options from defaults. disable() is the full teardown whatever holds are outstanding (the console's reset), so re-enabling to reopen a window and calling disable() once cannot strand a hold. enablePerformanceTracks releases through the token. Dev builds create a component's console.createTask task only for components rendered while an attribution engine is installed — the stack capture per call roughly doubled dev mount for a session with nothing enabled; the tracks enabled at bootstrap still see every component's site.

  • 1a1e2f2: Attribution: feedback() — what the user waited on, as ranked tables.

    DEV.attribution.feedback() is a pure fold over the records the engine already keeps — holds() and the interaction on each re-run — with no measurement or hook sites of its own, the way costs() folds re-runs into scope and write tables. sources ranks each set of async sources that held writes by the silent time spent behind them, with holds/heldMs/worstMs, silent/silentMs, acknowledgedBy (which affordance answered and in how many holds — a source acknowledged on one screen and silent on another reads as exactly that), latestOnly (answered only by a latest() shadow), the interactions that were held, the distinct writes, and actions. interactions ranks user events (type + target; repeated dispatches fold together) by total cost, pairing the synchronous re-run work one dispatch caused (runs, selfMs, worstDispatchMs — the long-flush hazard) with the time its writes spent held (holds, heldMs, silentMs, worstHoldMs — the silent-hold hazard): the two INP failure modes as columns of one row. Every hold counts at any duration; SILENT_HOLD remains the thresholded verdict over the same records. New exported types FeedbackSource and FeedbackInteraction; the reactivity-diagnostics skill gains a "where to start" entry, and solid-js's console footer names the surface.

  • fd36d37: Attribution engine: timeline records, and a flushStart hook

    Five new listener-gated records on attribution.subscribe: create (a computation's creation run — the mount flame), effect (an effect callback, timed and joined to its compute run), flush (one scheduler drain: runs, creations, whether it parked a transition, the interaction it served), flight (an async flight from origin to landing or abandonment, with the async node's owner path) and fallback (a loading boundary's fallback from show to hide). None is built, logged or folded unless something is subscribed to its type, so the console/agent readers pay nothing for records only a timeline wants. OBSERVE.subjectOf answers for the node-bearing ones.

    Core: a flushStart hook beside flushEnd (one drain, never nested), and effectRunStart now fires in observe builds like its effectRunEnd twin, so writes inside effect callbacks carry their effect origin in observe too, not only in dev. The observe core grows by 67 bytes minified; prod is byte-identical.

    The engine's effect-frame → node map is now filled by the first write inside a callback rather than by every callback (every reader resolves it through a write's origin, and most effect callbacks never write), which removes a WeakMap write per effect callback from the enabled engine's hot path.

    @solidjs/web/performance-tracks paints the new records: creation runs and effect callbacks on the Effects/Memos tracks, drains on the Propagation track (one wave per drain), flights and fallbacks on a new Async track.

  • 7c14e23: Attribution: write provenance — who performed a change.

    Every root ChangeRecord now carries origin: the imperative frame that made the write. interaction (a user event — type, described target such as button#next "Next →", and dispatch time), effect (the callback's name), action (the generator's name), async (the landing's node), or external (timers, sockets, promise callbacks — including writes after an await rather than a yield inside an action, the documented transaction escape). Frames nested under an interaction carry it: an action a click started (every step, including post-yield resumptions), an effect whose run a click's write caused, an async flight a click's write launched. Why-chains print the origin after the write; RerunEvent.interaction and HoldEvent.interaction expose the interaction a run or hold traces back to, and SILENT_HOLD now opens with what the user did and measures the wait from the event, not from the first parked flush.

    @solidjs/web declares the interaction around its two dispatch sites — delegated events (onClick, onInput, onKeyDown, pointer events: every INP-relevant type) and runtime-attached direct handlers (spreads, non-literal handler expressions) — via the new DEV.attribution.withInteraction(ref, fn), which custom renderers and test harnesses can call themselves. New core dev hooks effectRunStart/effectRunEnd (replacing effectRun) and actionStepStart/actionStepEnd; all sites fold out of prod, verified byte-identical against the size scenarios.

  • 8d249c7: External-audit fixes on the patch-list driver surface: family (projection/optimistic) arrays now decline the driver — their structural changes emit no row/slot ops and the proxy identity is stable, so an engaged list would freeze on optimistic or projection structure (classic mapArray handles them correctly, including on identity-swap handoff). Shallow slot-patch registration is now multi-consumer — two driven lists over one shallow array previously overwrote each other's channel. Adds storeHasFamily (with server stub) and regression tests for both.

  • 51ffcb9: refresh(target) now returns a promise for the target's next QUIESCENT state — the re-ask (and anything that supersedes it) has settled. Accessor targets resolve with the settled value; store targets resolve with the store node passed (nested targets re-ask the whole family but resolve with the node the caller was looking at). A failed re-ask rejects, so yield refresh(x) in an action throws back at the yield point and reverts like any failed step; an ignored promise never surfaces an unhandled rejection, keeping fire-and-forget refresh unchanged. Semantics are quiescence, not flight identity: a superseding refresh folds every waiter onto whatever finally lands. Inside actions, truth landing into the held transaction is staged; the promise settles then (matching resolve()/until() delivery) and delivers the staged value — never the caller's optimistic override. The re-ask stays verdict-quiet (isPending unchanged).

    Implementation is pay-for-use and shares resolve()/until()'s effect machinery: the waiter is a microtask-delivered, direct-commit, authoritative-read effect over the marked node, deferred one microtask so same-tick refreshes still coalesce into a single re-ask. One new reader bit (CONFIG_FRESH_READ) makes the waiter's read pull a still-dirty source through recompute inline — it then parks on the re-ask's pending window (woken by the settle walk, which runs on every landing including equal-value ones) or serves the sync answer, instead of misreading the pre-re-ask value as settled. updateIfNecessary now also refuses disposed nodes outright (#​2983's bug class), and a disposed or non-derived target resolves immediately with its last value.

  • 427dc18: Bare ssrSource: "client" (no loadingValue/seedLoadingValue) is now the structural form instead of a dev error: on the server the source is a final hole — reads suspend the nearest <Loading> boundary, which flushes its fallback with the client-continue marker (or rejects its stream fragment when the hole surfaces after registration) and hands the position to the client, which renders the content fresh after hydration. Read outside a <Loading> boundary it throws a real error instead of hanging the stream. The declared form is unchanged: loadingValue/seedLoadingValue renders the declared first paint on the server and stays the value-channel alternative. Also swallows the settled-rejected fragment promise at the hydration claim so rejected fragments (error finalize or client handoff) no longer surface unhandled-rejection noise.

  • 4b5272f: createErrorBoundary and createLoadingBoundary now return a properly typed Accessor<T | U> (content union fallback) instead of () => unknown, with the same external signature across the core, client hydration, and server layers.

  • 928ba28: Fixed a pending <Loading> leaking its asset-attribution scope to later document-order siblings during streaming SSR (#​2860). The boundary assigned _currentBoundaryId on its buffered context at creation, but the property is an accessor inherited from the root context over shared tracking state — the assignment mutated the global boundary id with no restore, so a root-level lazy() after the boundary filed its module under the boundary's already-serialized asset map instead of the root _assets map, and that island never hydrated. The creation-time assignment is removed; every render phase already scopes the id correctly via runWithBoundaryErrorContext, which sets and restores it around the run.

  • 5bef430: Move createErrorBoundary, createLoadingBoundary and createRevealOrder types to solid-js/internal; they remain runtime exports of solid-js but are no longer part of its public types (#​3709)

  • dea16f3: Add client hydration support with tree-shakeable createMemo/createSignal wrappers, fix SSR context isolation for concurrent requests, align seroval serialization format, update @​solidjs/signals to ^0.10.2

  • 15dc3c6: return of useTransition, small API tweaks

  • b964dc7: Bump dom-expressions, babel-plugin-jsx-dom-expressions, hyper-dom-expressions, and sld-dom-expressions to 0.50.0-next.10.

    This includes SSR runtime optimizations for synchronous function holes and plain SSR array resolution, reducing overhead in list-heavy server rendering.

  • 76b11b2: Bump dom-expressions to next.22 with cascading root hole fix and jsx-properties type resolution

  • 23f7550: Bump dom-expressions/babel-plugin-jsx-dom-expressions/hyper-dom-expressions to 0.50.0-next.3. Replace lit-dom-expressions with sld-dom-expressions in @​solidjs/html for an AST-driven, CSP-safe tagged-template runtime. Wire untrack into @​solidjs/h's runtime to satisfy the new hyper API. Add small vitest smoke suites for @​solidjs/h and @​solidjs/html, and a @solidjs/web#test-types task with a tripwire for upstream client.d.ts re-exports of VoidElements/RawTextElements. Refresh both READMEs.

  • 8b9c5bf: Bump dom-expressions, babel-plugin-jsx-dom-expressions, hyper-dom-expressions, and sld-dom-expressions to 0.50.0-next.4. Picks up the hyperscript callback-prop materialization fix (returning h(Comp, …) from a render-prop callback no longer re-mounts stable rows on parent updates) and the upstream client.d.ts re-exports of VoidElements/RawTextElements. Drops the local workarounds in @solidjs/web (explicit constants re-export and the client.d.ts skip in types:copy-web). Folds the For-row regression cases into @solidjs/h's smoke suite as plain tests.

  • e841f8c: Bump dom-expressions, babel-plugin-jsx-dom-expressions, hyper-dom-expressions, and sld-dom-expressions to 0.50.0-next.5. Picks up the document-root reactivity fix: render(..., document) and hydrate(..., document) now wrap the rendered tree in a transparent render effect (mirroring what insert does for non-document roots), so a top-level reactive expression at the document root stays driven by signal changes after the initial flatten. Previously the document-root path called flatten(code) and discarded the subscription scope, leaving any top-level memo idle after the first walk — most visible with full-document hydration as in TanStack Solid Start. The new JSDoc on the JSX class attribute (a string vs. array+object form note carried up from dom-expressions) is also picked up.

  • 95ca987: Bump dom-expressions, babel-plugin-jsx-dom-expressions, hyper-dom-expressions, and sld-dom-expressions to 0.50.0-next.8.

    • SSR attribute/textContent grouping (next.7): the compiler now coalesces contiguous runs of dynamic attribute and textContent closures into a single _$ssrGroup(() => […], N) per element, and the runtime resolves all N hole positions through one closure invocation instead of N. Inserts/children stay separate so child isolation and hydration ids are unaffected. Bench: ~+15% on search-results (heavy attribute usage), neutral on color-picker (no qualifying groups).
    • SSR bail-path single-invocation fix (next.8): ssr() was invoking certain function holes twice when their return value walked into the bail branch (e.g., an array containing a NotReady-throwing item). For closures that read stateful getters such as JSX props.children — which rebuilds an owner subtree on each access — the duplicate invocation produced a divergent hydration-key prefix that the client could not claim, surfacing as "Hydration completed with N unclaimed server-rendered node(s)" warnings. The bail path now consumes the already-evaluated value instead of re-invoking the original closure.
  • 46ab2dd: Dev diagnostic CAUGHT_REACTIVE_READ (D-42 / S-47): warns once per computation when a reactive read's throw — NotReadyError or the source's error — was caught inside the computation's body and the pass completed with a value. An async computation is judged when its flight settles (a rejection is the throw continuing; a landed value is the catch). The runtime's own catches (boundaries, isPending, watch, comparator/cleanup/effect-callback routing, solid-js's hydration trace) never warn. Dev-only; no production bytes.

  • cf839ea: Context providers no longer create an owner of their own: the provided value now sits on the two memos that resolve the provider's children, so each provider allocates one node and one bound function fewer.

  • 1b81476: CHEATSHEET.md (and the solid-2.0-cheatsheet skill built from it) no longer recommends module-scope state for app-wide state (#​4141). It now matches the createContext JSDoc and the 2.0 docs: create state in a Provider, which owns it per request on the server, and reserve module scope for constants.

  • 0090fe3: Fix: a streamed <Loading> claimed after a client write changed a shell memo it reads now shows the client's value. A hydrated memo adopted while its server answer was still streaming had no snapshot, so once a client write took its compute over, the boundary's claim read the client's value while adopting the server's markup — and kept the server's text (or attribute) for good, since nothing re-ran the binding. The memo's server answer is now its snapshot when it lands, even when the write already superseded it: the claim reads what the markup shows and replays the client's value at its release, as for a written signal. If the client's recompute is still in flight when the boundary resumes, the claim is served the snapshot instead of going pending, so the boundary keeps the server's content (no fallback over it, no detached nodes, no lost queued click) until the client's value lands.

  • db8241c: A cleanup (onCleanup or an effect's returned cleanup) that throws no longer aborts the rest of the teardown: every other cleanup in the tree still runs, and the first error is rethrown once the teardown is done. Outside a flush (a root's dispose()), the dispose call rethrows it. Inside a flush (a branch switch retiring a frame, a pass replacing an uncommitted one, an effect disposing a root), flush() rethrows it after the flush has finished, so commits and effects are never left half-applied, and lazy nodes released before the throw are still released. An unobserved hook that throws is handled the same way. If an uncaught error halts the reactive system, a collected cleanup error is dropped rather than surfacing later from an unrelated dispose(). On the server, disposeOwner runs every cleanup the same way, so renderToStream's final dispose still reports the error (#​4193).

  • 43fae6e: onCleanup callbacks on one owner now run in reverse registration order (unwind), restoring the 1.x #​1562 semantics; in production, component bodies share the enclosing owner, so a parent that registers cleanup before rendering its children now tears down after them, matching dev (#​3572).

  • d826cd3: The client error hook — configureClientErrors({ onError }) from solid-js, and render/hydrate's onError option in @solidjs/web: the prod-tier seam through which an app, or an error monitor, hears the one failure nothing else can see — an <Errored> / createErrorBoundary collected it and renders its fallback. The twin of the server's configureServerErrors. An uncaught error is not this hook's: the halt (REACTIVITY_HALTED) hands its cause to the platform's reportError, the channel every monitor already listens on.

    Once per error object (a reset() re-collecting the same failure says nothing new; a primitive is reported per sight); ownerPath carries the component labels where the runtime keeps owner names; no return — the client has no wire to map for; a throwing hook is reported and ignored. A root's own hook wins over the ambient one for failures under it.

    Pay-for-use: the hook machinery (core/error-hooks.ts) is retained by createErrorBoundary or the app's own configureClientErrors import; a root's hook is parked on the root owner under the registered ROOT_ERROR_HOOK symbol (defined in the scheduler), so render retains nothing for an app that passes none. Core floor unchanged; apps with a boundary +~200 B.

    The server surface consolidates on the same name. onError on renderToStream/renderToString and on handleServerFunctionRequest is the server error hook ((error, context) => wire | void); onServerError is removed. A one-argument onError written for the old shape keeps working and now hears every handled failure — filter on context.handling === "failed" for the request-failing ones alone. New handling: "serialize" for a hydration value that would not serialize (what seroval's onError reported, for a render that passed one). With no hook anywhere, a failure that fails the request still reaches console.error.

  • ee94440: Hydration keeps a client-only boundary's served fallback (#​4286). A <Loading> whose content reads a bare ssrSource: "client" source is served as its fallback plus the "$$f" marker; the client hydrated that fallback, then resumed by re-running the boundary, and when the content suspended on the question it now asks, the new boundary built a second fallback and dropped the served one (losing focus, selection or a running animation in it). The "$$f" route now creates the loading boundary once, at hydration: its content waits on the resume and its fallback hydrates the served one (built at the boundary's id, as the server built it), so content that suspends after the resume keeps the hydrated fallback until it can show.

  • 21b9784: A "recovery" record on OBSERVE.records (RecoveryEvent): the client rendering a <Loading> boundary the server handed over — its fragment rejected or the stream was cut — with how long the fallback stood (waitedMs) and what the fresh render cost (renderMs), joined to the server's "boundary" record by id.

  • a7c6b8e: Keep client-sourced stores pending during hydration until their first client result unless seedLoadingValue exposes the seed as commit zero.

  • 56918c6: Close a serialized async iterator once the response that carries it is abandoned. When a renderToStream consumer cancels the readable or a pipe sink throws, the render is disposed, but the tapped iterator handed to the serializer kept delegating next() to the source, so an iterable memo, an async memo that resolves to an iterable, and a generator projection kept pulling (or never ran their finally) for as long as the source lived. The tapped iterator now answers done and calls the source's return() once its computation is disposed, and the projection pump closes its source when it stops for disposal. The render's wind-down also closes the serializer, which returns every async iterator it is still pulling — including a source whose pending next() never settles, which the disposed check on the next pull could never reach.

  • 01ac18c: Compiler componentNames option: component owner labels that survive minification. With the flag on, DOM output carries the tag as written in source as a third createComponent argument — <Home /> compiles to createComponent(Home, props, "Home"), <Ui.Button /> to "Ui.Button", <this.Row /> to "this.Row" — and the dev and observe runtimes label the component's owner with it (<Home> in diagnostic ownerPaths, attribution chains, and the devtools _component.name), falling back to Comp.name as before. Until now an observe-tier production bundle reported hot scopes and holds under whatever the minifier left of the function name (<Xt> › <Kn>), and a lazy() or HMR wrapper hid the tag name even in dev. Off by default and byte-identical output when off; SSR (which inlines the call) and universal output never emit it; the production createComponent ignores the argument. Both co

[!IMPORTANT]
✂ PR body was truncated to here.


Configuration

📅 Schedule: (in timezone Asia/Shanghai)

  • Branch creation
    • Between 12:00 AM and 03:59 AM, on day 1 and 15 of the month (* 0-3 1,15 * *)
  • 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 these updates again.


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

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

@cloudflare-workers-and-pages

Copy link
Copy Markdown

Deploying rstack-cli with  Cloudflare Pages  Cloudflare Pages

Latest commit: 3a04b9c
Status: ✅  Deploy successful!
Preview URL: https://ac299263.rstack-cli.pages.dev
Branch Preview URL: https://renovate-solid-js-2-x.rstack-cli.pages.dev

View logs

@chenjiahan
chenjiahan merged commit 5b275d4 into main Nov 18, 2026
6 checks passed
@chenjiahan
chenjiahan deleted the renovate/solid-js-2.x branch November 18, 2026 12:15
@chenjiahan chenjiahan mentioned this pull request Nov 18, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant