git:20260814.105372d to git:20260815.a3eff3a

+ | `router-client.js` | Turbo Drive–style client router; entry: `enableClientRouter` / `navigate`. Also exports `refreshPage(mode)` (#1398): re-render the CURRENT url on the server and apply it in place, recording no history entry and never scrolling, so the reader keeps their place and Back still goes to the previous page. `'page'` (the default) morphs the deepest shared boundary, so the outer layout's DOM and the hydrated state of its components survive; `'shell'` takes the full-body tier (`swapFullBody`, extracted from `applySwap`'s tail so the background snapshot-restore path and this share one implementation) because a LAYOUT's own markup lives outside every children range and a boundary morph would leave it untouched. It SUPPRESSES `X-Webjs-Have`, which is required rather than an optimisation: the server short-circuits at the first layout whose segment path and route key the client already holds, and a same-URL request matches every one of them, so the response would omit the layouts and a layout edit would be invisible. It also suppresses the outgoing snapshot (it would write the pre-edit page under the url being refreshed, and a later Back would restore it), the optimistic `loading.ts` skeleton (flashing one over content that is already correct is worse than one round trip of stale content), and the prefetch fast path (every cached copy predates the change). It does NOT reload changed component modules and cannot, since `customElements.define` is once-per-tag and a module URL is fetched once per document. `enableClientRouter` publishes it as `globalThis.__webjsRefreshPage` and `disableClientRouter` deletes it, which is how the dev live-reload client (a separate served script with no import of this module) feature-DETECTS it: the global's absence covers both `webjs.clientRouter: false` and a page that ships no component at all, and both fall back to a full reload. The speculative prefetch cache carries a FRAME dimension (#1407): a trigger resolves `resolveTargetFrameId` at fire time, `prefetch(href, frameId)` sends `x-webjs-frame` so the warm body is the subtree the click needs, and `cacheKey(url, frameId)` keys the entry by both so a page fragment and a frame subtree for one url can coexist and can never substitute for each other. `prefetchTake` validates a frame entry by `liveFrameElement(entry.frameId)` rather than by `prefetchAnchor` (a subtree carries no `wj:children` marker, and a null anchor means "no constraint" on the page path, so falling through would consume it anywhere), and `prefetch` refuses to store a response whose `x-webjs-frame` marker does not match what it asked for, which is how the server's two full-document fall-throughs (a streamed render, an absent id) are kept out of the frame key; the refusal is recorded in `prefetchRefused`, a small TTL-bounded memo held OUTSIDE `prefetchCache` (it carries no fragment, so filing it in the capped cache would let a streaming route's framed links squat slots that consumable fragments compete for) which stops the request being re-issued on every hover, and which a detected deploy or an in-place `refreshPage` clears (never `revalidate`, the post-mutation api: clearing there would drop every memo on every write, and while a mutation CAN change a render's streamed shape via a conditional `Suspense`, a stale memo costs only one skipped warm-up per key until the TTL). Also exports `loadFrame(frameEl, url)` (#253), the reusable frame self-load `webjs-frame.js` calls: it fetches `url` as a frame nav (the `x-webjs-frame` header) and applies the matched subtree through the SAME `fetchAndApply` frame-swap path a click uses (no history push / snapshot / optimistic skeleton, since it swaps one region, and no prefetch fast path either: it EVICTS the warm entry for that url in its frame dimension and passes `noPrefetch` so it cannot consume one, #1407, because a `src` self-load is a freshness request; refusing without evicting would leave a copy the load has just superseded). Post-swap activation of a boundary range goes through `activateSwappedRange` (#1102), the ONE place both tiers (`replaceBoundaryRange`, `swapMarkerRange`) reactivate scripts and upgrade custom elements. Two things it owns and a new call site must keep: it SNAPSHOTS the range before iterating, because `reactivateScripts` replaces a top-level script and a detached node cuts a live `nextSibling` walk (every later node in the range is then silently skipped); and `reactivateScripts` handles container-IS-a-script itself, since `querySelectorAll` never matches the node it is called on. A top-level script therefore re-executes on every swap of its range, INCLUDING one the keyed differ reused by `id`, matching what a descendant script in a reused container has always done. `data-webjs-permanent` splits into two cases and they must NOT be unified (#1252). The marked element IS a script: NEVER exempt, whether the walk reaches it as the container or as a descendant of one (the regraft selector has no tag filter, so a marked script IS preserved by identity and does land in the WeakSet, which is why the exemption is STRICT containment and never reflexive). The regraft also has a both-exist guard, so on the swap that first mounts a route there is no live node to preserve and exempting the inert parsed copy would leave a script that runs on a cold load and never on a soft nav, which is #1102 itself. Script INSIDE a preserved marked element: exempt, because the attribute is subtree-scoped (`diffElementInPlace` already returns early rather than recursing into one) and re-emitting an init script against an instance the author kept alive is a double-initialization. The filter keys on the `regraftedPermanents` WeakSet, which the two regrafts populate on every successful path, so it means ACTUALLY preserved by identity rather than merely carrying the attribute; an attribute-only filter would leave a first-mount permanent element's scripts never running at all |