@symbo.ls/fetch 3.14.664 → 3.14.666

package/index.js

@@ -3,6 +3,7 @@
 import { isArray, isFunction, isObject, isString, exec } from '@symbo.ls/utils'
 import { createEffect } from '@symbo.ls/signal'
 import { dropEarly } from './early.js'
+import * as restAdapter from './adapters/rest.js'
 
 // --- Adapter resolution ---
 
@@ -32,8 +33,24 @@ const ADAPTER_METHODS = ['select', 'rpc', 'insert', 'update', 'upsert', 'delete'
 // declaration silently dies (SMBLS-FETCH-RESOLVEDB-EMPTY-RESULT-1).
 // Keeping these local is safe because every copy of this file ships
 // its own adapters/ chunks; the imports always resolve in-bundle.
+//
+// The REST adapter ships WITH the plugin, not as a lazy file: an app with
+// `fetch` reads its first data through it, and as a file of its own it was
+// the third load in a row before that first read — in smbls/core's split
+// build: the plugin (7.8 KB gzip), then the early/in-flight code the plugin
+// shared with the adapter (1.5 KB), then the adapter (2.7 KB) on the first
+// resolveDb. Static here, the three are one file.
+//
+// `local` stays a lazy file: an app that never configures it never loads it.
+// That is also why every microtask in this module is queued with
+// queueMicrotask, never `Promise.resolve().then(fn)`: parcel 2 (the bundler
+// `smbls build` runs) rewrites the first such call after an `import()` in a
+// file into `Promise.resolve().then(() => <that import>).then(fn)`, and this
+// `import()` comes first in the file. The `on: 'stateChange'` run loaded the
+// local adapter that way on XMA's first "Show more" click (xma.info,
+// 2026-10-16). __tests__/localAdapterStaysLazy.test.js holds the rule.
 const BUILTIN_ADAPTERS = {
-  rest: () => import('./adapters/rest.js'),
+  rest: () => Promise.resolve(restAdapter),
   local: () => import('./adapters/local.js')
 }
 
@@ -195,20 +212,81 @@ const parseDuration = (val) => {
   return 0
 }
 
-// --- Query cache ---
+// --- Server renders ---
+//
+// A context that sets `isolateFetchCache` is one server render:
+// @symbo.ls/brender sets it on every render, and no browser host sets it.
+// Such a context has a query store of its own (Query stores) and binds no
+// browser-only refetch (executeFetch). Window focus, reconnect and
+// `refetchInterval` keep a live page's data fresh; a server render is markup
+// once it ends, and its tree is never disposed, so what a query bound there
+// stayed for the life of the process: a focus / online callback per query
+// element in the module-level listener sets (about 2.5 MB of tree per render
+// kept alive), and an interval that kept firing — with
+// `refetchIntervalInBackground` it asked the tenant's database again every
+// period, and a request that landed during the NEXT render was recorded in
+// that render's fetch seed (brender records the GETs made while it renders),
+// so one tenant's page carried another's rows.
+const isServerRender = (context) => !!context && !!context.isolateFetchCache
+
+// --- Query stores ---
+//
+// A store is one query cache: its entries, the requests in flight (the
+// dedup), the invalidation marks and the mounted queries. A browser page has
+// one, the module's (`pageStore`), shared by every context that does not set
+// `isolateFetchCache` — the cache works as it always has, and `queryClient`
+// is its handle.
+//
+// A context that sets `isolateFetchCache` has a store of its own, made on its
+// first use and dropped with the context. @symbo.ls/brender sets it on every
+// server render. A server renders page after page, and project after
+// project, through ONE module instance of this plugin (`smbls build`, a
+// worker isolate, a host rendering several tenants), and a key carries no
+// project identity (`posts:select:""`). With one store, a page answered from
+// the rows an earlier page left made no request, so its fetch seed (recorded
+// from requests) did not carry them (xma.info, 2026-10-16); and two renders
+// of different projects read each other's rows — a render that overlapped
+// another joined its request in flight (its own database never asked), a
+// reply that landed after the other render's newer one took that render's
+// rows, a finished render's late reply served the next render's later
+// mounts, and one render's first query wiped the other's cache, mounted
+// queries and project-code writes. 3.14.665 emptied the one store when a new
+// render ran its first query, which only covered renders that never overlap.
+// Keyed by the context object, a render's store is reached only through its
+// own elements (runFetch, executeFetch, the project functions) and through
+// prefetchQuery given its context: every render starts empty and makes its
+// own requests, and nothing of one render is visible to another, at any
+// timing. The flag travels on the context, so the copy of this plugin that
+// runs the render — the one inside a server bundle — keeps the store; nothing
+// from outside that copy has to reach it.
+const createStore = () => ({
+  cache: new Map(), // key -> entry
+  subscribers: new Map(), // key -> Set of callbacks
+  active: new Map(), // key -> in-flight promise (dedup)
+  invalidatedAt: new Map(), // key -> seq of the key's last invalidation or removal
+  mounted: new Set() // the queries on screen (see Mounted queries)
+})
+
+const pageStore = createStore()
+const renderStores = new WeakMap() // isolating context -> its store
+
+const storeOf = (context) => {
+  if (!isServerRender(context)) return pageStore
+  let store = renderStores.get(context)
+  if (!store) renderStores.set(context, (store = createStore()))
+  return store
+}
 
-const cacheStore = new Map()
-const querySubscribers = new Map() // key -> Set of elements
-const activeQueries = new Map() // key -> Promise (deduplication)
+// --- Query cache ---
 
 // Request order. Every request a query sends, every cache write and every
 // invalidation takes the next number. A reply then knows whether it is older
 // than its key's last invalidation (its rows may predate the write: kept, but
 // never served as fresh) and whether a request that started after it has
 // already written its answer (that newer answer wins — a slow reply never
-// puts old rows back over it).
+// puts old rows back over it). One order for every store: a number is only
+// ever compared with numbers of the same store's keys.
 let fetchSeq = 0
-const invalidatedAt = new Map() // key -> seq of the key's last invalidation or removal
 const requestSeqs = new WeakMap() // in-flight promise -> seq of its request
 
 // The cache (and dedup) key of a query. runFetch writes its entry under it and
@@ -241,12 +319,12 @@ const queryCacheKey = (config, params, scope, lang, page = config.page, cursor =
   return `${from}:${method}:${scopeSeg}${JSON.stringify(params || '')}${infinite ? ':infinite' : ''}${pageSeg}${cursorSeg}${langSuffix}`
 }
 
-const getCacheEntry = (key) => cacheStore.get(key) || null
+const getCacheEntry = (store, key) => store.cache.get(key) || null
 
 // `seq` is the request the rows came from (a direct write — setQueryData,
 // initialData, a prefetch — is its own, current one); `stale` is set for rows
 // whose request started before the key's last invalidation.
-const setCacheEntry = (key, data, error, seq = ++fetchSeq, stale = false) => {
+const setCacheEntry = (store, key, data, error, seq = ++fetchSeq, stale = false) => {
   const entry = {
     data,
     error,
@@ -254,10 +332,10 @@ const setCacheEntry = (key, data, error, seq = ++fetchSeq, stale = false) => {
     stale,
     seq
   }
-  cacheStore.set(key, entry)
+  store.cache.set(key, entry)
 
   // Notify all subscribers of this query
-  const subs = querySubscribers.get(key)
+  const subs = store.subscribers.get(key)
   if (subs) {
     for (const sub of subs) {
       if (isFunction(sub)) sub(entry)
@@ -269,32 +347,33 @@ const setCacheEntry = (key, data, error, seq = ++fetchSeq, stale = false) => {
 
 // The entry a request that started after `seq` wrote (an error aside): the
 // newer answer, which an older reply must not replace.
-const newerEntry = (key, seq) => {
-  const entry = key ? cacheStore.get(key) : null
+const newerEntry = (store, key, seq) => {
+  const entry = key ? store.cache.get(key) : null
   return entry && !entry.error && entry.seq > seq ? entry : null
 }
 
 // A request that started before its key's last invalidation (or removal).
-const isOutdated = (key, seq) => (invalidatedAt.get(key) || 0) > seq
+const isOutdated = (store, key, seq) => (store.invalidatedAt.get(key) || 0) > seq
 
 // Every request on `key` that started before now is outdated from here on.
-const markInvalidated = (key) => { invalidatedAt.set(key, ++fetchSeq) }
+const markInvalidated = (store, key) => { store.invalidatedAt.set(key, ++fetchSeq) }
 
 // Removing an entry also marks its key, so a reply still in flight writes
 // its rows back as stale, never as fresh.
-const removeCache = (key) => {
-  cacheStore.delete(key)
-  markInvalidated(key)
+const removeCache = (store, key) => {
+  store.cache.delete(key)
+  markInvalidated(store, key)
 }
 
-const subscribeToCacheKey = (key, callback) => {
-  if (!querySubscribers.has(key)) querySubscribers.set(key, new Set())
-  querySubscribers.get(key).add(callback)
+const subscribeToCacheKey = (store, key, callback) => {
+  const { subscribers } = store
+  if (!subscribers.has(key)) subscribers.set(key, new Set())
+  subscribers.get(key).add(callback)
   return () => {
-    const subs = querySubscribers.get(key)
+    const subs = subscribers.get(key)
     if (subs) {
       subs.delete(callback)
-      if (subs.size === 0) querySubscribers.delete(key)
+      if (subs.size === 0) subscribers.delete(key)
     }
   }
 }
@@ -317,15 +396,14 @@ const parseCacheConfig = (cache) => {
 // --- Mounted queries ---
 //
 // The queries on screen: one record per element and `on: 'create'` query
-// config, registered by executeFetch. An invalidation refetches the ones whose
-// CURRENT key it selects (TanStack's "active" queries) instead of leaving them
-// on the old rows until their next mount or a window focus. The key is
-// computed when needed — the same resolution as the focus check — because
-// params, language and tenant scope can move after mount. A record whose
-// element was removed (`__ref` gone or replaced) is dropped whenever the
-// registry is walked: an invalidation, or the GC sweep.
-const mountedQueries = new Set()
-
+// config, registered by executeFetch in its context's store (`mounted`). An
+// invalidation refetches the ones whose CURRENT key it selects (TanStack's
+// "active" queries) instead of leaving them on the old rows until their next
+// mount or a window focus. The key is computed when needed — the same
+// resolution as the focus check — because params, language and tenant scope
+// can move after mount. A record whose element was removed (`__ref` gone or
+// replaced) is dropped whenever the registry is walked: an invalidation, or
+// the GC sweep.
 const isMounted = (record) => !!record.ref && record.element.__ref === record.ref
 
 const mountedKey = ({ config, element, context }) => {
@@ -337,6 +415,9 @@ const mountedKey = ({ config, element, context }) => {
 }
 
 // --- GC ---
+//
+// Sweeps the page store. A render's store is not swept: it goes with its
+// context.
 
 let gcTimer = null
 
@@ -344,20 +425,21 @@ const startGC = () => {
   if (gcTimer) return
   gcTimer = setInterval(() => {
     const now = Date.now()
-    for (const [key, entry] of cacheStore) {
-      const subs = querySubscribers.get(key)
+    const { cache, subscribers, active, invalidatedAt, mounted } = pageStore
+    for (const [key, entry] of cache) {
+      const subs = subscribers.get(key)
       const hasSubscribers = subs && subs.size > 0
       if (!hasSubscribers && (now - entry.time) > (entry.gcTime || 300000)) {
-        cacheStore.delete(key)
+        cache.delete(key)
       }
     }
     // What nothing can need any more: an invalidation mark matters while its
     // key has rows or a request out, and a removed element is not mounted.
     for (const [key] of invalidatedAt) {
-      if (!cacheStore.has(key) && !activeQueries.has(key)) invalidatedAt.delete(key)
+      if (!cache.has(key) && !active.has(key)) invalidatedAt.delete(key)
     }
-    for (const record of mountedQueries) {
-      if (!isMounted(record)) mountedQueries.delete(record)
+    for (const record of mounted) {
+      if (!isMounted(record)) mounted.delete(record)
     }
   }, 30000)
   if (gcTimer.unref) gcTimer.unref()
@@ -493,10 +575,12 @@ const resolveLanguage = (element, context) => {
 // state — `root.__fetchScope` — so the SAME (from, method, params) tuple
 // yields DIFFERENT cache/dedup keys per tenant. Without it the cache is
 // tenant-blind: org A's cached `workspaceProject.people:list:""` entry (AND its
-// in-flight `activeQueries` promise) is served / dedup-collapsed for org B, so a
+// request in flight, the dedup) is served / dedup-collapsed for org B, so a
 // page mounted right after an org switch renders the previous tenant's rows.
 // Read generically (same pattern as resolveLanguage) so the plugin stays
 // app-agnostic — apps that never set it get byte-identical keys to before.
+// (Tenants in ONE page share its store, so they need a scope; separate server
+// renders have separate stores — see Query stores.)
 const resolveScope = (element, context) => {
   const root = element?.state?.root || context?.state?.root
   const scope = root?.__fetchScope
@@ -793,13 +877,15 @@ const runFetch = async (config, element, context, opts = {}) => {
   // tenant so an org/workspace switch never serves — or dedup-collapses into —
   // the previous tenant's entry, while keeping `from:method` as the key prefix.
   const cacheKey = cacheConfig ? queryCacheKey(config, params, scope, lang, pageValue, cursorValue) : null
+  // The store this run reads and writes: its context's (storeOf).
+  const store = storeOf(context)
 
   // Apply initial/placeholder data on first mount
   if (!ref.__fetchInitialized && cacheKey) {
     ref.__fetchInitialized = true
     if (initialData !== undefined) {
       const initData = isFunction(initialData) ? initialData() : initialData
-      setCacheEntry(cacheKey, initData, null)
+      setCacheEntry(store, cacheKey, initData, null)
     }
   }
 
@@ -810,7 +896,7 @@ const runFetch = async (config, element, context, opts = {}) => {
   // dedup, so while the entry was fresh every one of those answered from the
   // cache and sent nothing — a poll shorter than the stale time never polled.
   if ((method === 'select' || method === 'rpc') && cacheKey && cacheConfig && !opts.refresh && !opts.force) {
-    const cached = getCacheEntry(cacheKey)
+    const cached = getCacheEntry(store, cacheKey)
     if (cached && !cached.error) {
       const age = Date.now() - cached.time
       const isStale = cached.stale || age > (cacheConfig.staleTime || 0)
@@ -842,8 +928,8 @@ const runFetch = async (config, element, context, opts = {}) => {
   // Deduplication — if same query is already in-flight, share the promise (with
   // timeout). Never one that started before the key's last invalidation: its
   // reply may predate the write.
-  const existing = cacheKey && !opts.force ? activeQueries.get(cacheKey) : null
-  if (existing && !isOutdated(cacheKey, requestSeqs.get(existing) || 0)) {
+  const existing = cacheKey && !opts.force ? store.active.get(cacheKey) : null
+  if (existing && !isOutdated(store, cacheKey, requestSeqs.get(existing) || 0)) {
     // The shared request failed: so did this query, with the same error. It
     // used to read an error answer as null rows (onFetchComplete(null)) and a
     // thrown one as nothing at all.
@@ -855,7 +941,7 @@ const runFetch = async (config, element, context, opts = {}) => {
       } else if (result?.data !== undefined) {
         // A request that started later (an invalidation's refetch) may have
         // landed first: its rows are the newer answer.
-        const newer = !infinite && newerEntry(cacheKey, requestSeqs.get(existing) || 0)
+        const newer = !infinite && newerEntry(store, cacheKey, requestSeqs.get(existing) || 0)
         const finalData = shape(newer ? newer.data : result.data)
         if (!isCurrent()) return
         updateElementState(element, finalData, stateKey)
@@ -872,7 +958,7 @@ const runFetch = async (config, element, context, opts = {}) => {
   }
 
   // Set loading status
-  const isFirstLoad = !getCacheEntry(cacheKey)?.data
+  const isFirstLoad = !getCacheEntry(store, cacheKey)?.data
   setFetchStatus(element, {
     isFetching: true,
     isLoading: isFirstLoad,
@@ -998,14 +1084,14 @@ const runFetch = async (config, element, context, opts = {}) => {
   requestSeqs.set(fetchPromise, requestSeq)
 
   // Store for deduplication
-  if (cacheKey) activeQueries.set(cacheKey, fetchPromise)
+  if (cacheKey) store.active.set(cacheKey, fetchPromise)
 
   try {
     const result = await fetchPromise
     // An action's write happened whatever became of the element that fired
     // it (a dialog that closed on submit): its `invalidates` runs on success.
     if (action && config.invalidates && result && !result.error && !result.subscribed) {
-      runInvalidates(config.invalidates, from)
+      runInvalidates(store, config.invalidates, from)
     }
     if (!isCurrent()) return
     if (result?.subscribed) return
@@ -1014,7 +1100,7 @@ const runFetch = async (config, element, context, opts = {}) => {
 
     if (error) {
       // An older request's failure never replaces a newer answer.
-      if (cacheKey && !newerEntry(cacheKey, requestSeq)) setCacheEntry(cacheKey, null, error, requestSeq)
+      if (cacheKey && !newerEntry(store, cacheKey, requestSeq)) setCacheEntry(store, cacheKey, null, error, requestSeq)
       fail(error)
       if (_emitNet) _emitNet({
         phase: 'error', mode: 'query', from, method, cacheKey,
@@ -1031,12 +1117,12 @@ const runFetch = async (config, element, context, opts = {}) => {
         // A request that started later has written its newer rows already:
         // show those, leave the cache alone. (Not for an infinite query —
         // each of its replies is one page, not the whole answer.)
-        const newer = !infinite && newerEntry(cacheKey, requestSeq)
+        const newer = !infinite && newerEntry(store, cacheKey, requestSeq)
         if (newer) {
           rows = newer.data
         } else {
           // Invalidated while this request was out: kept, never served as fresh.
-          const entry = setCacheEntry(cacheKey, data, null, requestSeq, isOutdated(cacheKey, requestSeq))
+          const entry = setCacheEntry(store, cacheKey, data, null, requestSeq, isOutdated(store, cacheKey, requestSeq))
           entry.gcTime = cacheConfig?.gcTime || 300000
         }
       }
@@ -1089,7 +1175,7 @@ const runFetch = async (config, element, context, opts = {}) => {
     })
   } finally {
     // A forced refetch may have replaced this key while the old request ran.
-    if (cacheKey && activeQueries.get(cacheKey) === fetchPromise) activeQueries.delete(cacheKey)
+    if (cacheKey && store.active.get(cacheKey) === fetchPromise) store.active.delete(cacheKey)
   }
 }
 
@@ -1157,8 +1243,8 @@ const bindStateChange = (config, element, context, runner) => {
     if (inputs === last) return
     last = inputs
     // Outside the effect: the run reads state as well, and none of that may
-    // become the effect's dependency.
-    Promise.resolve().then(() => runner(config, element, context))
+    // become the effect's dependency. (queueMicrotask: see BUILTIN_ADAPTERS.)
+    queueMicrotask(() => runner(config, element, context))
   })
   if (Array.isArray(ref.__effects)) ref.__effects.push(effect)
   else ref.__fetchListeners.push(() => effect.dispose())
@@ -1198,7 +1284,7 @@ const bindAutoRefetch = (config, element, context) => {
   if (onFocusEnabled) {
     const onFocus = () => {
       const cacheKey = elementQueryKey(config, element, context)
-      const entry = getCacheEntry(cacheKey)
+      const entry = getCacheEntry(storeOf(context), cacheKey)
       const cacheConfig = parseCacheConfig(config.cache)
       if (!entry || entry.stale || (Date.now() - entry.time) > (cacheConfig?.staleTime || 0)) {
         runFetch(config, element, context, { force: true })
@@ -1281,15 +1367,15 @@ const keyMatcher = (match) => {
   return () => false
 }
 
-// Refetch the mounted queries whose current key `matches` selects. The first
-// on a key sends the request; the others on that key share it through the
-// dedup, which never shares a request that started before the key's
-// invalidation — so no one is handed the pre-write rows.
-const refreshMounted = (matches) => {
+// Refetch the mounted queries of `store` whose current key `matches` selects.
+// The first on a key sends the request; the others on that key share it
+// through the dedup, which never shares a request that started before the
+// key's invalidation — so no one is handed the pre-write rows.
+const refreshMounted = (store, matches) => {
   const runs = []
-  for (const record of mountedQueries) {
+  for (const record of store.mounted) {
     if (!isMounted(record)) {
-      mountedQueries.delete(record)
+      store.mounted.delete(record)
       continue
     }
     const key = mountedKey(record)
@@ -1298,47 +1384,56 @@ const refreshMounted = (matches) => {
   return Promise.allSettled(runs).then(() => {})
 }
 
-// Mark every key `matches` selects as invalidated — its cache entry stale, and
-// a first load still in flight outdated — then refetch the mounted queries on
-// those keys; resolves once those refetches settle. The answers the pre-boot
-// script asked for (early.js) are dropped as well: an invalidation means a
-// write happened, and they may predate it.
-const invalidateMatching = (matches) => {
+// Mark every key of `store` that `matches` selects as invalidated — its cache
+// entry stale, and a first load still in flight outdated — then refetch the
+// mounted queries on those keys; resolves once those refetches settle. The
+// answers the pre-boot script asked for (early.js) are dropped as well: an
+// invalidation means a write happened, and they may predate it.
+const invalidateMatching = (store, matches) => {
   dropEarly()
-  for (const [key, entry] of cacheStore) {
+  for (const [key, entry] of store.cache) {
     if (!matches(key)) continue
     entry.stale = true
-    markInvalidated(key)
+    markInvalidated(store, key)
   }
-  for (const [key] of activeQueries) {
-    if (!cacheStore.has(key) && matches(key)) markInvalidated(key)
+  for (const [key] of store.active) {
+    if (!store.cache.has(key) && matches(key)) markInvalidated(store, key)
   }
-  return refreshMounted(matches)
+  return refreshMounted(store, matches)
 }
 
 // A write's `invalidates`: `true` or '*' selects every query of the write's
 // own `from`; anything else — or each item of a list — is a match as
 // invalidateQueries takes it. (Whole keys only, before: the documented
 // `invalidates: ['posts']` matched no real key.)
-const runInvalidates = (invalidates, from) => {
+const runInvalidates = (store, invalidates, from) => {
   const matchers = (isArray(invalidates) ? invalidates : [invalidates]).map((match) => {
     if (match === true || match === '*') return (key) => key.startsWith(from + ':')
     return match ? keyMatcher(match) : () => false
   })
-  return invalidateMatching((key) => matchers.some((matches) => matches(key)))
+  return invalidateMatching(store, (key) => matchers.some((matches) => matches(key)))
 }
 
-const removeMatching = (matches) => {
-  for (const [key] of cacheStore) {
-    if (matches(key)) removeCache(key)
+const removeMatching = (store, matches) => {
+  for (const [key] of store.cache) {
+    if (matches(key)) removeCache(store, key)
   }
-  for (const [key] of activeQueries) {
-    if (matches(key)) markInvalidated(key)
+  for (const [key] of store.active) {
+    if (matches(key)) markInvalidated(store, key)
   }
 }
 
 const ALL_KEYS = () => true
 
+// What getQueryData / setQueryData do, on one store.
+const readQueryData = (store, key) => getCacheEntry(store, key)?.data ?? undefined
+
+const writeQueryData = (store, key, updater) => {
+  const existing = getCacheEntry(store, key)
+  const data = isFunction(updater) ? updater(existing?.data) : updater
+  setCacheEntry(store, key, data, null)
+}
+
 // --- Mutation runner (insert/update/delete with optimistic + invalidation) ---
 
 const runMutation = async (config, element, context) => {
@@ -1445,7 +1540,7 @@ const runMutation = async (config, element, context) => {
     })
 
     // Invalidate related queries — the mounted ones refetch now
-    if (invalidates) runInvalidates(invalidates, from)
+    if (invalidates) runInvalidates(storeOf(context), invalidates, from)
   } catch (e) {
     if (snapshot !== undefined) rollbackOptimistic(element, config)
     setFetchStatus(element, errorStatus(e))
@@ -1476,7 +1571,7 @@ const releaseFetch = (ref) => {
   for (const cleanup of ref.__fetchCleanups || []) release(cleanup)
   for (const cleanup of ref.__fetchListeners || []) release(cleanup)
   if (isFunction(ref.__unsubscribe)) release(ref.__unsubscribe)
-  for (const record of ref.__fetchMounted || []) mountedQueries.delete(record)
+  for (const record of ref.__fetchMounted || []) storeOf(record.context).mounted.delete(record)
   ref.__fetchCleanups = []
   ref.__fetchListeners = []
   ref.__unsubscribe = null
@@ -1495,11 +1590,13 @@ export const executeFetch = (param, element, state, context) => {
     ? fetchProp.map(c => resolveFetchConfig(exec(c, element), element)).filter(Boolean)
     : [resolveFetchConfig(fetchProp, element)].filter(Boolean)
 
-  // This element's mounted queries (refetched by an invalidation). A re-run
-  // replaces its configs, so it replaces their records too.
+  // This element's mounted queries (refetched by an invalidation), in its
+  // context's store. A re-run replaces its configs, so it replaces their
+  // records too.
   const ref = element.__ref
+  const store = storeOf(context)
   if (ref.__fetchMounted) {
-    for (const record of ref.__fetchMounted) mountedQueries.delete(record)
+    for (const record of ref.__fetchMounted) store.mounted.delete(record)
   }
   ref.__fetchMounted = []
 
@@ -1514,6 +1611,10 @@ export const executeFetch = (param, element, state, context) => {
     ref.__effects.push(ref.__fetchDisposer)
   }
 
+  // Window focus, reconnect and an interval refresh a live page; a server
+  // render binds none of them (isServerRender).
+  const browserRefetch = !isServerRender(context)
+
   for (const config of configs) {
     const isMutation = isMutationMethod(config.method)
     const runner = isMutation ? runMutation : runFetch
@@ -1525,20 +1626,19 @@ export const executeFetch = (param, element, state, context) => {
     if (config.on === 'create') {
       runner(config, element, context)
     } else {
-      Promise.resolve().then(() => {
-        bindEvent({ ...config, __runner: runner }, element, context)
-      })
+      // (queueMicrotask: see BUILTIN_ADAPTERS.)
+      queueMicrotask(() => bindEvent({ ...config, __runner: runner }, element, context))
     }
 
     // Bind auto-refetch for queries
     if (isQuery && config.on === 'create') {
-      if (config.refetchInterval || config.refetchOnWindowFocus !== false || config.refetchOnReconnect !== false) {
+      if (browserRefetch && (config.refetchInterval || config.refetchOnWindowFocus !== false || config.refetchOnReconnect !== false)) {
         bindAutoRefetch(config, element, context)
       }
       // A single-use body has no cache key to invalidate.
       if (!isSingleUse(config)) {
         const record = { element, ref, config, context }
-        mountedQueries.add(record)
+        store.mounted.add(record)
         ref.__fetchMounted.push(record)
       }
     }
@@ -1571,34 +1671,36 @@ export const executeFetch = (param, element, state, context) => {
 }
 
 // --- Query client (global cache management) ---
+//
+// The page store's handle (see Query stores): a browser page's cache. A
+// render context's store is reached through its own elements — the project
+// functions below, `el.call('invalidateQueries', …)` — and prefetchQuery,
+// which takes the context.
 
 export const queryClient = {
   // Marks every matching entry stale and refetches the mounted queries on
   // those keys; resolves once those refetches settle. `keyOrPattern`: nothing
   // (every key), a key prefix or substring, a list of key parts (joined with
   // ':'), a RegExp, or a predicate `(key) => boolean`.
-  invalidateQueries: (keyOrPattern) => invalidateMatching(keyMatcher(keyOrPattern)),
+  invalidateQueries: (keyOrPattern) => invalidateMatching(pageStore, keyMatcher(keyOrPattern)),
 
   // Drops every matching entry (same matches). A mounted query keeps the rows
   // it shows; the next mount loads them afresh.
   removeQueries: (keyOrPattern) => {
-    removeMatching(keyOrPattern ? keyMatcher(keyOrPattern) : ALL_KEYS)
+    removeMatching(pageStore, keyOrPattern ? keyMatcher(keyOrPattern) : ALL_KEYS)
   },
 
-  getQueryData: (key) => {
-    const entry = getCacheEntry(key)
-    return entry?.data ?? undefined
-  },
+  getQueryData: (key) => readQueryData(pageStore, key),
 
   setQueryData: (key, updater) => {
-    const existing = getCacheEntry(key)
-    const data = isFunction(updater) ? updater(existing?.data) : updater
-    setCacheEntry(key, data, null)
+    writeQueryData(pageStore, key, updater)
   },
 
+  // Into the store of `context` — a render context's own, else the page's.
   prefetchQuery: async (config, context) => {
     const db = context?.fetch
     if (!db) return
+    const store = storeOf(context)
 
     const adapter = await resolveAdapter(db, context)
     if (!adapter) return
@@ -1633,16 +1735,16 @@ export const queryClient = {
 
     // Ordered like a query's reply: never over newer rows, stale when the key
     // was invalidated while the prefetch was out.
-    if (result?.data !== undefined && !result?.error && !isSingleUse(config) && !newerEntry(cacheKey, requestSeq)) {
-      const entry = setCacheEntry(cacheKey, result.data, null, requestSeq, isOutdated(cacheKey, requestSeq))
+    if (result?.data !== undefined && !result?.error && !isSingleUse(config) && !newerEntry(store, cacheKey, requestSeq)) {
+      const entry = setCacheEntry(store, cacheKey, result.data, null, requestSeq, isOutdated(store, cacheKey, requestSeq))
       entry.gcTime = parseCacheConfig(config.cache)?.gcTime || 300000
     }
 
     return result
   },
 
-  getCache: () => cacheStore,
-  clear: () => removeMatching(ALL_KEYS),
+  getCache: () => pageStore.cache,
+  clear: () => removeMatching(pageStore, ALL_KEYS),
 
   // Drop every cache entry whose lang suffix isn't `keepLang`.
   // Cache keys are of the form `${from}:${method}:${params}[:lang]` — entries
@@ -1657,14 +1759,14 @@ export const queryClient = {
   dropNonLang: (keepLang) => {
     if (!keepLang) return
     const keepSuffix = `:${keepLang}`
-    for (const [key] of cacheStore) {
+    for (const [key] of pageStore.cache) {
       // Entry without any lang suffix: presence of `:` in middle but not
       // matching any 2-3 letter ISO suffix at the end. Conservative: keep
       // entries whose tail doesn't look like `:xx` or `:xxx`.
       const tailMatch = key.match(/:([a-z]{2,3})$/i)
       if (!tailMatch) continue              // no lang suffix → keep
       if (key.endsWith(keepSuffix)) continue // matches keepLang → keep
-      removeCache(key)
+      removeCache(pageStore, key)
     }
   }
 }
@@ -1684,11 +1786,15 @@ const keyFor = (keyOrConfig, element) => {
   return elementQueryKey({ method: 'select', ...keyOrConfig }, element, element?.context)
 }
 
+// Each works on the caller's store (storeOf its context), as a query does:
+// in a server render, the render's own — what its project code writes,
+// removes or invalidates stays in that render; in a browser page, the page
+// store, as queryClient.
 export const fetchFunctions = {
-  invalidateQueries (keyOrPattern) { return queryClient.invalidateQueries(keyOrPattern) },
-  removeQueries (keyOrPattern) { return queryClient.removeQueries(keyOrPattern) },
-  getQueryData (keyOrConfig) { return queryClient.getQueryData(keyFor(keyOrConfig, this)) },
-  setQueryData (keyOrConfig, updater) { return queryClient.setQueryData(keyFor(keyOrConfig, this), updater) }
+  invalidateQueries (keyOrPattern) { return invalidateMatching(storeOf(this?.context), keyMatcher(keyOrPattern)) },
+  removeQueries (keyOrPattern) { removeMatching(storeOf(this?.context), keyOrPattern ? keyMatcher(keyOrPattern) : ALL_KEYS) },
+  getQueryData (keyOrConfig) { return readQueryData(storeOf(this?.context), keyFor(keyOrConfig, this)) },
+  setQueryData (keyOrConfig, updater) { writeQueryData(storeOf(this?.context), keyFor(keyOrConfig, this), updater) }
 }
 
 // --- Plugin interface ---
@@ -1714,11 +1820,12 @@ export const fetchPlugin = {
     const fetchProp = element.fetch
     if (!fetchProp) return
     // Clear stale in-flight queries on root element creation
-    if (!element.parent) activeQueries.clear()
+    if (!element.parent) storeOf(element.context).active.clear()
     executeFetch(fetchProp, element, element.state, element.context)
   }
 }
 
 export { parseDuration }
-export { earlyKey, EARLY_KEY, createEarlySeedScript } from './early.js'
+export { earlyKey, EARLY_KEY, createEarlySeedScript, createEarlySeedBlock, SEED_BLOCK } from './early.js'
+export { requestsInFlight, whenRequestsIdle } from './inflight.js'
 export default executeFetch