# Changelog ## 0.5.0 - 2026-10-12 - Document the application-owned stable ID pattern for label and description associations, with installed SSR/hydration, keyed reordering, independent roots and native browser qualification. - Document and execute an optional DOM Testing Library/user-event recipe for native component and router harnesses, with scoped accessible queries, input and keyboard interactions, async retry, isolated runtime retirement and cleanup; qualify browser defaults separately. The integrations are dev-only and add no runtime dependency or public export (#755). - Add typed `appMeta` declaration data to routes, groups and pages, with immutable parent-to-leaf `currentRoute().matches` reads and leaf-only `matchRoute()` reads. Application metadata is separate from head metadata and is not automatically transported in SSR hydration data. See the application route metadata guide. ### Breaking changes - Require `@askrjs/auth` and `@askrjs/schema` 0.5.x when these optional peers are used. Upgrade their packages together with Core. - Reduce the Core surface from 373 to 342 named/entrypoint pairs while keeping all 22 export-map keys. Remove testing `mount`/`queryState` aliases; move testing `matchRoute` to its router owner. Remove utilities `ariaDisabled`, `ariaExpanded`, `ariaSelected`, `DefaultPreventable`, `FocusLikeEvent`, `KeyboardLikeEvent`, `PointerLikeEvent`, and `PropagationStoppable`. - Retire stateless `isControlled`, `resolveControllable`, and `makeControllable` exports and manual `createLayer`, `Layer`, `LayerOptions`, and `LayerManager` exports. Remove router `ParsedSegment`, `PageScopeRecord`, and `LayoutScopeRecord`; import `AuthContext`/`AuthRequirement` from `@askrjs/auth`. - Remove SSR `SSRRoute` and SSG `RouteConfig`/`DiscoveredResources`; make registry-based `SSGOptions` non-generic. Import `SSRStyleRegistrationValidation` from SSR. Import `jsxDEV` from `jsx-dev-runtime` and manual `JSXComponent`, `JSXElement`, and `JSXElementType` from `jsx-runtime`. See `docs/migration/0.5.0.md` for every replacement and behavior difference, and `docs/development/0.5.0-public-api.md` for the complete API decisions. ### Deprecations - None. ### Additions - Add `createSessionAuth()` and its three option/binding types at the router owner for same-origin server provider sessions. Adopt a minimal SSR identity, dedupe session GETs, construct safe provider links and retire private routed data before logout or identity changes. Decoded typed interaction failures trigger login or consent recovery without wrapping API transports. Session-bound roots own dedicated isolated runtimes; manual auth remains independently supported. See `docs/guides/provider-sessions.md` (#777). - Export the existing `RenderableChild` type from `@askrjs/askr` for component presentation props and layout slots, including nested readonly arrays. Together with isolated runtime retirement and app runtime replacement, the surface before the provider-session binding has 345 named/entrypoint pairs. Value children exclude factories; `Scope` retains its explicit factory-child contract. See `docs/core/rendering.md#presentation-children`. - Add `disposeDataRuntime()` at `@askrjs/askr/data` for terminal, idempotent retirement of isolated runtimes, including retained readers, queued work, mutation rollback, and abort-ignoring requests. Create a new isolated runtime after disposal; the shared default cannot be disposed. Native prefetch uses the effective `context.signal` combining caller cancellation and retirement, rather than preserving the caller signal's object identity; disposing the runtime does not abort the caller's own signal. - Add `replaceDataRuntime(root, next)` at `@askrjs/askr/boot` to switch a live routed app or island to another native runtime without remounting its shell. Future implicit data hooks and route preloads use the replacement; pending navigation from an earlier owner cannot publish. The operation preserves component state and does not dispose the previous runtime. Explicitly retire an exclusively owned old runtime when changing identity. - Add aggregate critical-runtime coverage with independent DOM, SSR, data and router regression floors, CI source reports, and cleanup/hydration failure and recovery probes. ### Fixes - Preserve session transport failures when a supplied fetch throws before returning a promise; allow the next resolution to retry without an unhandled rejection or cached identity. - Make removed-export type assertions fail when a value or type is restored. Qualify the packed absence checks under TypeScript 6 and 7, and exercise the required classic JSX factory for a key written after a spread. - Preserve newer navigation ownership when an abort listener starts or cancels a request, and stop the interrupted request before starting obsolete work. - Enforce startup locks and component-function checks for index and fallback routes, retain a page's index slot after failed registration, and normalize root-page fallback paths to `/*`. - Ignore query results and consistency errors superseded by their own callbacks; preserve newer invalidation work created by start or reconciliation abort listeners instead of starting obsolete transport or suppressing retries. - Retire a destroyed query's cache entry before abort listeners run, so a reader mounted by that listener acquires a live replacement for the same key. - Restore hydration render context when claiming SSR resource metadata throws, so a failed claim leaves server nodes and the following hydration retry intact. ## 0.4.4 - 2026-10-08 ### Breaking changes - None. ### Deprecations - None. ### Additions - Add lifecycle-owned `refreshOnActivity()` for focus, visible-document return, and reconnect hints with an explicit freshness age and shared query ownership. ### Fixes - None. ## 0.4.3 — 2026-10-02 ### Breaking changes - None. ### Deprecations - None. ### Additions - None. ### Fixes - Retain each queued input or textarea edit and checkbox/radio change during hydration, so replayed handlers and a following submit observe the captured values even when hydration writes the initial control state. File input values remain untouched. - Preserve native printable typing, Backspace, and Delete in editable text controls before hydration. Enter, modified shortcuts, and activation retain their existing cancellation; immediately activated deferred key handlers can still cancel the native edit. - Discard events whose target is replaced during deferred activation and release root capture listeners when the final deferred boundary completes. ## 0.4.2 — 2026-10-01 - fix(foundations): honor previously cancelled click and keyboard events in `pressable()` and `rovingFocus()` while preserving disabled propagation suppression and native keyboard activation timing. - fix(ssr): support private sibling component opt-in to render descendants once before ancestor attributes, preserving legacy attribute order and output for ordinary hosts, scoped lifetimes, namespaces, portals, and streaming transport. - fix(ssr): finalize private component reference metadata after the rendered root and its portals, preserving ordinary attribute evaluation and error boundaries without repeating components or caller ID functions. ## 0.4.1 — 2026-10-01 - fix(data): honor defined-query `skipInitialFetch` and `initialData` options, retain prefetched/hydrated data precedence, and retire active or queued refreshes when the last reader leaves a query retained by `gcTime` (#724). - fix(data): retire obsolete requests immediately when invalidation supersedes them, preserve every string query key during dehydration, and keep sparse query-key arrays from colliding with empty arrays. Dense-array keys are unchanged. - fix(resources): abort and close failed stream generations, capture stream definitions from the committed render, and preserve component ownership in listener and timer callbacks so nested FX and invalidation use the owning app. - fix(core): restore `derive()`/`selector()` definitions and subscriptions after a rejected render, and run replacement refs even when previous ref cleanup throws. - fix(core): retain the following server element when hydration adopts merged adjacent text nodes, including text claimed through reserved cursors. - fix(control): preserve native and class instance receivers in `For` rows while retaining reactive overlays for plain records and stable keyed row lifetimes. - fix(foundations): prevent stale collection cleanup from removing a newer registration for the same node, and preserve own `__proto__` props in `mergeProps()` without changing the output record's prototype. - fix(router): preserve prototype-named path parameters and query fields without changing the prototype of the returned plain records. Server snapshots omit browser history state, and hydration omission guards apply only to declared omissions rather than inherited object properties. - fix(router): capture each committed `onRouteChange()` callback and snapshot, preserving ordered changes and cleanup when several commits precede a flush. Destination snapshots read the matching navigation state before browser history is written, and navigation state getters run once per destination. - fix(ssr): distinguish actual deferred hydration values from ordinary records with the same marker keys. Existing generated pages retain their original deferred decoding, unambiguous pages retain their existing envelope bytes, and the hydration envelope remains version 1. - fix(rendering): keep attribute names such as `constructor` and `toString` literal rather than interpreting them as inherited alias or namespace entries. - fix(hydration): retain the clicked submit button when replaying a form submission after hydration replaces its controls. Failed idle attempts retain interaction and visibility retries, and mixed completion paths release their replay and scroll listeners after the final deferred section activates. - fix(ssg): normalize named splat entry parameters while preserving accepted raw token spellings, encode dynamic render URLs while preserving existing output paths and data override keys, and rebuild unchanged routes when their generated HTML is missing. ## 0.4.0 — 2026-09-28 - feat(router): expose `matchRoute(path, { registry })` for synchronous route path checks without resolving policies or loading route data. The testing helper uses the same implementation. - fix(core): a component tree too deep for the call stack fails with a `RenderDepthError` (exported from `@askrjs/askr`) that explains the limit, instead of a bare `RangeError` (or Firefox `InternalError`). It is raised where render errors are first caught, so error boundaries, updates, and SSR see it. The rendering guide documents the supported depth (#624). - perf(core): remove quadratic owner, scheduler, and context paths (#612). Detaching an owner is O(1) (holes in the parent's child list, compacted when they dominate), the render lane is a depth-ordered heap and the effect and post lanes are O(1) queues, and each component caches its inherited context revision. On the new `tier2-subsystem-core-scaling` bench: disposing 10,000 sibling owners 50.7 ms to 0.43 ms, 5,000 render jobs 13.4 ms to 0.87 ms, 20,000 effect jobs 20.2 ms to 2.06 ms, patching a 2,000-deep chain 13.0 ms to 0.72 ms (mean). - fix(jsx): export `createElement` from `@askrjs/askr`. The automatic JSX transform in TypeScript, esbuild, Babel, and oxc (Vite) compiles a `key` written after a spread (``) to `createElement` from the import source, which previously failed to resolve. It removes the development-only `__self`/`__source` props and, like `jsxs()`, marks several child arguments as static children (#617). - fix(foundations): `controllableState()` results destructure like `state()` (`const [value, setValue] = controllableState(...)`). `ControllableState` is now based on `StateTuple`, so the destructured getter and setter are typed. The getter is readable like a `state()` getter, and an updater passed to its setter runs once (#621). - docs(foundations): document stacking dialogs and toasts through one writer that owns the layer list and writes it through its own `definePortal()` channel, since a portal shows the most recent writer's content (#495). The default portal is part of the core client bundle, because every application root provides and hosts it; the SSG hydration bundle check now asserts this and the SSG guide no longer says otherwise (#611). - **breaking** refactor(api): control, data, `getSignal` and `onRouteChange` each have one import path (#487). Migration: - `For`, `Show`, `Case`, `Match` and their prop types: import from `@askrjs/askr/control` instead of `@askrjs/askr`. - `createQuery`, `createQueryCollection`, `defineQuery`, `serveQuery`, `defineServerQueries`, `prefetchQuery`, `dehydrateDataRuntime`, `hydrateDataRuntime` and the query types: import from `@askrjs/askr/data` instead of `@askrjs/askr`. - `getSignal`: import from `@askrjs/askr` instead of `@askrjs/askr/resources`. - `onRouteChange`, `RouteChangeCleanup`, `RouteChangeOptions`: import from `@askrjs/askr/router` instead of `@askrjs/askr/resources`. - **breaking** refactor(api): unused low-level exports are removed (#490). `resolveRequest` and `renderResolvedToStringSync` are no longer exported from `@askrjs/askr/ssr`. To resolve auth, redirects and status without rendering, call `resolveRouteRequest(url, { registry, mode: 'ssr', auth, authContext, request, signal })` from `@askrjs/askr/router`. Pass `mode: 'ssr'` explicitly (the default is `'spa'` when a global `window` exists) and pass `signal` explicitly (it is not taken from `request.signal`). The result may be a plain value or a Promise, and errors can throw synchronously, so call it inside an `async` function and `await` it to keep the old always-async behavior; to render, use `renderToString`, `renderRouteRequest` or `renderRouteRequestToString`. `debounce` and `DebounceOptions` are no longer exported from `@askrjs/askr/fx`; use `debounceEvent` for event handlers, or keep a local debounce helper for code outside components. - fix(types): intrinsic JSX typings accept MathML elements (``, ``, ``, ...), `dangerouslySetInnerHTML` on every element, and the `formAction`/`formMethod`/`formEncType`/`formNoValidate`/`formTarget` attributes on `
` on the client. This applied when the result was the first render or followed an empty first render, including `{'x'}`, Portal function children, wrapper fragments rendering text, and content in the automatic default-portal host. The client now places that content among its siblings inside `askr-range` comment anchors, matching the server markup. A nested component that renders nothing and later renders text keeps its instance and state. - fix(runtime): a failed render no longer leaves a structural function child stale. A function child in a component's fragment or array result (`<>{() => Array.from({ length: n() }, ...)}`) renders as a small component; when its update joined a parent render that failed, the rollback dropped that update, so the list kept the old item count until `n` changed again, even after the parent recovered. The same applied to any child component re-rendering on its own state. A rolled-back render now restores the update the component was due (a queued run, or a scheduled render it superseded), so the component renders again with the current state, as fine-grained bindings do since #546. - fix(runtime): cleanup failures are no longer swallowed in production. When an update removes DOM or an app is cleaned up, a callback ref that throws on `null`, a listener that cannot be removed, a throwing component cleanup function (from a mount operation, task, or watch), or a failing root cleanup callback was logged with a development-only warning. Every cleanup step still runs, and the failures are now reported with `reportError()` in every build, queued until the current task finishes: one report per removed subtree (a single failure as-is, several as an `AggregateError`) and one per component. Error handlers run after the update, can update state, and cannot roll it back. `For` row disposal failures (previously a development-only `console.error`), provisional component cleanup failures during a failed render (previously dropped), and an async mount cleanup that resolves after unmount (previously `console.error`) are reported the same way. A throwing ref is no longer called with `null` twice. With `cleanupStrict: true`, `cleanupApp()` now throws the failures of descendant refs, listeners, and components, including components rendered inside `For`, `Show`, and `Case`, instead of dropping them. In hosts without `reportError()`, such as jsdom and Node under Vitest, the failures surface as unhandled errors; stub `globalThis.reportError` in tests that throw from cleanup on purpose. - breaking(data): `dehydrateDataRuntime()` now throws a `TypeError` naming the query key and property path when cached query data is not JSON transport-safe (a `Date`, `Map`, `Set`, class instance, bigint, non-finite number, `undefined`, accessor, or cyclic value). It was documented as dropping non-serializable values, and in practice let `JSON.stringify()` turn a `Date` into a string and a `Map` into `{}`. Query data now follows the same transport rules as route hydration data. An SSR-mode `prefetchQuery()` applies them as each value arrives and `renderRouteRequest()` checks the data runtime before returning a streamed result, so the render fails before a shell is sent. The shared validator walks iteratively, so deeply nested data no longer overflows the stack, and a fulfilled deferred that contains itself is reported as cyclic. - breaking(actions): a failed `action().submit()` now always rejects with an `Error` whose message carries the HTTP status (`Action failed (403): ...`), including non-JSON bodies on any status. The server value (the envelope `error`, or the body itself such as an RFC 7807 problem, whose `detail` or `title` is used for the message) is kept as `cause`. It used to throw the raw envelope `error` value, and a non-JSON body surfaced as a JSON `SyntaxError` that hid the status. 422 validation replays keep their `ActionValidationError` shape, and a bodiless success (204, 205, or an empty 2xx body) resolves with `undefined` and still runs declared invalidations. - fix(ssr): dehydrated query data now travels in a separate `queries` record of the hydration payload instead of the `resources` record, so a query key such as `r:0` no longer replaces resource slot data and resource slots are no longer hydrated into the client data runtime. HTML rendered before this change carries query data under `resources`; a new client bundle hydrating such HTML fetches that query data again instead of reusing it. - fix(data): concurrent `prefetchQuery()` calls for the same key and runtime share one in-flight fetch. A joiner still rejects promptly with its own `signal.reason`, and starts a replacement fetch as soon as the starting context aborts. An `invalidate()` covering the key detaches the fetch: later prefetches fetch again, and no caller of the detached fetch stores its pre-invalidation result. - perf(data): invalidation skips invalidation-listener dispatch entirely when no listener is registered (listeners come only from `createInvalidationRecorder()`). - fix(runtime): cleanup failures are no longer swallowed in production. When an update removes DOM or an app is cleaned up, a callback ref that throws on `null`, a listener that cannot be removed, a throwing component cleanup function (from a mount operation, task, or watch), or a failing root cleanup callback was logged with a development-only warning. Every cleanup step still runs, and the failures are now reported with `reportError()` in every build, queued until the current task finishes: one report per removed DOM node, one per component tree disposed together, and one per update for work that runs after the update commits (a single failure as-is, several as an `AggregateError`). Error handlers run after the update, can update state, and cannot roll it back. `For` row disposal failures (previously a development-only `console.error`), provisional component cleanup failures during a failed render (previously dropped), an async mount cleanup that resolves after unmount, cleanup of the previous route after navigation, and mount or commit operations that throw after an update commits (all previously `console.error`) are reported the same way. A throwing ref is no longer called with `null` twice. With `cleanupStrict: true`, `cleanupApp()` now throws the failures of descendant refs, listeners, and components, including components rendered inside `For`, `Show`, and `Case` at any depth and after re-renders, instead of dropping them; failures during ordinary updates of a strict app are reported. A cleanup failure during server rendering is thrown from the render call. In hosts without `reportError()`, such as jsdom and Node under Vitest, reported failures surface as unhandled errors; stub `globalThis.reportError` in tests that throw from cleanup on purpose. - fix(hydration): markup verification (`hydrate: { verifyMarkup }`, on by default outside production) now also compares the server HTML with the DOM the client renderer produces while hydrating it, so SSR/client renderer divergences such as a function child the server rendered empty throw `Hydration mismatch detected` instead of passing a server-against-server comparison. Both comparisons normalize through the DOM and compare `style` attributes by their parsed declarations, so the SSR `color:red;` and the DOM's `color: red;` are equal. The client check is skipped for static pages hydrated at a client-only query or hash and for pages with server-rendered portal content. A mount failure under `hydrate: { deferUntilIdle: true }` now rejects `hydrateSPA()` instead of leaving it pending. - fix(runtime): an `ErrorBoundary` fallback now removes the portal content its failed subtree wrote. A component that rendered no DOM of its own (such as a writer that returns only ``) shared the boundary's host node and survived the fallback, so its `Portal` content stayed in the host, still mounted, and its cleanups never ran. The fallback now disposes every component inside the boundary. This applies to render, function-valued prop and control-flow errors, and `reset()`/`resetKey` recovery writes the portal again. An explicit `DefaultPortal` host replaced by a fallback (directly, or inside a component or `Show`/`For`/`Case`) keeps the portal claimed, so its content does not move to the automatic host. During SSR and SSG, portal writes made by a subtree whose boundary renders its fallback are discarded instead of being emitted. - fix(events): delegated handlers on app nodes inside an open shadow root attached within an app's tree now run, once and in native bubbling order, with `stopPropagation()` respected and `event.target` set to the real target inside the shadow tree (retargeted to the host outside it). Dispatch follows `composedPath()` up to the app root, falling back to the target's ancestry when a host's composed path skips ancestors. `change` and `submit`, which are not composed and never leave a shadow root, are no longer delegated and attach directly to their element, so `onChange` and `onSubmit` run inside open and closed shadow roots; each element with one of these handlers now carries its own native listener. Delegated handlers inside closed shadow roots, and delegated event types dispatched with `composed: false` inside a shadow root, still do not run; mount an app inside the shadow root instead. - fix(state): a `derive()` or `selector()` owned by a component whose ancestor is queued to re-render (including a portal writer) or whose `` is about to reconcile (including through a `derive()`/`selector()` chain feeding `each`) is no longer evaluated in the derived lane with the component's stale props. It waits for that render, so a list row being removed no longer runs (and throws from) a derive that indexes by its old prop; a surviving component still gets the updated value in the same flush. - fix(router): navigation edge cases. `navigate()` and guard redirects to another origin now load that URL with `location.assign()` (or `replace()`) instead of rendering its path in-app. A hash that is not valid percent-encoding (`#%E0`) no longer throws after the history entry was written. `` is handled by the router. String targets for `navigate()`, `` and `redirect()` are always logical below a registry `basePath`: `/app/settings` under `/app` now goes to `/app/app/settings` instead of being treated as already mounted, and development builds warn about such strings. `navigate()`, `redirect()`, `loginPath` and `authenticatedRedirectTo` accept a typed destination from `to()`, whose public href is used as-is; `RouteDestination` is branded so only `to()` creates one. Only targets with an explicit `http:`/`https:` scheme may leave the origin: path-like strings that resolve to another host (`//evil.example`, `/\evil.example`) throw a `TypeError`, on the client, in server redirect decisions, for `loginPath` and at `` render. A redirect to another origin during the first load is handed to the browser instead of rendering its path locally, and an absolute `loginPath` on another origin keeps its origin when `next` is appended. Same-origin paths whose dot segments collapse to a leading `//` (`/.//evil.example`) are refused too, and history writes and document loads receive absolute URLs. `history.pushState()`/`replaceState()` calls from `navigate()`, ``, redirects and `updateRouteQuery()` now pass an absolute same-origin URL (`https://site.example/page`) instead of a root-relative one, so code that wraps or spies on them sees the full URL. Enhanced action redirects are checked the same way and assigned as absolute URLs. - fix(resources): a synchronous `task()` registers its cleanup as it runs instead of one microtask later, so removing its owner right after mount (for example a function child remounting when its hooks change) runs the cleanup before the replacement's task. A task that throws still reports the error as before. - fix(ssr): function children and props, and `state`/`derive` cells passed as children or props, now render their current value on the server instead of nothing (children) or the function's source text (props). Each is called once, untracked, and escaped like a static value, so the server markup matches the client and hydration adopts it in place. On both server and client, a function child that returns a `state`/`derive` cell renders that cell's value (and the client follows it); any other function in a function child's result renders nothing. A component that returns a function or a cell itself renders nothing, but function and cell items in the fragment or array a component returns (for example a layout that renders `<>{props.children}`), and a function child of `ErrorBoundary`, now render reactively on the client as they do on the server; the client dropped them. `ErrorBoundary` no longer wraps text or fragment content in a `
` on the client. A function child may use hooks (`state()`, `resource()`, `task()`, `watch()`), `Show`/`For`/`Case` and `readScope()` in every position, on both sides. The server renders each one as a `FunctionChild` component; on the server these threw. On the client, an element's function child that only reads values stays a direct DOM binding, and upgrades in place to a mounted `FunctionChild` component the first time a run asks for a component (code before the first hook then runs again); a function child whose hooks change between runs remounts with fresh state rather than reporting a hook-order error. Before, hooks there rendered nothing, resources never resolved, and `readScope()` could read the wrong provider. A function child of `Portal` now renders on the client. Parent re-renders no longer remove the text of an element's function child when the element is a component's root (`
{() => o()}
`), also with element siblings. Hydrating an element returned by a function child now sets up that element's own function children instead of clearing them. A function child that throws on the client now goes to the nearest `ErrorBoundary`, or is thrown from the update without one, like a reactive prop; it was logged and swallowed, leaving the element empty, while the server rendered the boundary's fallback. - fix(renderer): a child list that starts with an item that renders nothing (a plain object, a function, `true`) no longer duplicates the following text or elements when it updates existing nodes, such as server markup being hydrated (#544). - fix(ssr): `renderResolvedToStringSync()` no longer throws "no route found" for a route without params when `params` is omitted. - fix(renderer): a component returning a fragment or array now retains its child components when it re-renders with new props. Matching children keep their state and DOM identity, including after hydration; nested fragments reconcile against the same flattened child list used at creation. - fix(control): existing `For` rows now render with the latest row callback. A value the parent computed during render and captured in the callback (for example `const current = selected()`) kept its first value in rows that were already mounted. When the parent rerenders with a new callback, retained rows rerun with it and keep their DOM, key, and local state; a stable callback still skips them. A row that reruns on its own, because it read a reactive value, now keeps its key: a component in that row previously lost its local state when the row rendered again in the same flush. The docs now also state that a reactive read inside the callback subscribes the row that made it (they previously said it did not subscribe). See docs/guides/control-flow.md. - fix(renderer): a failed keyed reconciliation commit now propagates to the component update, which rolls the DOM back and routes the error to the nearest `ErrorBoundary` (or throws it from the flush). Previously any commit error was swallowed and the parent was rebuilt with `replaceChildren()`, which also tore down children that were being reused. Errors from grouped blueprint bindings (the second and later instances of a component or `For` row) and from reactive child functions (`{() => ...}`) now reach the nearest `ErrorBoundary` like single reactive props, or are thrown from the update when there is none, instead of a development-only warning. A reactive child update that fails while changing the element's children is rolled back instead of left half-applied. - fix(fx): errors thrown by `scheduleTimeout`/`scheduleIdle` callbacks, by handlers run later by `debounceEvent`/`throttleEvent`/`rafEvent`, and by `scheduleRetry` (a synchronous throw, the last attempt's rejection, or a throwing `backoff`) are reported with `reportError()` like event handler errors, instead of only being logged. - build(deps): `@askrjs/auth` and `@askrjs/schema` are now optional peer dependencies instead of dependencies, so apps that do not use route auth or schemas no longer install auth's SAML/XML stack. Askr uses them for types only: route requirements are composed by Askr itself, and the published declarations typecheck without either package installed. Apps that use `@askrjs/auth` or `@askrjs/schema` must list them in their own dependencies. - fix(ssg): the `@askrjs/askr/ssg` declarations no longer contain a stray `import 'node:fs/promises'`, so consumers without `@types/node` typecheck. - test(test-utils): `npm run typecheck` (and so `npm run lint`) now also typechecks `test-utils/**`, including the Playwright browser app, through `test-utils/tsconfig.json`. The existing type errors are fixed: fixtures import `state` from the root entry, the playwright app's Vite config uses `oxc.jsx`, and two scenarios no longer rely on unsafe nullable state reads. - test(benches): `npm run typecheck` also typechecks `benches/`. Bench fixtures now use `htmlFor`, a numeric `tabIndex`, `RouteHandler` route handlers and a complete auth context, matching the public types. - perf(env): development/production checks and renderer debug-flag reads no longer copy `process.env` on every call. `isProductionEnvironment()` runs on every component render, and enumerating the environment is expensive on Windows, where it dominated deep component trees (a 10,000-deep chain took ~60s in jsdom on Windows CI; it now mounts in ~0.1s locally, down from ~2.9s). - test: scheduler tests now exercise the behaviour their names describe (render-time writes, nested handlers, `scheduleEventHandler` deferral, mid-flush lane order, the render-time write guard error), the runtime and native owner-view consumer contracts assert observable behaviour instead of private fields, and the browser form tests wait on the pending render instead of wall-clock timing. - fix(ssr): `renderRouteRequest()` streams each deferred `Resolve` boundary as soon as its value settles instead of awaiting boundaries one at a time in declaration order, so a slow boundary no longer holds back faster ones. Patches can arrive out of order; boundary ids stay deterministic. A `Resolve` rendered inside a settled boundary's content now streams too (id `d:0.0` under `d:0`) with the same request route state and auth, where its fallback was previously never replaced. - fix(renderer): a failed render no longer leaves fine-grained bindings (function-valued props and children) stale. A binding whose function the render replaced kept the new value after the DOM rolled back, so later renders saw nothing to change, and an update the binding was due to run in the same flush was dropped. Bindings now roll back with the render and then catch up with their state; see "Fine-grained bindings and rollback" in docs/core/rendering.md. - fix(control): development and production now agree on invalid `For` keys and `Case`/`Match` children. A null, undefined, or duplicate `For` key throws in every build (production previously dropped rows and showed the last duplicate's data), and a non-`Match` child of `Case` or a `Match` outside a `Case` throws in every build (production previously dropped it). These errors reach the nearest `ErrorBoundary`, including a duplicate key introduced by a boundary-local list update, a list inside a `Show`/`Case` branch, and an invalid `Case` child, which previously escaped the boundary. Component errors rendered inside a `For`/`Show`/`Case` created above an `ErrorBoundary` now reach that boundary too. `For` resolves each row key once per update, and the development-only key-type-change check (which could never fire) is removed. - fix(renderer): props whose live state is not the attribute now set the DOM property. `