@ic-reactor/mcp 0.0.0-stage → 0.0.0

package/examples/canister-studio/src/routeTree.gen.ts

@@ -0,0 +1,227 @@
+/* eslint-disable */
+
+// @ts-nocheck
+
+// noinspection JSUnusedGlobalSymbols
+
+// This file was automatically generated by TanStack Router.
+// You should NOT make any changes in this file as it will be overwritten.
+// Additionally, you should also exclude this file from your linter and/or formatter to prevent it from being checked or modified.
+
+import { Route as rootRouteImport } from './routes/__root'
+import { Route as IndexRouteImport } from './routes/index'
+import { Route as HistoryRouteImport } from './routes/history'
+import { Route as PlaygroundRouteImport } from './routes/playground'
+import { Route as SafetyRouteImport } from './routes/safety'
+import { Route as WalletRouteImport } from './routes/wallet'
+import { Route as CanisterCanisterIdRouteImport } from './routes/canister.$canisterId'
+import { Route as CanisterCanisterIdIndexRouteImport } from './routes/canister.$canisterId.index'
+import { Route as CanisterCanisterIdInterfaceRouteImport } from './routes/canister.$canisterId.interface'
+
+const IndexRoute = IndexRouteImport.update({
+  id: '/',
+  path: '/',
+  getParentRoute: () => rootRouteImport,
+} as any)
+const HistoryRoute = HistoryRouteImport.update({
+  id: '/history',
+  path: '/history',
+  getParentRoute: () => rootRouteImport,
+} as any)
+const PlaygroundRoute = PlaygroundRouteImport.update({
+  id: '/playground',
+  path: '/playground',
+  getParentRoute: () => rootRouteImport,
+} as any)
+const SafetyRoute = SafetyRouteImport.update({
+  id: '/safety',
+  path: '/safety',
+  getParentRoute: () => rootRouteImport,
+} as any)
+const WalletRoute = WalletRouteImport.update({
+  id: '/wallet',
+  path: '/wallet',
+  getParentRoute: () => rootRouteImport,
+} as any)
+const CanisterCanisterIdRoute = CanisterCanisterIdRouteImport.update({
+  id: '/canister/$canisterId',
+  path: '/canister/$canisterId',
+  getParentRoute: () => rootRouteImport,
+} as any)
+const CanisterCanisterIdIndexRoute = CanisterCanisterIdIndexRouteImport.update({
+  id: '/',
+  path: '/',
+  getParentRoute: () => CanisterCanisterIdRoute,
+} as any)
+const CanisterCanisterIdInterfaceRoute =
+  CanisterCanisterIdInterfaceRouteImport.update({
+    id: '/interface',
+    path: '/interface',
+    getParentRoute: () => CanisterCanisterIdRoute,
+  } as any)
+
+export interface FileRoutesByFullPath {
+  '/': typeof IndexRoute
+  '/history': typeof HistoryRoute
+  '/playground': typeof PlaygroundRoute
+  '/safety': typeof SafetyRoute
+  '/wallet': typeof WalletRoute
+  '/canister/$canisterId': typeof CanisterCanisterIdRouteWithChildren
+  '/canister/$canisterId/interface': typeof CanisterCanisterIdInterfaceRoute
+  '/canister/$canisterId/': typeof CanisterCanisterIdIndexRoute
+}
+export interface FileRoutesByTo {
+  '/': typeof IndexRoute
+  '/history': typeof HistoryRoute
+  '/playground': typeof PlaygroundRoute
+  '/safety': typeof SafetyRoute
+  '/wallet': typeof WalletRoute
+  '/canister/$canisterId/interface': typeof CanisterCanisterIdInterfaceRoute
+  '/canister/$canisterId': typeof CanisterCanisterIdIndexRoute
+}
+export interface FileRoutesById {
+  __root__: typeof rootRouteImport
+  '/': typeof IndexRoute
+  '/history': typeof HistoryRoute
+  '/playground': typeof PlaygroundRoute
+  '/safety': typeof SafetyRoute
+  '/wallet': typeof WalletRoute
+  '/canister/$canisterId': typeof CanisterCanisterIdRouteWithChildren
+  '/canister/$canisterId/interface': typeof CanisterCanisterIdInterfaceRoute
+  '/canister/$canisterId/': typeof CanisterCanisterIdIndexRoute
+}
+export interface FileRouteTypes {
+  fileRoutesByFullPath: FileRoutesByFullPath
+  fullPaths:
+    | '/'
+    | '/history'
+    | '/playground'
+    | '/safety'
+    | '/wallet'
+    | '/canister/$canisterId'
+    | '/canister/$canisterId/interface'
+    | '/canister/$canisterId/'
+  fileRoutesByTo: FileRoutesByTo
+  to:
+    | '/'
+    | '/history'
+    | '/playground'
+    | '/safety'
+    | '/wallet'
+    | '/canister/$canisterId/interface'
+    | '/canister/$canisterId'
+  id:
+    | '__root__'
+    | '/'
+    | '/history'
+    | '/playground'
+    | '/safety'
+    | '/wallet'
+    | '/canister/$canisterId'
+    | '/canister/$canisterId/interface'
+    | '/canister/$canisterId/'
+  fileRoutesById: FileRoutesById
+}
+export interface RootRouteChildren {
+  IndexRoute: typeof IndexRoute
+  HistoryRoute: typeof HistoryRoute
+  PlaygroundRoute: typeof PlaygroundRoute
+  SafetyRoute: typeof SafetyRoute
+  WalletRoute: typeof WalletRoute
+  CanisterCanisterIdRoute: typeof CanisterCanisterIdRouteWithChildren
+}
+
+declare module '@tanstack/react-router' {
+  interface FileRoutesByPath {
+    '/': {
+      id: '/'
+      path: '/'
+      fullPath: '/'
+      preLoaderRoute: typeof IndexRouteImport
+      parentRoute: typeof rootRouteImport
+    }
+    '/history': {
+      id: '/history'
+      path: '/history'
+      fullPath: '/history'
+      preLoaderRoute: typeof HistoryRouteImport
+      parentRoute: typeof rootRouteImport
+    }
+    '/playground': {
+      id: '/playground'
+      path: '/playground'
+      fullPath: '/playground'
+      preLoaderRoute: typeof PlaygroundRouteImport
+      parentRoute: typeof rootRouteImport
+    }
+    '/safety': {
+      id: '/safety'
+      path: '/safety'
+      fullPath: '/safety'
+      preLoaderRoute: typeof SafetyRouteImport
+      parentRoute: typeof rootRouteImport
+    }
+    '/wallet': {
+      id: '/wallet'
+      path: '/wallet'
+      fullPath: '/wallet'
+      preLoaderRoute: typeof WalletRouteImport
+      parentRoute: typeof rootRouteImport
+    }
+    '/canister/$canisterId': {
+      id: '/canister/$canisterId'
+      path: '/canister/$canisterId'
+      fullPath: '/canister/$canisterId'
+      preLoaderRoute: typeof CanisterCanisterIdRouteImport
+      parentRoute: typeof rootRouteImport
+    }
+    '/canister/$canisterId/': {
+      id: '/canister/$canisterId/'
+      path: '/'
+      fullPath: '/canister/$canisterId/'
+      preLoaderRoute: typeof CanisterCanisterIdIndexRouteImport
+      parentRoute: typeof CanisterCanisterIdRoute
+    }
+    '/canister/$canisterId/interface': {
+      id: '/canister/$canisterId/interface'
+      path: '/interface'
+      fullPath: '/canister/$canisterId/interface'
+      preLoaderRoute: typeof CanisterCanisterIdInterfaceRouteImport
+      parentRoute: typeof CanisterCanisterIdRoute
+    }
+  }
+}
+
+interface CanisterCanisterIdRouteChildren {
+  CanisterCanisterIdInterfaceRoute: typeof CanisterCanisterIdInterfaceRoute
+  CanisterCanisterIdIndexRoute: typeof CanisterCanisterIdIndexRoute
+}
+
+const CanisterCanisterIdRouteChildren: CanisterCanisterIdRouteChildren = {
+  CanisterCanisterIdInterfaceRoute: CanisterCanisterIdInterfaceRoute,
+  CanisterCanisterIdIndexRoute: CanisterCanisterIdIndexRoute,
+}
+
+const CanisterCanisterIdRouteWithChildren =
+  CanisterCanisterIdRoute._addFileChildren(CanisterCanisterIdRouteChildren)
+
+const rootRouteChildren: RootRouteChildren = {
+  IndexRoute: IndexRoute,
+  HistoryRoute: HistoryRoute,
+  PlaygroundRoute: PlaygroundRoute,
+  SafetyRoute: SafetyRoute,
+  WalletRoute: WalletRoute,
+  CanisterCanisterIdRoute: CanisterCanisterIdRouteWithChildren,
+}
+export const routeTree = rootRouteImport
+  ._addFileChildren(rootRouteChildren)
+  ._addFileTypes<FileRouteTypes>()
+
+import type { getRouter } from './router.tsx'
+import type { createStart } from '@tanstack/react-start'
+declare module '@tanstack/react-start' {
+  interface Register {
+    ssr: true
+    router: Awaited<ReturnType<typeof getRouter>>
+  }
+}

package/examples/canister-studio/src/router.test.ts

@@ -0,0 +1,290 @@
+// @vitest-environment node
+import { isReactorError } from "@ic-reactor/core"
+import { createTestClient } from "@ic-reactor/core/testing"
+import {
+  CancelledError,
+  hydrate,
+  type DehydratedState,
+  type QueryKey,
+} from "@tanstack/react-query"
+import { afterEach, describe, expect, it, vi } from "vitest"
+import { actor as icrc1Actor, type Actor as Ledger } from "./canisters/icrc1.ts"
+import { ledgerReads, startLedgerReads } from "./components/home/featured.ts"
+import {
+  boundServerReads,
+  getRouter,
+  SERVER_READ_DEADLINE_MS,
+  shouldDehydrateRead,
+} from "./router.tsx"
+
+const key = (name: string): QueryKey => [name]
+
+// Any canister id: the test replica answers wherever it is mocked.
+const LEDGER = "mxzaz-hqaaa-aaaar-qaada-cai"
+
+type TestClient = ReturnType<typeof createTestClient>
+
+/** A promise the test settles, for a canister that answers when told. */
+function gate<T>(): { promise: Promise<T>; open(value: T): void } {
+  let open!: (value: T) => void
+  const promise = new Promise<T>((resolve) => {
+    open = resolve
+  })
+  return { promise, open }
+}
+
+const never = <T>(): Promise<T> => new Promise<T>(() => undefined)
+
+/** How many canister requests of `test` named `method`. */
+const requestsOf = (test: TestClient, method: string): number =>
+  test.requests.filter(
+    (r) =>
+      (r.endpoint === "query" || r.endpoint === "call") &&
+      r.methodName === method
+  ).length
+
+/** An anonymous test client on "ic", the key segment the app uses. */
+const anonymous = (): TestClient =>
+  createTestClient({ network: "ic", signedIn: false })
+
+afterEach(() => {
+  vi.useRealTimers()
+})
+
+describe("getRouter", () => {
+  it("makes one ic-reactor client per router, owning the query client", () => {
+    const a = getRouter()
+    const b = getRouter()
+    try {
+      expect(a.options.context.reactor).not.toBe(b.options.context.reactor)
+      expect(a.options.context.queryClient).toBe(
+        a.options.context.reactor.queryClient
+      )
+      expect(a.options.context.reactor.network).toBe("ic")
+    } finally {
+      a.options.context.reactor.dispose()
+      b.options.context.reactor.dispose()
+    }
+  })
+
+  it("prefetches on intent and leaves freshness to TanStack Query", () => {
+    const router = getRouter()
+    try {
+      expect(router.options.defaultPreload).toBe("intent")
+      expect(router.options.defaultPreloadStaleTime).toBe(0)
+      expect(router.options.scrollRestoration).toBe(true)
+      expect(router.options.defaultNotFoundComponent).toBeTypeOf("function")
+      expect(router.options.defaultErrorComponent).toBeTypeOf("function")
+    } finally {
+      router.options.context.reactor.dispose()
+    }
+  })
+
+  it("dehydrates successful reads only: never one that failed or may still fail", () => {
+    const router = getRouter()
+    const { queryClient } = router.options.context
+    try {
+      const cache = queryClient.getQueryCache()
+      const ok = cache.build(queryClient, { queryKey: key("ok") })
+      ok.setData(1n)
+      const inFlight = cache.build(queryClient, { queryKey: key("in-flight") })
+      inFlight.setState({ fetchStatus: "fetching" })
+      const idle = cache.build(queryClient, { queryKey: key("idle") })
+      const failed = cache.build(queryClient, { queryKey: key("failed") })
+      failed.setState({ status: "error", error: new Error("rejected") })
+      expect(shouldDehydrateRead(ok)).toBe(true)
+      // Its promise would reach the browser as Error("redacted") if it failed.
+      expect(shouldDehydrateRead(inFlight)).toBe(false)
+      expect(shouldDehydrateRead(idle)).toBe(false)
+      expect(shouldDehydrateRead(failed)).toBe(false)
+    } finally {
+      router.options.context.reactor.dispose()
+    }
+  })
+
+  it("streams a read that lands after dehydration, and leaves one that fails then to the browser", async () => {
+    const server = anonymous()
+    const symbol = gate<string>()
+    const supply = gate<void>()
+    server.mock<Ledger>(icrc1Actor, LEDGER, {
+      icrc1_decimals: () => 8,
+      icrc1_fee: () => 10n,
+      icrc1_symbol: () => symbol.promise,
+      icrc1_total_supply: async () => {
+        await supply.promise
+        throw new Error("the ledger trapped")
+      },
+    })
+    const router = getRouter(server.client)
+    // What TanStack Start attaches to a server router for one request.
+    let finishRendering: (() => void) | undefined
+    Object.assign(router, {
+      serverSsr: {
+        onRenderFinished: (fn: () => void) => {
+          finishRendering = fn
+        },
+      },
+    })
+    const reads = ledgerReads(server.client, LEDGER)
+    const { queryClient } = server.client
+    try {
+      // The home loader: starts every read and waits for none; two of them
+      // land before the router dehydrates.
+      startLedgerReads(server.client, queryClient, LEDGER)
+      await vi.waitFor(() => {
+        expect(queryClient.getQueryState(reads.decimals.queryKey)?.status).toBe(
+          "success"
+        )
+        expect(queryClient.getQueryState(reads.fee.queryKey)?.status).toBe(
+          "success"
+        )
+      })
+      const dehydrated = (await router.options.dehydrate?.()) as {
+        query: {
+          initial?: DehydratedState["queries"]
+          stream: ReadableStream<DehydratedState["queries"]>
+        }
+      }
+      const chunks = dehydrated.query.stream.getReader()
+      const streamed: DehydratedState["queries"] = []
+      const drained = (async () => {
+        for (;;) {
+          const { done, value } = await chunks.read()
+          if (done) return
+          streamed.push(...value)
+        }
+      })()
+
+      // After dehydration: one read lands, one fails.
+      symbol.open("ckBTC")
+      supply.open()
+      await vi.waitFor(() => {
+        expect(queryClient.getQueryState(reads.symbol.queryKey)?.status).toBe(
+          "success"
+        )
+        expect(
+          queryClient.getQueryState(reads.totalSupply.queryKey)?.status
+        ).toBe("error")
+      })
+      finishRendering?.()
+      await drained
+
+      const sent = (queries: DehydratedState["queries"]) =>
+        queries.map((q) => q.queryHash).sort()
+      const hashOf = (k: QueryKey) =>
+        queryClient.getQueryCache().find({ queryKey: k, exact: true })
+          ?.queryHash
+      expect(sent(dehydrated.query.initial ?? [])).toEqual(
+        [hashOf(reads.decimals.queryKey), hashOf(reads.fee.queryKey)].sort()
+      )
+      expect(sent(streamed)).toEqual([hashOf(reads.symbol.queryKey)])
+
+      // The browser: everything the server sent is there without a request;
+      // the failed read is its own to make, and it gets the real answer.
+      const browser = anonymous()
+      browser.mock<Ledger>(icrc1Actor, LEDGER, {
+        icrc1_decimals: () => 8,
+        icrc1_fee: () => 10n,
+        icrc1_symbol: () => "ckBTC",
+        icrc1_total_supply: () => 21_000_000n,
+      })
+      try {
+        const bq = browser.client.queryClient
+        hydrate(bq, {
+          mutations: [],
+          queries: [...(dehydrated.query.initial ?? []), ...streamed],
+        })
+        const own = ledgerReads(browser.client, LEDGER)
+        expect(await bq.ensureQueryData(own.symbol)).toBe("ckBTC")
+        expect(await bq.ensureQueryData(own.decimals)).toBe(8)
+        expect(await bq.ensureQueryData(own.fee)).toBe(10n)
+        expect(await bq.ensureQueryData(own.totalSupply)).toBe(21_000_000n)
+        expect(requestsOf(browser, "icrc1_symbol")).toBe(0)
+        expect(requestsOf(browser, "icrc1_decimals")).toBe(0)
+        expect(requestsOf(browser, "icrc1_fee")).toBe(0)
+        expect(requestsOf(browser, "icrc1_total_supply")).toBe(1)
+      } finally {
+        browser.client.dispose()
+      }
+    } finally {
+      server.client.dispose()
+    }
+  })
+
+  it("cancels a server read still in flight at SERVER_READ_DEADLINE_MS", async () => {
+    vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] })
+    const server = anonymous()
+    server.mock<Ledger>(icrc1Actor, LEDGER, {
+      icrc1_total_supply: () => never(),
+    })
+    const router = getRouter(server.client)
+    try {
+      const read = server.client.queryClient.query(
+        ledgerReads(server.client, LEDGER).totalSupply
+      )
+      const outcome = read.then(
+        () => "answered",
+        (error: unknown) => error
+      )
+      await vi.advanceTimersByTimeAsync(SERVER_READ_DEADLINE_MS - 1)
+      const early = server.client.queryClient
+        .getQueryCache()
+        .getAll()
+        .map((q) => q.state.fetchStatus)
+      expect(early).toEqual(["fetching"])
+      await vi.advanceTimersByTimeAsync(1)
+      expect(await outcome).toBeInstanceOf(CancelledError)
+    } finally {
+      router.options.context.reactor.dispose()
+    }
+  })
+})
+
+describe("boundServerReads", () => {
+  it("ends a hung read in an error, so nothing reads it again on the server", async () => {
+    const server = anonymous()
+    server.mock<Ledger>(icrc1Actor, LEDGER, {
+      icrc1_total_supply: () => never(),
+    })
+    const { queryClient } = server.client
+    const stop = boundServerReads(queryClient, 50)
+    try {
+      const options = ledgerReads(server.client, LEDGER).totalSupply
+      await expect(queryClient.query(options)).rejects.toBeInstanceOf(
+        CancelledError
+      )
+      const state = queryClient.getQueryState(options.queryKey)
+      // Not reverted to "pending": a suspended section's next server render
+      // throws this error instead of starting the same read again.
+      expect(state?.status).toBe("error")
+      expect(state?.fetchStatus).toBe("idle")
+      expect(isReactorError(state?.error)).toBe(false)
+      expect(
+        shouldDehydrateRead(queryClient.getQueryCache().getAll()[0]!)
+      ).toBe(false)
+      await vi.waitFor(() => {
+        expect(requestsOf(server, "icrc1_total_supply")).toBe(1)
+      })
+    } finally {
+      stop()
+      server.client.dispose()
+    }
+  })
+
+  it("leaves a read that settles in time alone", async () => {
+    const server = anonymous()
+    server.mock<Ledger>(icrc1Actor, LEDGER, { icrc1_fee: () => 10n })
+    const { queryClient } = server.client
+    const stop = boundServerReads(queryClient, 60_000)
+    try {
+      const options = ledgerReads(server.client, LEDGER).fee
+      expect(await queryClient.query(options)).toBe(10n)
+      expect(queryClient.getQueryState(options.queryKey)?.status).toBe(
+        "success"
+      )
+    } finally {
+      stop()
+      server.client.dispose()
+    }
+  })
+})

package/examples/canister-studio/src/router.tsx

@@ -0,0 +1,127 @@
+import type { Client } from "@ic-reactor/core"
+import { ReactorProvider } from "@ic-reactor/react"
+import type { Query, QueryClient } from "@tanstack/react-query"
+import { createRouter } from "@tanstack/react-router"
+import { setupRouterSsrQueryIntegration } from "@tanstack/react-router-ssr-query"
+import { DefaultError, DefaultNotFound } from "./components/fallbacks.tsx"
+import { createAppClient } from "./lib/reactor.ts"
+import { routeTree } from "./routeTree.gen.ts"
+
+/**
+ * What every route's `loader`, `beforeLoad` and `head` receive as `context`.
+ * Loaders read through `context.reactor` and `context.queryClient`;
+ * components use `useClient()` instead (the same client).
+ */
+export interface RouterContext {
+  /** The ic-reactor client of this request (server) or tab (browser). */
+  reactor: Client
+  /** `reactor.queryClient`: ic-reactor owns it, there is no other. */
+  queryClient: QueryClient
+}
+
+/**
+ * TanStack Start calls this once per request on the server and once per tab
+ * in the browser, so the client made here has exactly the lifetime ic-reactor
+ * asks for: one per request, one per tab, never shared, never per render.
+ * Start passes nothing; a test passes a `createTestClient()` client.
+ */
+export function getRouter(reactor: Client = createAppClient()) {
+  const queryClient = reactor.queryClient
+
+  const router = createRouter({
+    routeTree,
+    context: { reactor, queryClient } satisfies RouterContext,
+    defaultPreload: "intent",
+    // Let TanStack Query decide freshness, not the router's loader cache.
+    defaultPreloadStaleTime: 0,
+    scrollRestoration: true,
+    defaultNotFoundComponent: DefaultNotFound,
+    defaultErrorComponent: DefaultError,
+    Wrap: ({ children }) => (
+      // Borrowed: the client exists before the provider's factory is called,
+      // so the provider never disposes it. ReactorProvider renders
+      // QueryClientProvider with reactor.queryClient itself.
+      <ReactorProvider client={() => reactor}>{children}</ReactorProvider>
+    ),
+  })
+
+  setupRouterSsrQueryIntegration({
+    router,
+    queryClient,
+    // ReactorProvider already provides reactor.queryClient.
+    wrapQueryClient: false,
+    dehydrateOptions: { shouldDehydrateQuery: shouldDehydrateRead },
+  })
+  if (typeof document === "undefined") {
+    boundServerReads(queryClient, SERVER_READ_DEADLINE_MS)
+  }
+
+  return router
+}
+
+/**
+ * How long a server render lets any one read run. ic-reactor sets no
+ * timeout on a query, and a suspended section holds the response open until
+ * its read settles: for a bot, which gets nothing before the whole page is
+ * ready, one hung read would be a blank page. Longer than a shared link's
+ * own budget (SHARED_READ_BUDGET_MS), which ends its read first.
+ */
+export const SERVER_READ_DEADLINE_MS = 5_000
+
+/**
+ * Cancels every read of `queryClient` still in flight `deadlineMs` after it
+ * started, where it stands (`revert: false`): the query ends in an error.
+ * Reverted instead, it would be pending again, and the suspended section's
+ * next server render would start the same unbounded read once more. The
+ * error is never dehydrated (see {@link shouldDehydrateRead}), so the
+ * browser renders that section and reads it itself. Returns the unsubscribe.
+ */
+export function boundServerReads(
+  queryClient: QueryClient,
+  deadlineMs: number
+): () => void {
+  const timers = new Map<string, ReturnType<typeof setTimeout>>()
+  return queryClient.getQueryCache().subscribe((event) => {
+    const { query } = event
+    const hash = query.queryHash
+    if (event.type === "removed" || query.state.fetchStatus === "idle") {
+      clearTimeout(timers.get(hash))
+      timers.delete(hash)
+    } else if (!timers.has(hash)) {
+      timers.set(
+        hash,
+        setTimeout(() => {
+          timers.delete(hash)
+          void queryClient.cancelQueries(
+            { queryKey: query.queryKey, exact: true },
+            { revert: false }
+          )
+        }, deadlineMs)
+      )
+    }
+  })
+}
+
+/**
+ * Which reads the server sends to the browser: successful ones only. A read
+ * still in flight when the router dehydrates is sent once it succeeds: the
+ * integration offers each later change of the cache to this filter again
+ * while the page streams, before the section that waited for it.
+ *
+ * Never a failed read, and never a promise that may still fail: the router's
+ * serializer sends an Error as `new Error(message)`, and a dehydrated promise
+ * that rejects reaches the browser as `Error("redacted")`. Either way
+ * `isReactorError()` is false, so ic-reactor would not retry it and the
+ * section would show that error. Left out, the read is the browser's: the
+ * section the server could not finish renders there, reads again, and shows
+ * the real ReactorError only if that read fails too.
+ */
+export function shouldDehydrateRead(query: Query): boolean {
+  return query.state.status === "success"
+}
+
+declare module "@tanstack/react-router" {
+  interface Register {
+    router: ReturnType<typeof getRouter>
+  }
+}