@kontsedal/olas-core 0.0.5 → 0.1.0

package/src/forms/validators.ts

@@ -1,13 +1,16 @@
-import { isStandardSchema, type StandardSchemaV1 } from './standard-schema'
-import type { Validator } from './types'
+import type { StandardSchemaV1, StandardSchemaV1Issue } from './standard-schema'
+import type { FormIssue, Validator } from './types'
 
 /**
  * Wrap any Standard-Schema-compatible schema (Zod 4, Valibot 1, ArkType 2,
- * …) as an Olas validator. The validator returns the first issue's message
- * on failure (or `'Invalid'` if no issues are produced), `null` on success.
+ * …) as an Olas validator. Returns **all** issues as `FormIssue[]`, each
+ * carrying the schema's own `path` — so a whole-form schema used as a
+ * form-level validator routes each issue onto the matching field (T5.2),
+ * and a leaf schema (whose issues have empty paths) still reports on the
+ * field it's attached to. An empty array means "valid".
  *
  * Standard Schema validators may be sync or async; this wrapper threads
- * through whichever the schema returns — `Promise<string|null>` only when
+ * through whichever the schema returns — `Promise<FormIssue[]>` only when
  * the underlying validate call is itself async.
  *
  * `signal` is accepted to match the `Validator<T>` shape but isn't forwarded
@@ -18,15 +21,33 @@ export function validator<I, O>(schema: StandardSchemaV1<I, O>): Validator<I> {
     void signal
     const result = schema['~standard'].validate(value)
     if (result instanceof Promise) {
-      return result.then(messageFromResult)
+      return result.then(issuesFromResult)
     }
-    return messageFromResult(result)
+    return issuesFromResult(result)
   }
 }
 
-function messageFromResult(result: { issues?: ReadonlyArray<{ message: string }> }): string | null {
-  if (result.issues === undefined || result.issues.length === 0) return null
-  return result.issues[0]?.message ?? 'Invalid'
+function issuesFromResult(result: { issues?: ReadonlyArray<StandardSchemaV1Issue> }): FormIssue[] {
+  if (result.issues === undefined || result.issues.length === 0) return []
+  return result.issues.map((issue) => ({
+    path: normalizeIssuePath(issue.path),
+    message: issue.message ?? 'Invalid',
+  }))
+}
+
+/**
+ * Standard Schema issue paths are `(PropertyKey | { key: PropertyKey })[]`.
+ * Flatten to the `(string | number)[]` shape `FormIssue` uses: numeric keys
+ * stay numeric (array indices), everything else stringifies.
+ */
+function normalizeIssuePath(path: StandardSchemaV1Issue['path']): (string | number)[] {
+  if (path === undefined) return []
+  const out: (string | number)[] = []
+  for (const seg of path) {
+    const key = typeof seg === 'object' && seg !== null ? seg.key : seg
+    out.push(typeof key === 'number' ? key : String(key))
+  }
+  return out
 }
 
 export { isStandardSchema, type StandardSchemaV1 } from './standard-schema'
@@ -35,15 +56,28 @@ const isEmpty = (value: unknown): boolean => {
   if (value === undefined || value === null) return true
   if (typeof value === 'string') return value.length === 0
   if (Array.isArray(value)) return value.length === 0
+  // A boolean `false` is a legitimate value (a toggle set to "off"), NOT empty
+  // — `required` accepts it. For a consent / confirm checkbox that MUST be
+  // ticked, use `mustBeTrue` instead (T5.3).
   return false
 }
 
-/** Reject empty values (undefined, null, empty string, empty array). */
+/** Reject empty values (undefined, null, empty string, empty array). Booleans always pass. */
 export const required =
   <T>(message = 'Required'): Validator<T> =>
   (value) =>
     isEmpty(value) ? message : null
 
+/**
+ * Reject any value that isn't boolean `true` — the "you must check this box"
+ * rule for consent / terms-of-service / confirm checkboxes. Unlike `required`
+ * (which now accepts `false` as a valid boolean), this fails on `false`.
+ */
+export const mustBeTrue =
+  (message = 'Required'): Validator<boolean> =>
+  (value) =>
+    value === true ? null : message
+
 /** Reject strings / arrays shorter than `n`. Allows null/undefined (use with `required` to forbid). */
 export const minLength =
   (n: number, message?: string): Validator<string | readonly unknown[]> =>

package/src/index.ts

@@ -24,9 +24,16 @@ export type { DebugBus, DebugCacheEntry, DebugEvent } from './devtools'
 // Emitter
 export type { Emitter, EmitterErrorReporter } from './emitter'
 export { createEmitter } from './emitter'
-export type { ErrorContext } from './errors'
+export type { ErrorContext, ErrorContextInput, ErrorHandler } from './errors'
 // Forms — stdlib validators + Standard Schema adapter + debouncedValidator
-export type { StandardSchemaV1, Validator } from './forms'
+export type {
+  FieldTransform,
+  FormIssue,
+  StandardSchemaV1,
+  ValidateOn,
+  Validator,
+  ValidatorResult,
+} from './forms'
 export {
   email,
   isStandardSchema,
@@ -34,6 +41,7 @@ export {
   maxLength,
   min,
   minLength,
+  mustBeTrue,
   pattern,
   required,
   validator,
@@ -84,11 +92,7 @@ export type {
   RegisteredQuery,
   SetDataEvent,
 } from './query/plugin'
-export {
-  _unregisterMutationById,
-  lookupRegisteredMutation,
-  lookupRegisteredQuery,
-} from './query/plugin'
+export { lookupRegisteredMutation, lookupRegisteredQuery } from './query/plugin'
 // Query primitives
 export type {
   AsyncState,
@@ -96,6 +100,7 @@ export type {
   DehydratedEntry,
   DehydratedState,
   LocalCache,
+  NetworkMode,
   Query,
   QuerySpec,
   QuerySubscription,
@@ -113,6 +118,7 @@ export { selection } from './selection'
 export type { Computed, ReadSignal, Signal } from './signals'
 export { batch, computed, effect, signal, untracked } from './signals'
 // Timing
+export type { TimingSignal } from './timing'
 export { debounced, throttled } from './timing'
 
 // Utilities

package/src/query/client.ts

@@ -20,14 +20,25 @@ const DEFAULT_GC_TIME = 5 * 60_000
 
 type AnyQuery = Query<any, any> & {
   readonly __spec: QuerySpec<any, any>
+  readonly __id: string
   __clients: Set<QueryClient>
 }
 
 type AnyInfiniteQuery = InfiniteQuery<any, any, any> & {
   readonly __spec: InfiniteQuerySpec<any, any, any, any>
+  readonly __id: string
   __clients: Set<QueryClient>
 }
 
+/**
+ * Composite hydration-buffer key: query identity + key hash. Namespacing by
+ * identity stops a dehydrated entry for query A being adopted by query B that
+ * merely hashes to the same key (spec §15, T1.2). `JSON.stringify` of the pair
+ * is used rather than string concatenation so no separator char is ambiguous —
+ * both `id` (an arbitrary user `queryId`) and `hash` are unbounded strings.
+ */
+const hydrationKey = (id: string, hash: string): string => JSON.stringify([id, hash])
+
 export class ClientEntry<T> {
   readonly entry: Entry<T>
   /** The result of `spec.key(...args)` — used for hashing/identity. */
@@ -80,6 +91,8 @@ export class ClientEntry<T> {
       staleTime: spec.staleTime,
       retry: spec.retry as RetryPolicy | undefined,
       retryDelay: spec.retryDelay as RetryDelay | undefined,
+      networkMode: spec.networkMode,
+      structuralShare: spec.structuralShare,
       initialData: hydrated?.data,
       initialUpdatedAt: hydrated?.lastUpdatedAt,
       events:
@@ -142,6 +155,20 @@ export class ClientEntry<T> {
     if (this.refetchInterval == null) return
     if (this.intervalTimer != null) return
     this.intervalTimer = setInterval(() => {
+      // Skip when the tab is hidden — refetching while in background wastes
+      // battery and network. `refetchOnWindowFocus` (when enabled) will
+      // catch the entry up on visibility return; pure-interval users without
+      // focus-refetch get the catch-up via `acquire()` re-arming the timer
+      // when they next mount.
+      if (typeof document !== 'undefined' && document.visibilityState === 'hidden') {
+        return
+      }
+      // Join an in-flight fetch instead of aborting it. `startFetch()` aborts
+      // the current request, so a fetch slower than the interval would
+      // livelock — abort→restart every tick, never completing, hammering one
+      // aborted request per interval (T3.2). Skip the tick; the running fetch
+      // will finish and the next tick re-arms once it's idle.
+      if (this.entry.isFetching.peek()) return
       this.entry.startFetch().catch(() => {
         /* error already captured on entry */
       })
@@ -195,6 +222,9 @@ export class ClientEntry<T> {
   /** Refetch on focus / reconnect, but only if the data is actually stale. */
   private triggerEventRefetch(): void {
     if (!this.entry.isStaleNow()) return
+    // Join an in-flight fetch instead of aborting + restarting it — a focus /
+    // reconnect landing mid-fetch shouldn't cancel it (T3.9, cf. T3.2 interval).
+    if (this.entry.isFetching.peek()) return
     this.entry.startFetch().catch(() => {
       /* error already captured on entry */
     })
@@ -255,6 +285,8 @@ export class InfiniteClientEntry<TPage, TItem, PageParam> {
       staleTime: spec.staleTime,
       retry: spec.retry as RetryPolicy | undefined,
       retryDelay: spec.retryDelay as RetryDelay | undefined,
+      networkMode: spec.networkMode,
+      structuralShare: spec.structuralShare,
       // Fire SetDataEvent { kind: 'infinite', source: 'fetch' } whenever a
       // fetch settles successfully. Plugins (e.g. entity normalization) use
       // this to walk the pages and update their normalized stores. Mirrors
@@ -274,6 +306,10 @@ export class InfiniteClientEntry<TPage, TItem, PageParam> {
     }
   }
 
+  hasSubscribers(): boolean {
+    return this.subscriberCount > 0
+  }
+
   release(): void {
     this.subscriberCount -= 1
     if (this.subscriberCount <= 0) {
@@ -296,6 +332,13 @@ export class InfiniteClientEntry<TPage, TItem, PageParam> {
   private startIntervalTimer(): void {
     if (this.refetchInterval == null || this.intervalTimer != null) return
     this.intervalTimer = setInterval(() => {
+      // Same visibility-gate as the regular `ClientEntry.startIntervalTimer`.
+      if (typeof document !== 'undefined' && document.visibilityState === 'hidden') {
+        return
+      }
+      // Join an in-flight fetch instead of aborting it (T3.2) — see the
+      // regular `ClientEntry.startIntervalTimer` for the livelock rationale.
+      if (this.entry.isFetching.peek()) return
       this.entry.startFetch().catch(() => {
         /* error captured on entry */
       })
@@ -399,7 +442,7 @@ export class QueryClient {
     if (opts?.hydrate) this.hydrate(opts.hydrate)
     const api = this.makePluginApi()
     for (const plugin of this.plugins) {
-      this.callPlugin(() => plugin.init?.(api))
+      this.callPlugin(plugin, () => plugin.init?.(api))
     }
   }
 
@@ -427,13 +470,14 @@ export class QueryClient {
   }
 
   /** Invoke a plugin callback; route exceptions through `onError`. */
-  private callPlugin(fn: () => void): void {
+  private callPlugin(plugin: QueryClientPlugin, fn: () => void): void {
     try {
       fn()
     } catch (err) {
       dispatchError(this.onError, err, {
         kind: 'plugin',
         controllerPath: [],
+        pluginName: plugin.name,
       })
     }
   }
@@ -476,7 +520,7 @@ export class QueryClient {
     for (const plugin of this.plugins) {
       if (plugin.onSetData) {
         const cb = plugin.onSetData
-        this.callPlugin(() => cb.call(plugin, event))
+        this.callPlugin(plugin, () => cb.call(plugin, event))
       }
     }
   }
@@ -498,7 +542,7 @@ export class QueryClient {
     for (const plugin of this.plugins) {
       if (plugin.onInvalidate) {
         const cb = plugin.onInvalidate
-        this.callPlugin(() => cb.call(plugin, event))
+        this.callPlugin(plugin, () => cb.call(plugin, event))
       }
     }
   }
@@ -515,7 +559,7 @@ export class QueryClient {
     for (const plugin of this.plugins) {
       if (plugin.onGc) {
         const cb = plugin.onGc
-        this.callPlugin(() => cb.call(plugin, event))
+        this.callPlugin(plugin, () => cb.call(plugin, event))
       }
     }
   }
@@ -535,7 +579,7 @@ export class QueryClient {
     for (const plugin of this.plugins) {
       if (plugin.onMutationEnqueue) {
         const cb = plugin.onMutationEnqueue
-        this.callPlugin(() => cb.call(plugin, event))
+        this.callPlugin(plugin, () => cb.call(plugin, event))
       }
     }
   }
@@ -551,7 +595,7 @@ export class QueryClient {
     for (const plugin of this.plugins) {
       if (plugin.onMutationSettle) {
         const cb = plugin.onMutationSettle
-        this.callPlugin(() => cb.call(plugin, event))
+        this.callPlugin(plugin, () => cb.call(plugin, event))
       }
     }
   }
@@ -601,13 +645,60 @@ export class QueryClient {
     if (!entry) return
     this.applyingRemote = true
     try {
-      entry.entry.setData(() => data as never)
+      entry.entry.setData(() => data as never, { track: false })
       this.emitSetData(internal, entry.keyArgs, data, 'data', 'remote')
     } finally {
       this.applyingRemote = false
     }
   }
 
+  /**
+   * Apply a single dehydrated entry to the cache. Idempotent across
+   * pre-bind / post-bind:
+   *
+   * - If the matching `ClientEntry` already exists (a subscriber has
+   *   bound this key), `Entry.applyHydration(data, lastUpdatedAt)` writes
+   *   through with the server's timestamp + supersedes any inflight
+   *   fetch. Plugins see a `SetDataEvent` with `source: 'remote'`.
+   * - If no `ClientEntry` exists yet (the subscribing component hasn't
+   *   mounted), the entry is buffered in `hydratedData` so the next
+   *   `bindEntry` for that hash picks it up — same path the constructor
+   *   `hydrate(state)` uses.
+   *
+   * Designed for streaming SSR: each `<Suspense>` boundary that resolves
+   * on the server pushes its dehydrated entry through this method on the
+   * client as the bootstrap script executes.
+   */
+  applyDehydratedEntry(
+    queryId: string,
+    keyArgs: readonly unknown[],
+    data: unknown,
+    lastUpdatedAt: number,
+  ): void {
+    const query = lookupRegisteredQuery(queryId)
+    const hash = stableHash(keyArgs)
+    if (query && query.__olas === 'query') {
+      const internal = query as unknown as AnyQuery
+      const map = this.maps.get(internal)
+      const entry = map?.get(hash)
+      if (entry !== undefined) {
+        this.applyingRemote = true
+        try {
+          entry.entry.applyHydration(data, lastUpdatedAt)
+          this.emitSetData(internal, entry.keyArgs, data, 'data', 'remote')
+        } finally {
+          this.applyingRemote = false
+        }
+        return
+      }
+    }
+    // No local entry yet — buffer in the same map the constructor uses.
+    // The next bindEntry for this query + key will adopt the buffered payload
+    // and clear the slot. Namespaced by queryId so a colliding-key query can't
+    // steal it (spec §15, T1.2).
+    this.hydratedData.set(hydrationKey(queryId, hash), { data, lastUpdatedAt })
+  }
+
   /**
    * Local-originated `setData` keyed by `queryId + keyArgs`. Plugin-facing
    * (exposed via `QueryClientPluginApi.setEntryData`); used by the
@@ -633,7 +724,7 @@ export class QueryClient {
       if (!map) return
       const entry = map.get(hash)
       if (!entry) return
-      entry.entry.setData(updater as (prev: unknown) => never)
+      entry.entry.setData(updater as (prev: unknown) => never, { track: false })
       this.emitSetData(internal, entry.keyArgs, entry.entry.data.peek(), 'data', 'set')
       return
     }
@@ -646,7 +737,7 @@ export class QueryClient {
     if (!map) return
     const entry = map.get(hash)
     if (!entry) return
-    entry.entry.setData(updater as (prev: unknown[] | undefined) => unknown[])
+    entry.entry.setData(updater as (prev: unknown[] | undefined) => unknown[], { track: false })
     this.emitSetData(internal, entry.keyArgs, entry.entry.pages.peek(), 'infinite', 'set')
   }
 
@@ -696,7 +787,7 @@ export class QueryClient {
     }
     for (const entry of state.entries) {
       const hash = stableHash(entry.key)
-      this.hydratedData.set(hash, {
+      this.hydratedData.set(hydrationKey(entry.id, hash), {
         data: entry.data,
         lastUpdatedAt: entry.lastUpdatedAt,
       })
@@ -745,10 +836,11 @@ export class QueryClient {
 
   dehydrate(): DehydratedState {
     const entries: DehydratedState['entries'] = []
-    for (const map of this.maps.values()) {
+    for (const [query, map] of this.maps) {
       for (const ce of map.values()) {
         if (ce.entry.status.peek() === 'success') {
           entries.push({
+            id: query.__id,
             key: ce.keyArgs,
             data: ce.entry.data.peek(),
             lastUpdatedAt: ce.entry.lastUpdatedAt.peek() ?? Date.now(),
@@ -792,16 +884,27 @@ export class QueryClient {
       await Promise.all(tasks)
     }
     // The 100-iteration safety bound exists so a pathological setup that
-    // keeps starting new fetches doesn't lock the dehydrate path. Warn so
-    // it's surfaced — silent success would let an SSR dehydrate ship an
-    // incomplete payload looking like a clean one.
-    if (__DEV__) {
-      // eslint-disable-next-line no-console
-      console.warn(
-        '[olas] waitForIdle(): exited via the 100-iteration safety bound — ' +
-          'the cache or mutations keep restarting. The dehydrate payload may be incomplete.',
-      )
+    // keeps starting new fetches doesn't lock the dehydrate path. This is
+    // a correctness failure for SSR: silently returning would let
+    // `dehydrate()` ship an incomplete payload that looks clean. Throw so
+    // the SSR boundary surfaces it instead of pretending success.
+    const unsettled: Array<{ key: readonly unknown[]; kind: 'data' | 'infinite' }> = []
+    for (const map of this.maps.values()) {
+      for (const ce of map.values()) {
+        if (ce.entry.isFetching.peek()) unsettled.push({ key: ce.keyArgs, kind: 'data' })
+      }
     }
+    for (const map of this.infiniteMaps.values()) {
+      for (const ce of map.values()) {
+        if (ce.entry.isFetching.peek()) unsettled.push({ key: ce.keyArgs, kind: 'infinite' })
+      }
+    }
+    const err = new Error(
+      '[olas] waitForIdle: exceeded 100-iteration safety bound — cache or mutations keep restarting',
+    ) as Error & { unsettled: typeof unsettled; mutationsInflight: number }
+    err.unsettled = unsettled
+    err.mutationsInflight = this.mutationsInflight$.peek()
+    throw err
   }
 
   bindEntry<Args extends unknown[], T>(query: Query<Args, T>, args: Args): ClientEntry<T> {
@@ -817,8 +920,9 @@ export class QueryClient {
     const hash = stableHash(keyArgs)
     let entry = map.get(hash) as ClientEntry<T> | undefined
     if (!entry) {
-      const hydrated = this.hydratedData.get(hash) as { data: T; lastUpdatedAt: number } | undefined
-      if (hydrated) this.hydratedData.delete(hash)
+      const hkey = hydrationKey(internal.__id, hash)
+      const hydrated = this.hydratedData.get(hkey) as { data: T; lastUpdatedAt: number } | undefined
+      if (hydrated) this.hydratedData.delete(hkey)
       // Build the fetcher-success emitter here so `emitSetData` can stay
       // `private` — `ClientEntry` doesn't reach back into the client to call
       // it; the closure captures (query, keyArgs, this) in this scope and
@@ -853,6 +957,29 @@ export class QueryClient {
       if (hydrated !== undefined) {
         this.emitSetData(internal, keyArgs, hydrated.data, 'data', 'fetch')
       }
+    } else if (__DEV__) {
+      // The fetcher closure is captured on first `bindEntry`. If a later
+      // subscriber binds the SAME `keyArgs` (same hash) but DIFFERENT
+      // `callArgs`, the next refetch will still use the first caller's
+      // arguments — a silent staleness footgun when a `key()` function
+      // collapses non-key args (e.g. headers, abort tokens). Warn so the
+      // mismatch is surfaced; the consumer should either include the diff
+      // in the key or accept the documented "first wins" behavior.
+      const prev = entry.callArgs
+      const len = Math.max(prev.length, args.length)
+      let mismatch = prev.length !== args.length
+      for (let i = 0; i < len && !mismatch; i++) {
+        if (!Object.is(prev[i], args[i])) mismatch = true
+      }
+      if (mismatch) {
+        // eslint-disable-next-line no-console
+        console.warn(
+          `[olas] bindEntry: hash collision with diverging callArgs for query` +
+            ` ${internal.__spec.queryId ?? '<anonymous>'} key=${JSON.stringify(keyArgs)}.` +
+            ` First bind's args are used by the fetcher; later args ignored.` +
+            ` Either include the difference in spec.key(...) or pass identical args.`,
+        )
+      }
     }
     return entry
   }
@@ -873,6 +1000,32 @@ export class QueryClient {
     this.emitGc(entry.query, entry.keyArgs, 'data')
   }
 
+  /**
+   * Invalidate one entry: if it has subscribers, mark stale AND refetch; if
+   * not, mark stale only — the next subscriber refetches. Spec §5.7 says
+   * invalidate refetches only IF subscribed; the old always-fetch behavior woke
+   * orphaned entries that no one was watching (T3.9). Works for both
+   * `ClientEntry` and `InfiniteClientEntry`.
+   */
+  private invalidateEntry(entry: {
+    hasSubscribers(): boolean
+    keyArgs: readonly unknown[]
+    entry: { invalidate(): Promise<unknown>; markStale(): void }
+  }): void {
+    if (entry.hasSubscribers()) {
+      entry.entry.invalidate().catch((err) => {
+        if (isAbortError(err)) return
+        dispatchError(this.onError, err, {
+          kind: 'cache',
+          controllerPath: [],
+          queryKey: entry.keyArgs,
+        })
+      })
+    } else {
+      entry.entry.markStale()
+    }
+  }
+
   invalidate<Args extends unknown[]>(query: Query<Args, any>, args: Args): void {
     const internal = query as AnyQuery
     const map = this.maps.get(internal)
@@ -884,14 +1037,7 @@ export class QueryClient {
     if (__DEV__) {
       this.devtools?.emit({ type: 'cache:invalidated', queryKey: keyArgs })
     }
-    entry.entry.invalidate().catch((err) => {
-      if (isAbortError(err)) return
-      dispatchError(this.onError, err, {
-        kind: 'cache',
-        controllerPath: [],
-        queryKey: keyArgs,
-      })
-    })
+    this.invalidateEntry(entry)
     this.emitInvalidate(internal, keyArgs, 'data')
   }
 
@@ -904,18 +1050,25 @@ export class QueryClient {
       if (__DEV__) {
         this.devtools?.emit({ type: 'cache:invalidated', queryKey: entry.keyArgs })
       }
-      entry.entry.invalidate().catch((err) => {
-        if (isAbortError(err)) return
-        dispatchError(this.onError, err, {
-          kind: 'cache',
-          controllerPath: [],
-          queryKey: entry.keyArgs,
-        })
-      })
+      this.invalidateEntry(entry)
       this.emitInvalidate(internal, entry.keyArgs, 'data')
     }
   }
 
+  cancel<Args extends unknown[]>(query: Query<Args, any>, args: Args): void {
+    const internal = query as AnyQuery
+    const map = this.maps.get(internal)
+    if (!map) return
+    const hash = stableHash(internal.__spec.key(...args))
+    map.get(hash)?.entry.cancel()
+  }
+
+  cancelAll(query: Query<any, any>): void {
+    const map = this.maps.get(query as AnyQuery)
+    if (!map) return
+    for (const entry of map.values()) entry.entry.cancel()
+  }
+
   setData<Args extends unknown[], T>(
     query: Query<Args, T>,
     args: Args,
@@ -927,7 +1080,21 @@ export class QueryClient {
     // not the updater function (which would be uncloneable across
     // BroadcastChannel).
     this.emitSetData(entry.query, entry.keyArgs, entry.entry.data.peek(), 'data', 'set')
-    return snapshot
+    // Re-broadcast on rollback so cross-tab / entity plugins drop the failed
+    // optimistic value instead of keeping it (T3.6). Guard on an actual data
+    // change: a non-top chain-splice rollback (§6.4) leaves current data
+    // untouched, so there is nothing new to broadcast.
+    return {
+      rollback: () => {
+        const before = entry.entry.data.peek()
+        snapshot.rollback()
+        const after = entry.entry.data.peek()
+        if (!Object.is(before, after)) {
+          this.emitSetData(entry.query, entry.keyArgs, after, 'data', 'set')
+        }
+      },
+      finalize: () => snapshot.finalize(),
+    }
   }
 
   bindInfiniteEntry<Args extends unknown[], TPage, TItem>(
@@ -993,14 +1160,7 @@ export class QueryClient {
     const hash = stableHash(keyArgs)
     const entry = map.get(hash)
     if (!entry) return
-    entry.entry.invalidate().catch((err) => {
-      if (isAbortError(err)) return
-      dispatchError(this.onError, err, {
-        kind: 'cache',
-        controllerPath: [],
-        queryKey: entry.keyArgs,
-      })
-    })
+    this.invalidateEntry(entry)
     this.emitInvalidate(internal, keyArgs, 'infinite')
   }
 
@@ -1009,18 +1169,25 @@ export class QueryClient {
     const map = this.infiniteMaps.get(internal)
     if (!map) return
     for (const entry of map.values()) {
-      entry.entry.invalidate().catch((err) => {
-        if (isAbortError(err)) return
-        dispatchError(this.onError, err, {
-          kind: 'cache',
-          controllerPath: [],
-          queryKey: entry.keyArgs,
-        })
-      })
+      this.invalidateEntry(entry)
       this.emitInvalidate(internal, entry.keyArgs, 'infinite')
     }
   }
 
+  cancelInfinite<Args extends unknown[]>(query: InfiniteQuery<Args, any, any>, args: Args): void {
+    const internal = query as AnyInfiniteQuery
+    const map = this.infiniteMaps.get(internal)
+    if (!map) return
+    const hash = stableHash(internal.__spec.key(...args))
+    map.get(hash)?.entry.cancel()
+  }
+
+  cancelAllInfinite(query: InfiniteQuery<any, any, any>): void {
+    const map = this.infiniteMaps.get(query as AnyInfiniteQuery)
+    if (!map) return
+    for (const entry of map.values()) entry.entry.cancel()
+  }
+
   setInfiniteData<Args extends unknown[], TPage>(
     query: InfiniteQuery<Args, TPage, any>,
     args: Args,
@@ -1029,7 +1196,19 @@ export class QueryClient {
     const entry = this.bindInfiniteEntry(query, args)
     const snapshot = entry.entry.setData(updater)
     this.emitSetData(entry.query, entry.keyArgs, entry.entry.pages.peek(), 'infinite', 'set')
-    return snapshot
+    // Re-broadcast on rollback so peers drop the failed optimistic pages
+    // (T3.6); guard on an actual change (non-top chain-splice is a no-op).
+    return {
+      rollback: () => {
+        const before = entry.entry.pages.peek()
+        snapshot.rollback()
+        const after = entry.entry.pages.peek()
+        if (!Object.is(before, after)) {
+          this.emitSetData(entry.query, entry.keyArgs, after, 'infinite', 'set')
+        }
+      },
+      finalize: () => snapshot.finalize(),
+    }
   }
 
   prefetchInfinite<Args extends unknown[], TPage>(
@@ -1103,7 +1282,7 @@ export class QueryClient {
     for (const plugin of this.plugins) {
       if (plugin.dispose) {
         const cb = plugin.dispose
-        this.callPlugin(() => cb.call(plugin))
+        this.callPlugin(plugin, () => cb.call(plugin))
       }
     }
   }