@symbo.ls/fetch 3.14.663 → 3.14.665

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')
 }
 
@@ -277,17 +294,14 @@ const newerEntry = (key, seq) => {
 // A request that started before its key's last invalidation (or removal).
 const isOutdated = (key, seq) => (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) }
+
 // 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) => {
-  if (key) {
-    cacheStore.delete(key)
-    invalidatedAt.set(key, ++fetchSeq)
-    return
-  }
-  for (const [cacheKey] of cacheStore) invalidatedAt.set(cacheKey, ++fetchSeq)
-  for (const [inFlightKey] of activeQueries) invalidatedAt.set(inFlightKey, ++fetchSeq)
-  cacheStore.clear()
+  cacheStore.delete(key)
+  markInvalidated(key)
 }
 
 const subscribeToCacheKey = (key, callback) => {
@@ -671,6 +685,10 @@ const updateElementState = (element, data, stateKey, options = {}) => {
   }
 }
 
+// The settled statuses (setFetchStatus copies, so one object serves every write).
+const SUCCESS = Object.freeze({ isFetching: false, isLoading: false, isStale: false, isSuccess: true, error: null, status: 'success', fetchStatus: 'idle' })
+const errorStatus = (error) => ({ isFetching: false, isLoading: false, isStale: false, isSuccess: false, error, status: 'error', fetchStatus: 'idle' })
+
 const setFetchStatus = (element, status) => {
   // Element may have been torn down (route change, modal close, parent
   // unmount) between the runFetch entry guard and this call site —
@@ -754,6 +772,20 @@ const runFetch = async (config, element, context, opts = {}) => {
     keepPreviousData
   } = config
 
+  // The rows as the element gets them: `select` (a function) then `transform`.
+  const shape = (data) => {
+    if (isFunction(selectTransform)) data = selectTransform(data, element, element.state)
+    if (transform) data = transform(data, element, element.state)
+    return data
+  }
+  // This query failed: its status, then the element's and the config's
+  // onFetchError.
+  const fail = (error) => {
+    setFetchStatus(element, errorStatus(error))
+    triggerCallback(element, 'onFetchError', error)
+    triggerConfigCallback(config, element, 'onFetchError', error)
+  }
+
   let select = isString(selectTransform) ? selectTransform : undefined
   if (query && isFunction(element.getQuery)) {
     const q = element.getQuery(adapter.name || 'paths')
@@ -805,14 +837,12 @@ const runFetch = async (config, element, context, opts = {}) => {
         ref.__pages = [cached.data]
         setPageCursors(ref, config, cached.data)
       }
-      let data = cached.data
-      if (isFunction(selectTransform)) data = selectTransform(data, element, element.state)
-      if (transform) data = transform(data, element, element.state)
+      const data = shape(cached.data)
       if (!isCurrent()) return
       // The status first: the state update re-renders, and a render that
       // reads `__fetchStatus` must see the answer it renders (report #25).
       if (!isStale) {
-        setFetchStatus(element, { isFetching: false, isLoading: false, isStale: false, isSuccess: true, error: null, status: 'success', fetchStatus: 'idle' })
+        setFetchStatus(element, SUCCESS)
         updateElementState(element, data, stateKey)
         return
       }
@@ -834,11 +864,6 @@ const runFetch = async (config, element, context, opts = {}) => {
     // 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.
-    const fail = (error) => {
-      setFetchStatus(element, { isFetching: false, isLoading: false, isStale: false, isSuccess: false, error, status: 'error', fetchStatus: 'idle' })
-      triggerCallback(element, 'onFetchError', error)
-      triggerConfigCallback(config, element, 'onFetchError', error)
-    }
     try {
       const result = await Promise.race([existing, new Promise((_, r) => setTimeout(() => r('DEDUP_TIMEOUT'), 15000))])
       if (!isCurrent()) return
@@ -848,9 +873,7 @@ const runFetch = async (config, element, context, opts = {}) => {
         // 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)
-        let finalData = newer ? newer.data : result.data
-        if (isFunction(selectTransform)) finalData = selectTransform(finalData, element, element.state)
-        if (transform) finalData = transform(finalData, element, element.state)
+        const finalData = shape(newer ? newer.data : result.data)
         if (!isCurrent()) return
         updateElementState(element, finalData, stateKey)
         triggerCallback(element, 'onFetchComplete', finalData)
@@ -891,9 +914,7 @@ const runFetch = async (config, element, context, opts = {}) => {
       if (!isCurrent()) return
       if (auth === true && !session) {
         const err = { message: 'Not authenticated' }
-        setFetchStatus(element, { isFetching: false, isLoading: false, isStale: false, isSuccess: false, error: err, status: 'error', fetchStatus: 'idle' })
-        triggerCallback(element, 'onFetchError', err)
-        triggerConfigCallback(config, element, 'onFetchError', err)
+        fail(err)
         return { data: null, error: err }
       }
     }
@@ -1011,9 +1032,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)
-      setFetchStatus(element, { isFetching: false, isLoading: false, isStale: false, isSuccess: false, error, status: 'error', fetchStatus: 'idle' })
-      triggerCallback(element, 'onFetchError', error)
-      triggerConfigCallback(config, element, 'onFetchError', error)
+      fail(error)
       if (_emitNet) _emitNet({
         phase: 'error', mode: 'query', from, method, cacheKey,
         error: error.message || error,
@@ -1057,14 +1076,13 @@ const runFetch = async (config, element, context, opts = {}) => {
         setPageCursors(ref, config, data)
       }
 
-      if (isFunction(selectTransform)) finalData = selectTransform(finalData, element, element.state)
-      if (transform) finalData = transform(finalData, element, element.state)
+      finalData = shape(finalData)
       if (!isCurrent()) return
 
       // The status first: the state update re-renders, and a render that
       // reads `__fetchStatus` saw the request still pending beside its own
       // rows (report #25).
-      setFetchStatus(element, { isFetching: false, isLoading: false, isStale: false, isSuccess: true, error: null, status: 'success', fetchStatus: 'idle' })
+      setFetchStatus(element, SUCCESS)
 
       // keepPreviousData — don't clear state while fetching new page
       if (!keepPreviousData || finalData !== undefined) {
@@ -1080,9 +1098,7 @@ const runFetch = async (config, element, context, opts = {}) => {
     }
   } catch (e) {
     if (!isCurrent()) return
-    setFetchStatus(element, { isFetching: false, isLoading: false, isStale: false, isSuccess: false, error: e, status: 'error', fetchStatus: 'idle' })
-    triggerCallback(element, 'onFetchError', e)
-    triggerConfigCallback(config, element, 'onFetchError', e)
+    fail(e)
     if (_emitNet) _emitNet({
       phase: 'error', mode: 'query', from, method, cacheKey,
       error: e.message || String(e),
@@ -1158,8 +1174,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())
@@ -1309,10 +1325,10 @@ const invalidateMatching = (matches) => {
   for (const [key, entry] of cacheStore) {
     if (!matches(key)) continue
     entry.stale = true
-    invalidatedAt.set(key, ++fetchSeq)
+    markInvalidated(key)
   }
   for (const [key] of activeQueries) {
-    if (!cacheStore.has(key) && matches(key)) invalidatedAt.set(key, ++fetchSeq)
+    if (!cacheStore.has(key) && matches(key)) markInvalidated(key)
   }
   return refreshMounted(matches)
 }
@@ -1334,10 +1350,34 @@ const removeMatching = (matches) => {
     if (matches(key)) removeCache(key)
   }
   for (const [key] of activeQueries) {
-    if (matches(key)) invalidatedAt.set(key, ++fetchSeq)
+    if (matches(key)) markInvalidated(key)
   }
 }
 
+const ALL_KEYS = () => true
+
+// --- One query cache per server render ---
+//
+// The cache lives as long as this module: in a browser, the page. A server
+// renderer (@symbo.ls/brender) renders page after page in ONE module
+// instance — every route of `smbls build`, every request of a worker isolate
+// — and a page answered from the rows an earlier page left made no request:
+// nothing for that page's fetch seed (the browser asked again right after
+// boot; xma.info, 2026-10-16), and in an isolate serving several projects,
+// another project's rows under the same key. A context that sets
+// `isolateFetchCache` (brender sets it on every render) starts from an empty
+// cache: the first query it runs drops every entry an earlier context left,
+// marks the requests still out as outdated (never shared with it, never
+// written back as fresh) and forgets the queries mounted before it (an
+// invalidation it makes refetches its own). A browser context never sets it.
+const isolatedContexts = new WeakSet()
+const enterContext = (context) => {
+  if (!context || !context.isolateFetchCache || isolatedContexts.has(context)) return
+  isolatedContexts.add(context)
+  removeMatching(ALL_KEYS)
+  mountedQueries.clear()
+}
+
 // --- Mutation runner (insert/update/delete with optimistic + invalidation) ---
 
 const runMutation = async (config, element, context) => {
@@ -1372,7 +1412,6 @@ const runMutation = async (config, element, context) => {
   // Apply optimistic update
   const snapshot = optimistic ? applyOptimisticUpdate(element, config, mutationData) : null
 
-  ref.__fetching = true
   setFetchStatus(element, { isFetching: true, isLoading: false, isStale: false, isSuccess: false, error: null, status: 'pending', fetchStatus: 'fetching' })
   triggerCallback(element, 'onFetchStart')
   triggerConfigCallback(config, element, 'onFetchStart')
@@ -1412,7 +1451,7 @@ const runMutation = async (config, element, context) => {
 
     if (error) {
       if (snapshot !== undefined) rollbackOptimistic(element, config)
-      setFetchStatus(element, { isFetching: false, isLoading: false, isStale: false, isSuccess: false, error, status: 'error', fetchStatus: 'idle' })
+      setFetchStatus(element, errorStatus(error))
       triggerCallback(element, 'onFetchError', error)
       if (isFunction(onError)) onError(error, mutationData, element)
       if (isFunction(onSettled)) onSettled(null, error, mutationData, element)
@@ -1427,7 +1466,7 @@ const runMutation = async (config, element, context) => {
     delete ref.__optimisticSnapshot
 
     // The status first, as for a query: the state update re-renders.
-    setFetchStatus(element, { isFetching: false, isLoading: false, isStale: false, isSuccess: true, error: null, status: 'success', fetchStatus: 'idle' })
+    setFetchStatus(element, SUCCESS)
 
     // A body value (Blob, stream, …) lands in state only under `as`.
     if (data !== undefined && (stateKey || !isBodyValue(data))) {
@@ -1448,7 +1487,7 @@ const runMutation = async (config, element, context) => {
     if (invalidates) runInvalidates(invalidates, from)
   } catch (e) {
     if (snapshot !== undefined) rollbackOptimistic(element, config)
-    setFetchStatus(element, { isFetching: false, isLoading: false, isStale: false, isSuccess: false, error: e, status: 'error', fetchStatus: 'idle' })
+    setFetchStatus(element, errorStatus(e))
     triggerCallback(element, 'onFetchError', e)
     triggerConfigCallback(config, element, 'onFetchError', e)
     if (isFunction(onError)) onError(e, mutationData, element)
@@ -1487,6 +1526,7 @@ export const executeFetch = (param, element, state, context) => {
   if (!param) return
   const db = context?.fetch
   if (!db) return
+  enterContext(context)
 
   const fetchProp = exec(param, element)
   if (!fetchProp) return
@@ -1525,9 +1565,8 @@ 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
@@ -1582,11 +1621,7 @@ export const queryClient = {
   // Drops every matching entry (same matches). A mounted query keeps the rows
   // it shows; the next mount loads them afresh.
   removeQueries: (keyOrPattern) => {
-    if (!keyOrPattern) {
-      removeCache()
-      return
-    }
-    removeMatching(keyMatcher(keyOrPattern))
+    removeMatching(keyOrPattern ? keyMatcher(keyOrPattern) : ALL_KEYS)
   },
 
   getQueryData: (key) => {
@@ -1603,6 +1638,7 @@ export const queryClient = {
   prefetchQuery: async (config, context) => {
     const db = context?.fetch
     if (!db) return
+    enterContext(context)
 
     const adapter = await resolveAdapter(db, context)
     if (!adapter) return
@@ -1646,7 +1682,7 @@ export const queryClient = {
   },
 
   getCache: () => cacheStore,
-  clear: () => removeCache(),
+  clear: () => removeMatching(ALL_KEYS),
 
   // Drop every cache entry whose lang suffix isn't `keepLang`.
   // Cache keys are of the form `${from}:${method}:${params}[:lang]` — entries
@@ -1688,11 +1724,13 @@ const keyFor = (keyOrConfig, element) => {
   return elementQueryKey({ method: 'select', ...keyOrConfig }, element, element?.context)
 }
 
+// Each enters the caller's context first, as a query does (enterContext): rows
+// a server render's project code writes before its first query stay its own.
 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) { enterContext(this?.context); return queryClient.invalidateQueries(keyOrPattern) },
+  removeQueries (keyOrPattern) { enterContext(this?.context); return queryClient.removeQueries(keyOrPattern) },
+  getQueryData (keyOrConfig) { enterContext(this?.context); return queryClient.getQueryData(keyFor(keyOrConfig, this)) },
+  setQueryData (keyOrConfig, updater) { enterContext(this?.context); return queryClient.setQueryData(keyFor(keyOrConfig, this), updater) }
 }
 
 // --- Plugin interface ---
@@ -1724,5 +1762,6 @@ export const fetchPlugin = {
 }
 
 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

package/inflight.js

@@ -0,0 +1,39 @@
+'use strict'
+
+// --- Requests in flight ---
+//
+// Every request a REST adapter sends counts from its call until its body is
+// read. smbls holds the hydration window over a pre-rendered page open until
+// the first view's requests are done (smbls prerender.js), so a list that
+// renders with its first data still adopts the server's rows.
+//
+// The count lives on globalThis under a Symbol.for slot, like the adapter
+// registry (index.js CUSTOM_ADAPTERS): the copy of this package that smbls
+// asks and the copy an app bundle sends through may be two module instances.
+
+const KEY = Symbol.for('@symbo.ls/fetch:IN_FLIGHT')
+
+const state = () => globalThis[KEY] || (globalThis[KEY] = { count: 0, waiters: [] })
+
+export const requestStarted = () => {
+  state().count++
+}
+
+export const requestFinished = () => {
+  const s = state()
+  s.count = s.count > 0 ? s.count - 1 : 0
+  if (s.count === 0 && s.waiters.length) {
+    const waiters = s.waiters
+    s.waiters = []
+    for (const resolve of waiters) resolve()
+  }
+}
+
+/** How many REST adapter requests are in flight on this page. */
+export const requestsInFlight = () => state().count
+
+/** Resolves once no REST adapter request is in flight (at once when none is). */
+export const whenRequestsIdle = () => {
+  const s = state()
+  return s.count === 0 ? Promise.resolve() : new Promise((resolve) => { s.waiters.push(resolve) })
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbo.ls/fetch",
-  "version": "3.14.663",
+  "version": "3.14.665",
   "license": "CC-BY-NC-4.0",
   "type": "module",
   "module": "./dist/esm/index.js",
@@ -41,8 +41,8 @@
     "adapters"
   ],
   "dependencies": {
-    "@symbo.ls/signal": "^3.14.786",
-    "@symbo.ls/utils": "^3.14.784"
+    "@symbo.ls/signal": "^3.14.789",
+    "@symbo.ls/utils": "^3.14.787"
   },
   "sideEffects": false,
   "publishConfig": {