github solidjs/solid @solidjs/compiler@2.0.0

one hour ago

Minor Changes

  • 89a0531: Absorb the 0.50 expressions snapshot into this repo: lift compilers as @solidjs/babel-plugin and @solidjs/compiler, dump runtimes into @solidjs/web / h / html / universal. Origin: ryansolid/dom-expressions@e97e4290 (0.50.0-next.44).
  • 89a0531: Collapse the expressions dump: drop the rxcore seam, flatten runtimes into package src/, delete babel-preset-solid, and publish compiler natives as @solidjs/compiler-*.
  • 5455320: Register call-shaped component bindings in the refresh (HMR) pass (#3090). A component produced by a factory call — styled(...), an HOC, a tagged template — was never registered, and once a registered sibling made the module self-accept, hot.accept() disabled the very module invalidation its staleness relied on: the export went permanently stale, silently. Two compile-time admission gates fix this. A call-shaped top-level binding rendered as a JSX tag in its own module is proven a component and registers automatically (resolution is scope-aware — shadowing locals don't count). For export-only shapes with no in-module usage, the per-binding @refresh component pragma asserts it: export const Badge = /* @refresh component */ styled.span\...``. Registered call bindings get the full treatment — location, granular signature, and dependencies, with same-module registered components excluded from the dependency set (edits propagate through the proxy chain; counting them would remount the consumer on every edit of the module). This is a deliberate native-first divergence from the frozen Babel-plugin reference.

Patch Changes

  • 5a1abb3: Add a typed semantic IR stage and a compiler-owned TSRX typecheck projection with authored source maps, style metadata, and embedded CSS/script regions.

  • bb9dacb: Expose exact authored-to-generated TSRX ranges for editor tooling.

  • ead7b1a: Keep hydration IDs aligned when an intrinsic element has a ref and one reactive spread.

  • a40b6cd: The directives pass rejects a broadcast() render that reads the server function's outer body. The render is shared by every caller with the same arguments, but the body runs per caller, so the first caller's value would show for everyone. The returned component, and any local function it renders, may read the function's parameters, its own locals and module scope.

  • f5ad065: The broadcast() capture rule now covers data answers too. A returned value that is not a component (an async iterable, usually a call that makes one) may read the server function's parameters and module scope, never its outer body's locals: every later caller gets the first caller's stream, so const user = await getUser(); return watch(user.id) is a compile error. Of a returned respond(value, init) only value is checked, since each caller's response carries its own headers and status. A generator (async function*) is not checked: calling it runs none of its body, so all of it is shared.

  • 617d195: Emit element claims after the element's initial attributes are applied (#3923), at parity across both compilers.

    A fully static a[href] / form[action] is claimed at the end of its creation statements (after static writes and refs). An element with dynamic bindings captures its owner at creation (var _o$ = _$getOwner()) and is claimed as the last statement of its binding effect's callback — _$claimElement(_el$, _o$) — in both the single-binding and the multi-binding shapes, so the claim observes the applied values on the first run whether that run is synchronous or lands from a held flush. An element carrying a spread emits no compiled claim: the spread runtime claims it after the first application.

  • ba8c593: Restore Clippy and rustfmt checks for the native compiler and apply the resulting lint and formatting cleanups

  • ade599a: The Rust compiler core exports compile_program, an entry point that compiles an Oxc Program the caller has already built instead of source text. It is compile with the parse step split off: the program goes through the same dom / ssr / universal / dynamic back ends, with the same requireImportSource gate and coverage-pragma handling, so a frontend that produces an AST (rather than projecting to JSX text) gets the shared lowering and source maps on its own authored positions. source must be the program's source_text. Additive and Rust-only: compile and the Node transform() are unchanged (the shared back half is factored out of compile_inner; the TSRX route reaches it with its extracted stylesheet as before).

  • 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 compilers implement it in parity (shared fixtures, cross-mode ratchet). @solidjs/vite-plugin enables it for the dev and observe postures.

  • 3c1f809: Preserve /* istanbul ignore … */ and /* c8 ignore … */ block comments written as JSX children on the generated component children getter. Line comments are not carried.

  • 838b74b: The Rust compiler core exports TSRX's scoped-CSS engine as solidjs_compiler::style, moved from src/tsrx/style/ to src/style/ so it is available without the tsrx feature: compile_style, compile_style_with_class_map_selectors, and their input and output types (StyleInput, StyleLocation, StyleKind, Element, ElementKind, ElementChild, Attribute, AttributeValue, StyleOutput, ClassMapEntry, StyleError). The engine already had no dependency on the TSRX frontend; exporting it lets another frontend (one that does not use TSRX at all) scope a <style> block over its own elements and get the same stylesheet and hash a .tsrx file gets. Additive and Rust-only: the TSRX route and the Node transform() are unchanged.

  • b989693: Numbers inlined into templates now print the way JS String(number) does, as Babel's output does. Before, any whole number of 2^63 or more saturated to 9223372036854775807, and very large or very small values never switched to exponent form. Now {1e21} prints 1e+21, {1e19} prints 10000000000000000000 and {1e-7} prints 1e-7. A child hole now also folds -, * and / the way an attribute does, so <div>{1 / 0}</div> puts Infinity in the template instead of inserting 1 / 0 at runtime (#4322).

  • 3a2d214: The native compiler's JS loader accepts the patchDriver option and normalizes the boolean opt-in: the Rust core supports the option (dormant by default), but validateOptions' whitelist rejected it, and the napi wrapper mapping collapses true into Wrapper::Default — which patch_driver uniquely treats as disabled. The loader now whitelists the option and maps true to the default "patchDriver" import name so an explicit opt-in through @solidjs/vite-plugin reaches the native core.

  • bfc834e: Prefer a local development build (compiler.node) over the installed @solidjs/compiler-* platform package when loading the native binding. The published package ships no local binary, so a local build can only mean development — but the loader tried the platform package first, which made the monorepo's own tests (locally and in CI) silently run against the last published release instead of the code under test. A present-but-unloadable local build now fails loudly instead of degrading to the published binary.

  • ca15970: Non-hydratable client builds now remove the value attribute when a checkbox or radio input binds a nullish value or defaultValue, matching the runtime fix from #4009, so a checked box submits "on" instead of "". Both compilers route these bindings through setProperty when the input's static type is checkbox or radio, or when its type cannot be known at compile time (an expression, prop:type, attr:type). Text inputs, inputs without a type, and textareas still clear to "" inline (#2957).

  • 0c6db49: The secondary passes (transformDirectives, the lazy and refresh passes, source names) accept a filename with any extension. They run on code that is already lowered to JavaScript, so the filename is metadata rather than a parser choice: a known extension still picks its dialect, and any other (App.rx, from another front end) is parsed as TSX instead of failing with "Unknown file extension". This matters for server functions, whose IDs hash the filename: a front end can now pass the module's real path, so the ID matches the one moduleForFunctionId computes for that module. The JSX transform itself is unchanged.

  • ad1ecc5: serverComponents (SSR): keep attribute-slot positions bindable on intrinsic elements. A dynamic class or style now compiles to a whole-attribute _$ssrElementAttribute hole instead of a value inside the template's quotes, so a server component's class={{ selected: filters.all }} can mark the class name a client attribute slot owns; ref/on* positions compile, as before, to one guarded _$ssrClaim hole per element, which now emits _s:on:*/_s:ref markers for slot reads (the _bnd behavior-claim marker is gone). A spread element compiles its named ref/on* (<button {...rest} onClick={row.go} ref={row.el} />, wherever they sit relative to the spreads) to the same claim map — { click: expr, ref: [a, b] }, duplicate refs merged, a duplicate handler last-wins as on the template path — keyed by the index of the source each attribute sits before (<b {...a} onClick={go} {...b}> → { 1: { click: go } }) and handed to _$ssrElement as a seventh argument, a thunk the runtime reads only inside a server component's render, so plain SSR never evaluates the expressions (they used to drop with no marker and no finding); the runtime settles each handler position in source order, as the client's spread/merge() do (the last source that has the key owns it, undefined included). A ref beside a lone spread goes through the sources loop under the option (a dynamic spread call is thunked there, as it is beside any other attribute). The event name is always the lowercased on* remainder (onClick → click); on:/oncapture: are not 2.0 syntaxes and are no longer special-cased. Both compilers share the attributeSlots server-components fixture; plain SSR output is unchanged.

  • 5dbe29a: Count all JavaScript line terminators in scoped style and refresh locations and DOM and server-function diagnostics. Report diagnostic columns in UTF-16 units.

  • fd36d37: sourceNames.bindings: compiled binding effects are named by what they write. An attribute effect gets <tag>.<attribute> as written (span.textContent, div.class:active, div.style:color; a template's merged effect lists all of its bindings), a hole's insert is named for the parent it fills (div.children), and a spread passes its tag so the runtime labels its attribute effect div.spread and its children insert div.children. The names travel as a trailing options argument on effect/insert ({ name }) and a trailing string on spread; @solidjs/web's effect, insert, and spread accept them and put them on the render effect nodes, where the dev and observe tiers show them in owner paths, attribution chains, and the Propagation track — a binding effect reads span.textContent ← count instead of effect ← count. Production ignores the names; output with the option off is unchanged. DOM output only; sourceNames: true turns it on with components.

  • 4a99c84: sourceNames gains a locations kind and transform() a root option: component and binding labels carry a file:line:col for diagnostics, printed the same as @solidjs/babel-plugin's. createComponent(Home, props, "Home", "src/App.tsx:12:5") points at the <Home opening element (DOM and SSR output); a binding's options gain loc after name — the attribute's start for an attribute effect (a merged effect points at the first attribute it lists; a property split out of style={{…}} / class={{…}} at that attribute), the hole's { for an insert — and a spread passes it after the tag (spread(el, props, false, undefined, "div", "src/App.tsx:20:12")). The path is relative to root (default: the working directory) with / separators; line and column are 1-based, so a dev server links the location straight to the source. Like the other kinds, locations follows dev when unset, true turns every kind on, and the object form picks; a location is only emitted beside its label, and never without a filename.

    transformSourceNames gains locations (default true) and root: it writes loc beside name in every options literal it writes or completes — createSignal(0, { name: "count", loc: "src/store.ts:3:22" }), the call's start — keeping an explicit name (and still adding loc) and never overriding an explicit loc.

  • fd36d37: Rename the compilers' componentNames option to sourceNames, now boolean | { components?: boolean }. sourceNames: true (or { components: true }) is what componentNames: true was — the tag as written in source as createComponent's third argument, on DOM and SSR output. The option is now the home for every kind of source name the compilers can carry into output for the dev and observe runtimes to label the reactive graph with (binding effects and primitives follow); the object form picks kinds. @solidjs/compiler rejects componentNames as an unknown option, so a stale @solidjs/vite-plugin fails loudly rather than compiling without labels.

  • fd36d37: transformSourceNames: the pass behind the Vite plugin's sourceNames.primitives option (a @solidjs/vite-plugin option, not a compiler transform() option — the compiler exposes it as this standalone function). Reactive primitives (createSignal, createMemo, createOptimistic, createStore, createOptimisticStore, createProjection) resolving to a solid-js / @solidjs/signals import are named after the identifier they are declared as — array pattern, binding, property key, or class field — prefixed with the enclosing non-component function (createCounter.value), never overriding an explicit name. Plain JavaScript in and out, so it runs on .ts/.js modules too.

    Stores honour name: createStore(value, { name: "todos" }) labels its property nodes todos.title in attribution output instead of store.title; derived and optimistic stores name their property nodes alongside the projection node.

  • 8d6de07: Native elements with several spread sources compile to the runtimes' array form instead of a mergeProps() call, in DOM and SSR output: <div id="x" {...a} {...b}> becomes spread(el, [{ id: "x" }, a, b], …) on the client and ssrElement("div", [{ id: "x" }, a, b], …) on the server. The runtimes read the sources directly — later sources win per key, only the winning source is read — with no merge proxy to build and walk, and a reactive spread is a plain thunk called inside the tracking scope, so it mints no memo and consumes no hydration id on either side (the hydratable SSR () => mergeProps(…) wrapper is gone for the same reason). A lone spread still passes straight through (#3105). Requires @solidjs/web with the spread/ssrElement array forms (#3418, #3419).

  • a8c98bd: Preserve the source location of captured references in SSR props constructors so source maps point to the authored expression instead of the start of the JSX element, matching @solidjs/babel-plugin.

  • 59fb244: SSR hoistProps no longer captures names in TypeScript type positions (type parameters, annotations, as/satisfies targets, type arguments, typeof x queries, local type/interface declarations, implements/extends heritage) as constructor arguments, which threw ReferenceError once the types were stripped (#3828). A type or interface that shares a value's name no longer makes that value count as redeclared, so its site still hoists.

  • ab57910: Report correct TSRX diagnostic positions after Unicode line separators and carriage returns, preserving UTF-16 columns and treating CRLF as one line break.

  • 41be120: The @solidjs/compiler-wasm32-wasi fallback loads on Android (Termux), where the filesystem root cannot be opened: its generated loader no longer preopens / there (it failed with UVWASI_EACCES, uvwasi_init). The loader is regenerated by @napi-rs/cli 3.10.6, which maps the WASI root to the working directory on Android.

  • 38cab7a: Lower TSRX compiler output directly to Oxc AST without reparsing a generated text projection.

  • d70dda5: Carry authored istanbul/c8 ignore pragmas through the remaining #2138 cases: a pragma immediately before a component (including through a fragment) leads that component's children getter, pragmas inside fragments are preserved, and SSR prop-hoist copies them onto the shared descriptor's get().

  • 6d2bdeb: Move delegated event handlers off the $$<type> element key Solid 1 uses.

    Solid 1 delegates from document and fires any $$click/$$input/… it finds while walking up from the target, so a 1.x runtime on the same page — an older embedded widget, a devtools panel built on 1.x — ran every delegated handler in a 2.x app a second time. Compiled output and the runtime now stamp _$$<type> / _$$<type>Data instead; neither version can see the other's handlers, in either nesting direction.

    The key, the _$SOLID_EVENT_OWNER mark, and the walk rules are documented in client.ts as the delegated-event wire contract shared by every Solid copy on a page. Anything reading el.$$click directly must switch to el._$$click.

  • 1e7fa73: Reject authored TSRX lazy destructuring in Solid while retaining deferred patterns generated for keyed loops and catch clauses.

  • 47a797e: Drop leftover DOM Expressions loader fallbacks and reframe the compiler and Babel plugin as Solid 2.0 packages. Node transform() now defaults moduleName to @solidjs/web and builtIns to the Solid control-flow set, matching @solidjs/babel-plugin. SSR leaves a sole component child unescaped (it is a value; the callee's insert sites escape) and only HTML-escapes mixed/fragment children and element holes. Local native builds remain usable when an in-repo platform-package stub has not been populated yet.

  • bf71c28: DOM output no longer declares positional walks to nodes nothing reads. A text node ahead of an appended expression, like User : in <h1>User : {name()}</h1>, used to get var _el$3 = _el$2.firstChild even though the insert appends with a null marker. A minifier keeps that property read, since it could be a getter, so it shipped as _el$2.firstChild;. Both compilers now drop a firstChild/nextSibling walk when no later statement reads its node, including a walk that only fed another dropped walk.

  • 8366e09: A "use server" function declaration nested inside another function is now extracted like any other server function.

    • Previously the directive on a nested declaration was silently ignored: the body shipped to the client and ran there, while captures from the enclosing function were still rejected at compile time.
    • The declaration is hoisted to a const at the top of its block, so calling it before its source position still works.
    • Its id follows the binding path, such as outer.inner.
  • 0d2810a: Fix Babel and native compiler lowering divergences around nested content, custom-element ownership, static attributes, namespaces, and conditional evaluation order.

  • ad1ecc5: Native compiler: $key on an intrinsic element with a spread (<li $key={id} class="todo" {...attrs}>) now follows the same rule as on a template element — SSR compiles it to the _key attribute the frame morph matches keyed elements by, and a DOM compile strips it. It previously passed through the spread path unrenamed, so server markup carried a literal $key attribute and keyed morphs lost identity. Babel already behaved this way; the shared keyedElements fixtures pin the spread case for both.

  • c9c16cb: Fix DOM insert markers to reference the following sibling's declared walk variable (_$insert(_el$, expr, _el$2)) instead of re-deriving the walk inline (_el$.firstChild), matching babel-plugin output. Affects dynamic slots followed by static content in both single-slot and per-slot parents.

  • c8aac88: Fix native TSRX compilation of parenthesized keys, iterables, and conditions, including annotated @for loops used directly in a component body. Map comments back to the authored source to prevent invalid JavaScript and Unicode panics when source maps are enabled.

  • 43570f8: Reapply a select's bound value when its options arrive after the value was written.

  • 7d985b6: Fix SSR XSS: strings yielded by flow-control memos rendered unescaped

    <Show when={s}>{s}</Show>, <For>{v => v}</For>, <Dynamic component={() => s} />,
    <Switch>/<Match>, boundary fallbacks and any component that returns a string through a
    memo rendered that string raw on the server. The server flow controls return memos for
    hydration-id alignment; escape() passed functions through by identity, and the resolver
    appended whatever they later produced without escaping.

    One rule now: escape(x) at a hole covers everything reachable from x — strings, array
    items, and what a function yields when the resolver calls it (a deferred-escape wrapper).
    Finished { t } nodes pass through. Loading escapes its content the way it already
    escaped its fallback. The compilers stop wrapping fragment / mixed component children in
    _$escape (they are values; escaping them too double-escaped through
    <Comp>{props.children}</Comp>), and a single-expression fragment at a hole keeps the
    hole's wrap. Live-hole tags ride the wrapper and $slot survives the array copy, so
    frames behave as before.

  • 98b916d: Fix compiled SSR output that renders style="" or class="" for null and undefined. Babel and the native compiler now omit these attributes on elements without a spread.

  • 98d35b9: Fix computed keys in compiled SSR style objects (builds without serverComponents). A computed key's name got no ;, so style={{ color: "red", [k]: v }} rendered color:redtop:1px and the browser dropped both declarations. Hydration keeps the server's inline style, so they stayed dropped. A nullish first value also no longer leaves a leading ;. Both compilers now pass a multi-entry object to a new ssrStyleProperties(name, value, …) helper, which writes the separator only between the entries it writes; a single entry keeps ssrStyleProperty.

  • bbff5e0: Direct value/checked (and other stateful DOM property) bindings no longer overwrite pre-hydration user input during the hydration claim pass (#3182). Hydratable compiled output now routes locked DOM properties through setProperty, which skips writes on hydrating nodes and carries the <select value> microtask and input/textarea nullish special cases.

  • cdbd584: Assign static <select value> values through the live DOM property so the matching option is selected consistently with reactive values.

  • 077c787: A <textarea> with a dynamic value/defaultValue no longer desyncs hydration ids for the siblings after it (#3691). The server folds the value into the textarea's text content, and that fold was taking the _$scope hydration-id reservation a dynamic child hole gets — but the client writes the value as a plain property effect that never allocates an id, so every component after the textarea hydrated one id off and its updates targeted detached DOM. The fold is now treated like the innerHTML/textContent redirects (#3015): opaque content, no id reservation, in both the Babel plugin and the native compiler.

  • 59da78e: Preserve direct JSX child shape and deferred callback evaluation when lowering TSRX control flow.

  • ed9993f: Preserve scoped selectors when a TSRX element contains dynamic children.

  • 5a1abb3: Compile TSRX loops with an index but no explicit key using Solid's non-keyed callback shape.

  • a836015: Rewrite prefix and postfix updates of TSRX lazy bindings to their deferred member targets, matching the Babel frontend.

  • f02ce64: Preserve nested TSRX deferred-binding rewrites in optimized native compiler builds.

  • ea5f1da: Fix native TSRX compilation when a setup statement has no semicolon before markup.

  • 320f1f5: Universal text is text (#3127). The DOM and SSR generators splice static
    text into an HTML template that a parser later unescapes, so they escape
    static values and keep JSX entities as written. The universal generator
    hands strings straight to the host — createTextNode, setProp — with no
    parser downstream, so the escaping rendered literally ({"<b>"} showed as
    &lt;b>) and entities never decoded (&lt; showed as &lt;), leaving no
    spelling that produced a literal < in static text under a custom
    renderer. Universal-rendered element children now pass static values
    through unescaped and decode JSX entities in text and string attributes,
    matching what component children and fragment text always did. The flag
    rides on the element, not the config, so generate: "dynamic" decides per
    renderer. Applied to both compilers; the attribute half closed ten pinned
    cross-mode parity divergences between them. Reported with the fix mapped
    out by @antoinevanwel.

  • b3586e8: Validate document-shell templates in the document context (#3259). The validate pass round-trips templates through a body-context fragment parse, which strips <html>/<head>/<body> wrappers no matter how well-formed the markup — so once #3099 made validate failures compile errors, a root component owning the document shell failed to compile in plain client mode, and merely importing it (the jsdom component-test configuration) was fatal. Shell-rooted templates now parse as a document and the shell element is compared back — the analogue of the synthetic <table> wrap for table partials, in both the Babel plugin and the native compiler. Genuine restructuring (an implied <head>, flow content in <head>, a <p> split in <body>) still errors. Since <template> parsing flattens shells, actually client-creating one now throws a descriptive dev-mode error from template() pointing at hydrate() — the failure moved from every import to the one broken act.

  • 246eeeb: Emit non-identifier getter keys in compiled props literals as string literals (get "aria-label"() {}) instead of computed keys (get ["aria-label"]() {}). Same property, but a computed key drops the whole object literal off V8's boilerplate path into per-property runtime definition; on a seven-getter props literal the computed form costs ~45% more to build. Applies to every getter site in both compilers: component props, dynamic element attributes (DOM, SSR, universal).

  • 4ba1731: A controlled input no longer loses typed text when its signal write is held (an async derivation of it is pending) and another binding in the same template re-runs, such as a sibling isPending class flipping: a stateful DOM prop (value, checked, …) in a grouped effect or a spread skips an unchanged write while the effect is a stale reader of an open hold, and the hold's landing writes the bound value (#4872). Outside a hold every run still writes (#2016, #4186).

  • 7c551ae: Key server-function ids on identity instead of position (#3109). Production ids were <xxhash32(path)>-<ordinal>, so appending a server function to a file renumbered the others and every client holding the old numbering silently dispatched to different code with a 200. Ids are now <name>-<xxhash32(root-relative path)>, with a trailing ordinal only when the same descriptive name recurs within one file — appends, deletes, reorders, and body edits no longer move any address, and a removed or renamed function becomes a clean 404 instead of a wrong call. Development and production now share the exact same id format.

  • 82868c6: Support recursive lazy destructuring, lazy arrow parameters, per-read defaults, computed keys, rest views, standalone assignments, accessor-backed keyed-loop and catch patterns, and JavaScript-correct writes and updates across the Babel and native TSRX frontends.

  • 15e1228: The native compiler no longer drops a component ref whose value is wrapped in a TypeScript as cast, non-null ! or satisfies, such as ref={[setRef, props.ref] as any}; it classified the wrapper instead of the value inside and emitted no ref prop. The universal generate also keeps array refs on components and unwraps as and ! on element refs, so <view ref={myRef as any} /> assigns the element to myRef, as the Babel plugin does.

  • 0c4bff7: Add lazyModule() so a lazy module that is not a component can be preloaded and hydrated by module id.

  • 9e1edbc: A lone dynamic spread on an SSR element (<label {...props()} />) now defers behind a thunk like a spread beside other attributes, so it runs after the element's hydration key. A spread that created a memo shifted the element's key on the server only, and hydration missed the element (#4240).

  • 5230666: Fix hydration ids drifting after a reactive lone spread (#3105). A lone spread now passes its accessor straight to spread() on the client — no mergeProps, no memo, no hydration id — matching the server's existing pass-through fast path. The runtime resolves a function props source inside its own tracking scopes.

  • 96ffcf7: Production builds compile a <Show> that needs no component to the ternary it renders: no keyed, no spread, only when and fallback, with JSX children or a one-parameter callback whose when is a plain read (each u() reads when again). Dev builds keep the component and its stale-read error. The lowerShow option overrides the default (!dev). The native compiler's SSR pass also no longer returns a TSRX module's static templates unescaped when one element in the module is marked as safe.

  • 4f67697: Breaking: only on followed by an uppercase letter (onClick, onPointerDown) is an event handler. Lowercase on* names (onclick, onmouseover) are plain attributes everywhere:

    • Both compilers compile onclick={expr} like any other attribute (setAttribute, reactive when expr is dynamic) instead of binding a delegated or native event, and SSR renders it as an escaped attribute instead of dropping it. A leftover 1.x on:click={fn} is likewise a plain namespaced attribute (it previously compiled to addEventListener(":click", fn)).
    • @solidjs/web spread/assign set lowercase on* keys as attributes, the server spread walk renders them, and useHead applies lowercase on* attributes (camelCase handler names stay skipped). ssrAttribute escapes a function value instead of interpolating its source raw.
    • @solidjs/html and @solidjs/h elements wrap a function passed to a lowercase on* in a getter like any other attribute; only onXxx and ref are exempt.
    • @solidjs/html components follow @solidjs/h's rule: every zero-argument function prop, onXxx handlers and ref included, is a getter, so a component handler must declare its event argument (onClick=${e => …}).
    • New dev-only check LOWERCASE_EVENT_ATTRIBUTE (added to the DiagnosticCode union): warns once per attribute name when a function is set on a lowercase on* (or on:) attribute, naming the camelCase handler to use.
  • ea8e37c: A production <Show> whose callback reads its value ({u => <p>{u()}</p>}) is lowered to a ternary only when when reads signals, memos, stores, names, literals and operators. A when that reads another object's member, such as a prop, keeps the component (#4936): the ternary wrote u() as a second read of when, and a prop's getter runs again on each read, so when={props.children} created the child twice and broke its hydration. JSX children without a callback still lower for any when.

  • 2f01f23: Module-level "use server" exports now register by value: the server build registers each export's evaluated terminal initializer whole, so server-side wrappers compose onto every call path — export const getUser = withValidation(schema, fn) applies the wrapper to HTTP dispatch and in-process SSR calls alike, and patterns like withDelay(fn, 400) work for server mocks. The client build always emits bare references, so wrappers, schemas, and helpers stay server-only by construction. The compiler never inspects the initializer's shape; registerServerReference now throws at module eval when handed a non-function, turning stray non-function exports into loud boot errors instead of dead references. Anonymous default expressions (export default withDelay(...), export default async () => ...) get a synthesized binding and register too — previously they were silently dropped from both builds. Supersedes the unreleased wrapped-export compile error.

  • 235173e: Prune the observability surface: OBSERVE.attribution.install, the AttributionHooks type, DEV.setConsoleFooter, the TraceSlot and OriginRef aliases, PerformanceTracksOptions.group, and the untested solid-js/refresh runtime modes (esm, webpack5, rspack-esm) are gone — @solidjs/compiler's transformRefresh({ bundler }) accepts only "vite" | "standard" to match. ownerPath() is now OBSERVE.ownerPath(subject) and diagnosticGuideUrl() is DEV.guideUrl(code); why() also accepts a scope name. Engine record types (RerunEvent, HoldEvent, …) live on solid-js/attribution only, and InteractionRef/NavigationRef on the main entries only. @solidjs/diagnostics types its record tables off the runtimes' own catalogue (RecordEvent<K>), adds the recovery table, and bumps the artifact formatVersion to 8.

  • 8d249c7: Patch-channel contract hardening from the stage-2 re-audit: ordinary patchDriver registrations unbind with their owner (entries no longer leak past unmount); merged transitions move their held-patch stash so no patch strands; the optimistic drain shares the normal drain's per-entry error isolation and boundary routing; accessor-bearing records are excluded at admission (scan-before-trust) and records that acquire accessors demote their patches to tracked effect fallbacks; writable projection arrays emit setter row ops at their fold-commit visibility moment; row-ops/slot registrations resolve chained backings to the ultimate owner; duplicate keys match occurrence-aware instead of first-wins; the production dev-token typo (_DX_DEV_) is fixed; patchDriver: true normalizes identically in Babel and the native loader, the option is typed in TransformOptions, and a dom-patch parity tier ratchets patch-mode output across both compilers (currently byte-identical on all fixtures).

  • a5bd44a: Fix directive transform source maps to point to the original input by running dead-code elimination on the existing AST instead of printing and reparsing between passes.

  • 005d938: Recover common incomplete TSRX editor snapshots in the typecheck projection while keeping compilation strict.

  • 4da3fb4: Refresh pass: modules rendering document-shell elements (<html>/<head>/<body>) now take the @refresh reload path (decline + full reload) instead of registering hot-swappable components (#3151). A document shell can never hot-swap: the hydratable compile emits no client template for those elements — they are only recoverable from the hydration walk, so a post-hydration re-render throws a hydration mismatch — and their static markup/attributes exist only in the server-rendered HTML, so even a successful swap could not reflect the edit. Editing a Document/Shell component now triggers a full page reload that fetches a fresh server render.

  • c3de743: A module constant read by a component the refresh pass hoisted above it folds into the template as it does without the refresh pass, so the dev client and the server agree on the hole and hydration no longer crashes (#4791).

  • c71486d: DOM output: an element's ref now runs after its attributes and spread are applied, and still before its children. A ref's own attribute writes now survive client creation the way they already survived hydration (#3685).

  • a181e4d: A "use server" directive on a method, getter, or setter is now a compile error instead of being silently ignored.

    • Those forms are never extracted, so the body kept running wherever it was called, browser included.
    • Covers object literal methods and accessors, and class methods, accessors, and constructors.
    • Assign a function to a property instead, which the pass does extract.
  • 6bf2bf8: An arrow marked "use server" that reads this or arguments is now a compile error instead of silently breaking at runtime.

    • The arrow is extracted to module top level, where this is undefined and arguments does not exist.
    • A marked function is unaffected, and so is any function or class nested inside the server function.
  • bb905db: A module-level "use server" module that exports something other than a server function is now a compile error instead of producing a client build with the export missing.

    • Covers re-exports, export *, class and enum exports, destructured exports, and exports declared without an initializer.
    • The message names the export, its position, and what to do instead.
    • Type-only and declare exports are erased and stay allowed.
  • 3f36f77: Server components: binding slots are removed. Client components in slots replace them: place a client component through a Slot (<props.x />) where the server's markup needs client behavior, or a form action for a mutation. Removed with them: the BindingSlot, SlotOutput and SlotError types, the lazy @solidjs/web/frames/bind entry and its "bind" tier, the _s:* position markers and the compiled ssrClaim hole, the effect of the serverComponents compiler option (@solidjs/compiler and @solidjs/babel-plugin still accept it, so existing build configs keep working, and ignore it), and the BINDING_SLOT_POSITION diagnostic code (@solidjs/signals' DiagnosticCode, solid-js's diagnostics.json). Ordinary slots, their slot:<id> ranges and records, and $key are unchanged.

  • d601119: Remove the experimental patch channel and patch-mode list driver (always opt-in, never default). Graph-native regions own value delivery and the unified-For design owns list structure, so the channel's parallel delivery machinery is retired: patch.ts/patch-driver.ts deleted, the compiler-contract exports (registerPatch/registerRowOps/registerSlotPatch/patchableRaw, patchDriver/rowProof/driveList) removed, the patchDriver compiler option dropped from both compilers, the insert $ll seam stripped, and the write-side channel struct dieted to the single written-keys bound (t.wk) the core fold/notify paths actually use. Store-family app bundles reclaim up to ~900 B brotli; every measured tier shrinks.

  • 3e72783: The removed Solid 1.x attribute forms are now compile errors on native elements in the dom and ssr generates (#4187). on:, oncapture:, attr:, bool:, use: and classList used to compile silently into literal attributes (<div use:tip="() => {}">, classlist="[object Object]"). Both compilers now reject them with the same message, which names the 2.0 replacement: a camelCase handler or a ref callback for on:, a plain attribute for attr:, a boolean value for bool:, a ref directive factory for use:, and an object or array class for classList. Components, the universal generate, prop: and the XML namespaces (xlink:, xml:, xmlns:) are unaffected. The check runs only at compile time and adds no runtime code.

  • b534733: Scope-wrap bare function children in hydratable mode. A function child (<main>{() => <App/>}</main>, including via the children attribute) is a deferred hole at runtime, but it never classified as dynamic, so neither generate reserved an id scope for it — its owner ids drifted across async retry passes on the server and desynced from the client (the #2900 hydration-id-parity class). Both compilers now treat syntactic function expressions as scope-eligible alongside dynamic values, emitting _$scope(...) in the ssr generate and around the matching insert accessor in the dom generate. The native compiler also unwraps TS casts in the allocate-ids predicate, matching Babel (fixes a scope-emission desync for {call() as any} children).

  • 45407d1: JSX passed through a prop other than children (a layout's header, an object of slots, a context value) now hydrates when another id-allocating hole follows it (#3567). Both compilers' hole-scope predicate treated only props.children as able to build hydratable content, so a {props.header} hole compiled to a transparent insert: the server reserved the scoped sibling's slot at registration and gave the header's elements the next id, while the client allocated in source order, and every key after the slot shifted. The predicate is now a denylist: a dynamic hole takes a scope unless its value is provably a primitive (literals, template literals, unary, binary and update expressions), so property reads, optional calls, the left operand of ||/??, sequence and assignment expressions, and array literals with hydratable entries are all scoped. Ids of elements after such a hole shift by one slot on both sides.

  • c0299bf: Server-function ids now name a function by its binding path, so two same-named functions no longer share one id.

    • makeA's submit becomes makeA.submit-<hash> instead of submit-<hash>.
    • Adding a same-named function no longer re-points the ids of the existing ones.
    • Ids for functions in objects and classes pick up those names too, such as handlers.save.
    • A named function contributes its own name as well, so register(function saveHandler() {}) inside wire is wire.saveHandler rather than sharing an ordinal with its siblings.
  • 6717d35: sourceNames follows dev in both JSX compilers. Unset, every kind (components, bindings) is on when dev: true and off otherwise; true/false sets every kind (sourceNames: false opts a dev build out); the object form picks, and each kind it leaves unspecified follows dev (previously false). Production output (dev: false) is byte-identical with the option set or unset. @solidjs/babel-plugin's PluginConfig.sourceNames is now optional. Dev builds label components (createComponent(Home, props, "Home")) and binding effects (span.children) out of the box, so diagnostics and the Performance panel read as source without build-tool configuration.

    Primitive naming (createSignal(0, { name: "count" })) stays with @solidjs/compiler's standalone transformSourceNames pass, which the build tool runs on every module independently of the JSX compiler; it is not a JSX-transform kind, and the READMEs and RFC now say so.

  • d0ba31c: SSR evaluates a ref expression beside a spread, as it already does without one, so a ref factory's owned setup (ref={tooltip()}) runs on the server too and the hydration ids after it line up. The ref itself is still never called on the server (#4081). Under serverComponents the same holds outside a server component's render, where a ref expression was never evaluated on either path; inside one the claim evaluates it, once.

  • 56683ea: SSR templates write characters above U+00FF in static text and quoted attribute values as numeric character references (→ becomes &#8594;), as do the static attributes baked into a spread element's attribute string. One character above U+00FF in a template made V8 store the whole rendered page as a two-byte string, which roughly doubled the cost of flattening and UTF-8 encoding the response (#4328). Latin-1 characters stay literal. Tag internals, comments, raw-text bodies such as <script> and <style>, and the children of a spread <script> or <style> keep their characters, since browsers do not decode references there. Client output is unchanged.

  • 63560a1: componentNames now applies to SSR output. Under the option both compilers keep the createComponent call they otherwise inline to Comp(props) and pass the source tag name — createComponent(Comp, props, "Comp") — so the server runtime's observe/dev createComponent labels the owner and a server finding's ownerPath reads <App> › <Page> like the client's. Without the option (prod builds) SSR output is unchanged. @solidjs/vite-plugin already passes the option for its dev and observe postures, so app server builds pick this up with no config change.

    Fixes ssrScope under transparent owners: the virtual hole scope swapped the current owner's id counter, but content inside a hole resolves ids by walking past transparent owners, so with one in between (the server-component scope owner; now the labelled component owner) the hole's content took ids from the enclosing counter and disagreed with the client. The scope now swaps the nearest id-bearing owner.

  • b2cb0c7: The server build escapes string literals in a ternary branch, after &&, and in every return of a function child, including a return inside if, switch, try or a loop. The server now renders them as text, as the client does, in children and in attribute values (#4710). A function value in an attribute keeps its literals as written at every depth, because the server stringifies its source.

  • 701cbb3: SSR escapes the children of <style> and <script> under <svg> and <math>. There they are ordinary elements whose text parses as markup, so only HTML-namespace <style>/<script> render raw text (#4704).

  • 22f942d: SSR: a router can mark links in server HTML (#3878). Element claims never fire during SSR, so plain anchors arrived without aria-current="page" / data-active — late on hydrated pages, never on pages that do not hydrate. Both compilers now give every candidate <a href> in SSR output one hole after its attributes, ssrLinkClaim(attrs), where a render's link handler writes the anchor's link state and "" otherwise. A static anchor's hole is one eager call over a hoisted attributes object (no allocation per render); a dynamic anchor's joins the element's attribute group and reuses the raw value its href hole evaluated. Anchors the compiler can rule out — a static non-empty target, a download, a rel naming external, an author-written aria-current, an empty href or a non-HTTP scheme — get no hole at all. The hole creates no owner and takes no hydration id. A spread anchor's link attributes are collected by ssrElement from its winning sources (an anchor's trailing link attributes stay a source instead of baked tail markup).

    New server API (@experimental): setLinkClaim(handler) sets the handler of the render the caller belongs to — found through the owner chain like getHydrationWriter(), so concurrent renders never share one — and returns false outside a render; undefined clears it. The handler, (attrs) => string, receives the anchor's link-relevant attributes (href, target, rel, download, link, aria-current, raw values as written) and returns its attribute markup. An author-written aria-current always wins. Server components inline in the document render under the page's handler; a server component's own frame stream has none unless its render sets one.

    Trust marker: the first setLinkClaim of a render writes the links hydration record once (_$HY.r.links = 1, with the shell's hydration script on the document face, a data record on a frame stream). hasServerLinkState() (client; false on the server) reads it non-destructively, so a link consumer can tell "this page's anchors carry the server's link state" from "no handler ran" and trust the HTML at hydration instead of resolving every anchor's URL at claim. Without a handler the HTML and the hydration ids are byte-for-byte what they were.

  • 1735074: SSR: a component's props literal with getters compiles to a module-level constructor with shared getters (hoistProps, default on) instead of an object literal, which V8 builds in dictionary mode with a closure per getter per instance. Same own keys, order, descriptors and prototype; a props getter is now defined only for a read through its own object — copying its descriptor elsewhere throws (dev names the rule). Sites closing over a reassigned or later-declared binding, this, or arguments keep the literal. Babel and the native compiler emit the same output.

  • eabc4c5: A bound <select value> marks its matching <option selected> while the server renders, not in a pass over the finished html (#4891). The old pass was switched on for the whole process by a module-scope ssrSelectValues() call in any module that had a bound select, so every render after it scanned its full html and every streamed fragment, even with no select in it. Both compilers now read the select's value once ahead of its children (ssrSelect) and keep it on a transparent owner the select's children render under (ssrIn). Each compiled server <option> asks ssrOption whether it is selected. Options a <For>, a component or a later async pass renders inside the select are matched too, and a select whose options stream in after a <Loading> inside it is no longer left unmarked. ssrSelectValues and resolveSSRSelectValues are removed. A multiple select's bound value is matched as the client assigns it, entry by entry from an array, with no comma split. An option whose text content is markup (no value attribute) is not matched.

  • e10a4ba: SSR: attributes written after an element's last spread are markup, not a source. <li {...rest} class="row" data-id={id}> compiles to ssrElement("li", rest, …, _sk$, () => ' class="row"' + ssrElementAttribute("data-id", id)) — statics written as the template path writes them, dynamics through ssrElementAttribute (the spread walk's rules for one key), the whole string a literal when every part is static — with a hoisted skip predicate (var _sk$ = k => k === "class" || k === "data-id", one per key set) so the spread's own copies of those keys are never read or emitted. No later source can override a trailing attribute, so the output is unchanged; the thunk runs where the trailing source's getters used to be read, so hydration ids keep their order. What goes away per element is the trailing object literal (with getters, a dictionary-mode object and a closure per getter), its key list, and the precedence check on every key of the spread — an element whose only other source is the spread now serializes from one plain object. Attributes before a spread stay a source, and a source literal with getters (<li data-id={id} class="row" {...rest}>) now compiles to the same hoisted constructor as a component's props (hoistProps). Spread-static-tail server bench, 500 rows: statics after the spread 1.31×; a dynamic and a static after the spread 1.42× (1.22× from the hoisted source form, 1.17× from the thunk on top); the same attributes before the spread 1.21×. Child properties (innerHTML, textContent, children), a textarea's value, reserved namespaces and JSX-valued attributes stay sources.

  • 9adf007: Escape static text on SSR spread elements (#3557)

    • Static text children of a spread element (<div {...props}>a &lt;b&gt;</div>) are now HTML-escaped at compile time in both compilers, matching the template path; script and style children stay raw.
    • A static textarea value folded into the template (<textarea value="a &lt;b&gt;" />) is escaped in both compilers.
    • The Babel plugin no longer folds a textarea value into children on an element that carries a spread, so the value stays a prop and precedence follows JSX source order, matching the native compiler.
    • Static string props on the Babel spread paths are rebuilt from their decoded value, so <div {...props} title="a &amp; b" /> no longer double-encodes entities.
  • 642ea75: Validate SSR templates for malformed HTML under the validate option, as DOM templates already are, so markup that only compiles for the server (such as server components) reports the same compile error.

  • 4b836ab: Validate SSR templates rooted at an SVG or MathML element (such as <image> or <g> under control flow, in a fragment, or as a component root) inside their <svg>/<math> owner, as DOM templates already are, so valid SVG partials no longer fail the validate check.

  • 8a6de0f: Dev builds now warn with STRICT_READ_UNTRACKED (#1742) when an element's event handler expression reads reactive state, e.g. onClick={selected() ? a : b} or a props.onClick the parent passed a reactive expression. A handler is bound once, where its element is created, so such a read is not meant to be reactive; the warning says to read the value inside the handler function instead. A pending async read there throws PENDING_ASYNC_UNTRACKED_READ, as in a component body. The read still tracks, so dev re-mounts on a change exactly as production does.

    Production output is unchanged byte for byte. In dev DOM output both compilers wrap each handler expression that can read reactive state (anything but an identifier, an inline function or a literal), including the [handler, data] form's bound values on delegated events, in a new strictHandler(() => expr) helper from @solidjs/web. It reads expr through strictReadTracked, a dev-only strict-read window that keeps tracking (internal, from @solidjs/signals via solid-js). No production-compiled module imports either, so they tree-shake away.

  • 82868c6: Support TSRX statement containers in expression positions in the native compiler.

  • 774aad5: Add compile-time scoped styles, CSS sidecar output, style class maps, and style refs to both TSRX frontends.

  • d9a10b8: Support composing lowered .tsrx modules with the server-function directive transform while preserving path-stable function IDs.

  • 66cce98: Emit native TSRX source maps against authored .tsrx locations while leaving compiler-generated projection ranges unmapped.

  • ab4c40c: Object-valued style / class bindings are read in the TRACKED half of their effect. style() and className() enumerate their object in the effect's untracked commit phase, so a proxy value — a store sub-object (style={state.style}, class={row.classes}), merged props, anything arriving through a spread — was identity-reactive only: in-place key mutations never re-applied, and every leaf read tripped STRICT_READ_UNTRACKED in dev. Both compilers now wrap the compute value of a non-inline style={expr} / class={expr} in a new compiler primitive, readShallow(), and spread() applies it to those two keys as it copies. readShallow is an identity passthrough for strings, plain objects and proxy-free arrays (a fresh literal is already the compute's own — the common case pays a typeof); a proxy is copied with one ownKeys trap (its own trap keeps the key set tracked) plus one tracked read per key; arrays are re-mapped only when an element is a proxy. Inline literals are untouched — they already compile per property. Provably-string expressions (string/template literals, concatenation) and literal objects/arrays skip the wrap at compile time. New Tier-1 bench style-class-object: plain-object rows at parity; store-backed rows go from identity-only (and, in dev, ~97 ms per 500 elements of diagnostics) to per-key reactive at ~3.5 ms. Octane svg-dashboard (prod build, store-backed style/attrs through spread): mount at parity, style_spread_pulse −6%, select_toggle −7%.

    spread() shares the same enumeration: its compute half copied the source with for…in + hasOwn, which on a proxy source (merge()/omit(), {...props} in a component, store records — nearly every spread) is an ownKeys trap plus two getOwnPropertyDescriptor traps per key, each allocating a descriptor and a getter closure. It now takes the key set from one Reflect.ownKeys trap (the trap keeps the key set tracked) and reads each string key once; plain sources use Object.keys, the exact own-enumerable set the old loop yielded. New Tier-1 bench spread-enumerate (500 elements, 8 keys): merge(static, reactive) 376 → 537 ops/s (+43%), store record 253 → 415 ops/s (+64%), plain object at parity.

  • 350f65f: TSRX: @for … index/key items and @catch errors pass through to For / Errored as the accessors Solid hands out; the compilers no longer rewrite reads of those bindings into calls (#3474). Author item(), i() (under a custom key), and err() exactly as in JSX. A destructuring pattern in one of those positions is rejected with a diagnostic, since there is nothing to destructure — the default keyed @for item is still a raw value and still destructures. projectTsrxForTypecheck emits the same (item, i) => / (err, reset) => arrows @tsrx/solid does, so the two typecheck projections now agree.

  • c9c16cb: Add an experimental TSRX syntax frontend to both compilers. .tsrx sources (routed by filename with the new syntax: "auto" | "jsx" | "tsrx" option) desugar @if/@else, @for … @empty, @switch/@case, @try/@catch/@pending, @{} statement containers, and lazy destructuring (&{}/&[]) into the shared Solid JSX lowering, producing byte-identical output from both compilers. The Babel plugin loads the optional @tsrx/core peer dependency lazily; the native compiler ships the frontend behind the default-on tsrx cargo feature (statement containers in expression position are rejected with a structured diagnostic pending upstream oxc-tsrx support).

  • 6cca8b5: Dev builds now warn with UNCOMMITTED_INPUT_OVERWRITTEN (#4186) when a stateful DOM property binding (value/checked on an input, value on a textarea, value/selected on an option, muted on media) is about to re-write the value it wrote last time over an edit the user never committed to the bound signal — e.g. value={props.name} onChange={commit} with no draft signal, when another dynamic attribute in the same template changes. Runtime behavior is unchanged: the write still happens, once per element and property the warning names the fix (write the signal from onInput, use defaultValue/defaultChecked for an uncontrolled element, or write a rejected edit back with e.currentTarget.value = next).

    Production output is unchanged byte for byte. In dev DOM output both compilers write stateful properties through a new setStatefulProperty(el, name, value) helper instead of the inline el.name = value; hydratable output keeps setProperty, and spread/assign check in the runtime. The check lives only in @solidjs/web's dev build; the production entry carries a plain node[name] = value stub that no production-compiled module imports, so it tree-shakes away.

    The "Form inputs" section of the DOM RFC, the cheatsheet and the solid-2.0 skill now say that a change to any other dynamic attribute in the same template re-runs a stateful binding, link the new code, and drop equals: false as a way to reject input (it is what the warning reports); write the accepted value back with e.currentTarget.value = next instead.

  • 1643d2a: The universal renderer's spread() follows the @solidjs/web contract (#3388): ref folds into the props effect and is re-applied only when its identity changes (refs run with no owner, so nothing they create is disposed by the fold); children keep their own owned insert — that effect owns the child subtree — but a plain object whose children is a data property inserts the value with no effect at all. Three reactive nodes become two when children flow through the spread, one when they don't. spread also resolves a lone function source inside its own tracking scopes and accepts an array of sources — spread(node, [a, b], skipChildren) — the union of their keys with later sources winning, only the winning source read, function sources called inline with no merge and no memo. Both compilers' universal output uses it: a lone spread passes straight through (reactive included, no more mergeProps(() => …)), and several sources compile to the array instead of a mergeProps() call.

  • e27dc29: validate now fails the compile instead of warning when a template's markup would be restructured by the browser's HTML parser (#3099). Once the validator fires the emitted positional walk is guaranteed not to match the browser-built DOM (crashed or silently misplaced bindings; desynced hydration under SSR), so warn-and-emit shipped certain breakage with the diagnostic buried in server logs. Errors now point at the offending JSX (code frame in Babel, line:col in the native compiler). validate: false remains the opt-out.

  • 2ba1c4a: A valueless prop: attribute (<el prop:active />) now compiles as prop:active={true}, matching bare plain attributes, instead of being dropped silently (#4180).

Don't miss a new solid release

NewReleases is sending notifications on new releases.