Repository navigation
chore(deps): update dependency solid-js to v2 - #125
Open
renovate[bot] wants to merge 1 commit into
Open
renovate[bot] wants to merge 1 commit into
renovate[bot] wants to merge 1 commit into
Conversation
|
Important Review skippedBot user detected. To trigger a single review, invoke the
|
Deploying with
|
| Status | Name | Latest Commit | Updated (UTC) |
|---|---|---|---|
| ❌ Deployment failed View logs |
tools | a2fde95 | Nov 18 2026, 04:04 PM |
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.
Note
This PR body was truncated due to platform limits.
This PR contains the following updates:
1.9.18→2.0.0Release Notes
solidjs/solid (solid-js)
v2.0.0Major Changes
c3e5e78: Async everywhere2645436: Update to R3 based signalse855fcb: 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 fromsolid-jsto renderer packages.a4c833d: Update to new package layout, signals implementation, compilerMinor 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 forloadingValue/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 beta8d249c7: Patch-mode list driver: keyed<For>over a store array is offered to theruntime's row-ops driver (create/bind at op-apply, LIS moves, node removal —
no mapArray, no per-row owners, no DOM-side reconcile).
Forcarries$llmetadata 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 anddriveList(web, rxcoreseam) for the runtime.
1b94264: Question-scoped pending model and theaffects()primitive (supersedes the optimistic mask)isPendingis 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 liveaffects()mark.refresh(), polling, and confirm refetches whose tracked inputs are value-stable no longer read as pending — the fresh value reveals silently.affects(target, ...keys)primitive (re-exported fromsolid-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 forssrSource: "client"(#2981). The server cannot run a client source, so the author must say what the pre-compute window renders:loadingValueon signal-family sources (createMemo, function-formcreateSignal/createOptimistic; an explicitloadingValue: undefinedis a valid declaration — put the undefined in the type and branch on it),seedLoadingValue: trueon store-family sources (createProjection, derivedcreateStore/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 declareloadingValue: 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 slots75eebc2: 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:
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'ssignaloption types as the globalAbortSignalwhen the DOM lib or@types/nodedeclares one, and as the minimal abort surfaceuntiluses otherwise, so the published declarations type-check with neither lib underskipLibCheck: 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 livewhyDidRun/costsqueries against an open session;@solidjs/diagnostics/protocolpublishes the wire types for the vite-plugin dev-server endpoint;artifactToJSONL()provides line-oriented egress for offline/agent analysis.solid-jsnow ships askills/reactivity-diagnosticsrepair guide mapping every diagnostic code to its fix.729a5e1: Add a dev-onlysolid-js/refreshsubpath entry hosting the HMR component-swap runtime (ported from the standalonesolid-refreshpackage). Compiled HMR wrappers keep the frozen$$registry/$$component/$$refresh/$$declineABI and thehot.dataprotocol; the production build resolves to inert stubs. The "cannot hot-swap" bail path is now configurable viaconfigureRefresh({ invalidate })instead of hardcodingwindow.location.reload().500d484: Narrowaffects()to a single optional key:affects(target, key?). The variadic form read like a 1.x store path (affects(state, "user", "name")suggestsstate.user.namebut 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.03d8a8a9: Point JSDoc@descriptionlinks at the 2.0 reference docs (v2.solidjs.com), documentisPending, point the console footer, diagnostics guide and cheatsheet links at thenextbranch, and replace the staleonMountadvice 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@exampletags on the JSX components (<For>,<Repeat>,<Switch>,<Errored>,<Reveal>,dynamic,<Dynamic>); and tag cross-package wiring / compiler-emitted exports with@internalso 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 theequalsfield JSDoc onSignalOptions/MemoOptionsto mentionisEqualas 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)filter={filter}instead offilter={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.onSettledas the canonical lifecycle primitive for component-level setup/teardown (return a cleanup function from the body); demotedonCleanupto advanced.createStore,createOptimisticStore,createProjectionStoreSetter<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 byoptions.key(default"id").createStoreJSDoc 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 thatoptions.keydefaults to"id"and is only worth specifying for non-ididentity fields. Replaced the imperativedraft.length = 0; draft.push(...)example with areturn …filter(...)form that names the keyed-reconcile guarantee, plus a per-property mutation example.setStore(s => s.list.filter(...))line tocreateStoreand aremoveTodofilter-return action tocreateOptimisticStore.<Loading>Hydration wrappers (
solid-js)createMemo,createSignal,createOptimistic,createProjection,createStore,createOptimisticStore,createRenderEffect,createEffect, andcreateErrorBoundarypreviously had no docs at the wrapper site — hovering them insolid-jsshowed only the type signature. Each wrapper now carries the canonical primitive description plus a short Hydration paragraph pointing at the newHydrationSsrFieldstype, which centrally documents thessrSourcemodes ("server"/"hybrid"/"client") anddeferStream.HydrationProjectionOptions(used bycreateProjection, the projection form ofcreateStore, andcreateOptimisticStore) gets its own JSDoc explaining thessrSourceextension overProjectionOptions.@solidjs/universalREADME@solidjs/webpattern — names thesolid-js/universal→@solidjs/universalrename and the new deferred-mount semantics in the wrappedcreateRenderer.render(top-level mount goes through the effect queue and drains with a tailflush(); uncaught top-level async holds the initial commit on the active transition).@solidjs/universal, the destructureduse(1.x relic) replaced withapplyRef, refto match the actualdom-expressions/universal.jsreturn shape, and the forwarded control-flow list updated to 2.0 names —For, Repeat, Show, Switch, Match, Errored, Loading, Revealinstead ofFor, 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/webREADMEs for the 2.0 beta; ship a one-pageCHEATSHEET.mdinside thesolid-jsnpm package; audit and add@exampleblocks to the high-traffic public exports acrosssolid-js,@solidjs/web, and@solidjs/signals. No runtime changes.845b6bb: Drop the solid-side support machinery for dom-expressions' oldmemo(accessor, true)wrap ininsert(). That wrap has been replaced indom-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/webmemohelper collapses tocreateMemo(() => fn())anddrops the
coreMemoimport; thetransparentbranch and$rshort-circuit are no longer reachable.
@solidjs/signalsaccessor()no longer tags the returned functionwith
$r.@solidjs/webdrops@solidjs/signalsfrompeerDependenciesanddevDependencies— it reaches signals transitively throughsolid-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 shareStoreOptions, projection forms shareProjectionOptions, 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/SVGNamespace34c65b8: CSR: async reads without aLoadingancestor 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 tailflush()).New
scheduleoption on effects@solidjs/signalsexposes a newschedule?: booleanoption onEffectOptions. Whentrue, 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.@solidjs/web'srender()uses this option internally for its top-level insert, which is what enables permissive top-level async in CSR.Dev diagnostic
ASYNC_OUTSIDE_LOADING_BOUNDARYis now a non-haltingconsole.warn(severity downgraded fromerrortowarn). 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 ofrender()/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
Loadingboundary 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 nullsactiveTransitionbefore 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 aLoadingboundary 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 diagnosticASYNC_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 diagnosticASYNC_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 — sosetStore(async d => …)committed only the writes before its firstawaitand 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, sosetSignalhas no such rule. Production is unchanged.Docs: the
OBSERVE.excludeguidance in RFC 08 no longer suggestsrunWithOwner(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, likesubscribe), 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,historyLimitis the largest), so a hold adds to what the engine does and never takes away what another asked for — a track enabled withlog: falsebeside 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 callingdisable()once cannot strand a hold.enablePerformanceTracksreleases through the token. Dev builds create a component'sconsole.createTasktask 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 waycosts()folds re-runs into scope and write tables.sourcesranks each set of async sources that held writes by the silent time spent behind them, withholds/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 alatest()shadow), theinteractionsthat were held, the distinctwrites, andactions.interactionsranks 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_HOLDremains the thresholded verdict over the same records. New exported typesFeedbackSourceandFeedbackInteraction; the reactivity-diagnostics skill gains a "where to start" entry, andsolid-js's console footer names the surface.fd36d37: Attribution engine: timeline records, and aflushStarthookFive 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) andfallback(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.subjectOfanswers for the node-bearing ones.Core: a
flushStarthook besideflushEnd(one drain, never nested), andeffectRunStartnow fires in observe builds like itseffectRunEndtwin, so writes inside effect callbacks carry theireffectorigin 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-trackspaints the new records: creation runs and effect callbacks on theEffects/Memostracks, drains on thePropagationtrack (one wave per drain), flights and fallbacks on a newAsynctrack.7c14e23: Attribution: write provenance — who performed a change.Every root
ChangeRecordnow carriesorigin: the imperative frame that made the write.interaction(a user event — type, described target such asbutton#next "Next →", and dispatch time),effect(the callback's name),action(the generator's name),async(the landing's node), orexternal(timers, sockets, promise callbacks — including writes after anawaitrather than ayieldinside an action, the documented transaction escape). Frames nested under an interaction carry it: an action a click started (every step, including post-yieldresumptions), 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.interactionandHoldEvent.interactionexpose the interaction a run or hold traces back to, andSILENT_HOLDnow opens with what the user did and measures the wait from the event, not from the first parked flush.@solidjs/webdeclares 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 newDEV.attribution.withInteraction(ref, fn), which custom renderers and test harnesses can call themselves. New core dev hookseffectRunStart/effectRunEnd(replacingeffectRun) andactionStepStart/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. AddsstoreHasFamily(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, soyield 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 (matchingresolve()/until()delivery) and delivers the staged value — never the caller's optimistic override. The re-ask stays verdict-quiet (isPendingunchanged).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.updateIfNecessarynow also refuses disposed nodes outright (#2983's bug class), and a disposed or non-derived target resolves immediately with its last value.427dc18: BaressrSource: "client"(noloadingValue/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/seedLoadingValuerenders 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:createErrorBoundaryandcreateLoadingBoundarynow return a properly typedAccessor<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_currentBoundaryIdon 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-levellazy()after the boundary filed its module under the boundary's already-serialized asset map instead of the root_assetsmap, and that island never hydrated. The creation-time assignment is removed; every render phase already scopes the id correctly viarunWithBoundaryErrorContext, which sets and restores it around the run.5bef430: MovecreateErrorBoundary,createLoadingBoundaryandcreateRevealOrdertypes tosolid-js/internal; they remain runtime exports ofsolid-jsbut 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.215dc3c6: return of useTransition, small API tweaksb964dc7: 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 resolution23f7550: 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. Wireuntrackinto @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-typestask with a tripwire for upstreamclient.d.tsre-exports ofVoidElements/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 (returningh(Comp, …)from a render-prop callback no longer re-mounts stable rows on parent updates) and the upstreamclient.d.tsre-exports ofVoidElements/RawTextElements. Drops the local workarounds in@solidjs/web(explicit constants re-export and theclient.d.tsskip intypes: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)andhydrate(..., document)now wrap the rendered tree in a transparent render effect (mirroring whatinsertdoes 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 calledflatten(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 JSXclassattribute (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.textContentclosures into a single_$ssrGroup(() => […], N)per element, and the runtime resolves allNhole positions through one closure invocation instead ofN. Inserts/children stay separate so child isolation and hydration ids are unaffected. Bench: ~+15% onsearch-results(heavy attribute usage), neutral oncolor-picker(no qualifying groups).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 JSXprops.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 diagnosticCAUGHT_REACTIVE_READ(D-42 / S-47): warns once per computation when a reactive read's throw —NotReadyErroror the source's error — was caught inside the computation's body and the pass completed with a value. Anasynccomputation 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 thesolid-2.0-cheatsheetskill built from it) no longer recommends module-scope state for app-wide state (#4141). It now matches thecreateContextJSDoc 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 (onCleanupor 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'sdispose()), 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. Anunobservedhook 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 unrelateddispose(). On the server,disposeOwnerruns every cleanup the same way, sorenderToStream's final dispose still reports the error (#4193).43fae6e:onCleanupcallbacks 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 })fromsolid-js, andrender/hydrate'sonErroroption 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>/createErrorBoundarycollected it and renders its fallback. The twin of the server'sconfigureServerErrors. An uncaught error is not this hook's: the halt (REACTIVITY_HALTED) hands its cause to the platform'sreportError, 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);ownerPathcarries 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 bycreateErrorBoundaryor the app's ownconfigureClientErrorsimport; a root's hook is parked on the root owner under the registeredROOT_ERROR_HOOKsymbol (defined in the scheduler), sorenderretains nothing for an app that passes none. Core floor unchanged; apps with a boundary +~200 B.The server surface consolidates on the same name.
onErroronrenderToStream/renderToStringand onhandleServerFunctionRequestis the server error hook ((error, context) => wire | void);onServerErroris removed. A one-argumentonErrorwritten for the old shape keeps working and now hears every handled failure — filter oncontext.handling === "failed"for the request-failing ones alone. Newhandling: "serialize"for a hydration value that would not serialize (what seroval'sonErrorreported, for a render that passed one). With no hook anywhere, a failure that fails the request still reachesconsole.error.ee94440: Hydration keeps a client-only boundary's served fallback (#4286). A<Loading>whose content reads a baressrSource: "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 onOBSERVE.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 byid.a7c6b8e: Keep client-sourced stores pending during hydration until their first client result unlessseedLoadingValueexposes the seed as commit zero.56918c6: Close a serialized async iterator once the response that carries it is abandoned. When arenderToStreamconsumer cancels the readable or apipesink throws, the render is disposed, but the tapped iterator handed to the serializer kept delegatingnext()to the source, so an iterable memo, an async memo that resolves to an iterable, and a generator projection kept pulling (or never ran theirfinally) for as long as the source lived. The tapped iterator now answersdoneand calls the source'sreturn()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 pendingnext()never settles, which the disposed check on the next pull could never reach.01ac18c: CompilercomponentNamesoption: component owner labels that survive minification. With the flag on, DOM output carries the tag as written in source as a thirdcreateComponentargument —<Home />compiles tocreateComponent(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 diagnosticownerPaths, attribution chains, and the devtools_component.name), falling back toComp.nameas 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 alazy()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 productioncreateComponentignores the argument. Both compilers implement it in parity (shared fixtures, cross-mode ratchet).@solidjs/vite-pluginenables it for the dev aConfiguration
📅 Schedule: (UTC)
🚦 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.