@gscdump/nuxt 0.21.3 → 0.22.4

package/app/composables/useGscAnalyzer.ts

@@ -11,12 +11,14 @@
 // re-boot. Writes progress to the shared map so <GscBootProgress> lights up
 // on boot regardless of mode.
 
-import type { AnalysisParams, AnalysisResult } from '@gscdump/analysis'
 import type { AnalysisSourcesResponse, SourceInfoResponse } from '@gscdump/contracts'
 import type { AttachedTablesHandle, BrowserAnalysisRuntime, DuckDBWasmBootResult, QueryResult } from '@gscdump/engine-duckdb-wasm'
+import type { AnalysisParams, AnalysisResult } from '@gscdump/engine/analysis-types'
+import type { AnalyzerRegistry } from '@gscdump/engine/analyzer'
 import type { SiteLoadProgress } from './useGscAnalytics'
-import { defaultAnalyzerRegistry } from '@gscdump/analysis'
 import { coerceRow } from '@gscdump/engine'
+import { gscQueries } from '../queries/gsc'
+import { useGscRpc } from '../utils/gsc-rpc'
 import { useGscSharedSiteResource } from './_useGscSharedSiteResource'
 import { useGscAnalyticsContext } from './useGscAnalytics'
 import { useGscAnalyticsClient } from './useGscAnalyticsClient'
@@ -55,23 +57,13 @@ const DEFAULT_ATTACH_FETCH_CONCURRENCY = 2
 const DEFAULT_ATTACH_MAX_FILES = 32
 const DEFAULT_ATTACH_MAX_BYTES = 16 * 1024 * 1024
 
+let defaultAnalyzerRegistryPromise: Promise<AnalyzerRegistry> | null = null
+
 interface AnalyzerRange {
   start: string
   end: string
 }
 
-interface AnalysisSourcesClient {
-  getAnalysisSources: (
-    siteId: string,
-    tables?: string[] | string | { tables?: string[] | string, searchType?: NonNullable<AnalysisParams['searchType']>, start?: string, end?: string },
-    options?: { searchType?: NonNullable<AnalysisParams['searchType']>, start?: string, end?: string },
-  ) => Promise<AnalysisSourcesResponse>
-  getSourceInfo: (
-    siteId: string,
-    options?: { searchType?: NonNullable<AnalysisParams['searchType']>, start?: string, end?: string },
-  ) => Promise<SourceInfoResponse>
-}
-
 function normalizeSearchType(searchType: AnalysisParams['searchType']): NonNullable<AnalysisParams['searchType']> {
   return searchType ?? DEFAULT_SEARCH_TYPE
 }
@@ -89,18 +81,26 @@ function normalizeRange(range: AnalyzerRange | null | undefined): AnalyzerRange
   return range?.start && range?.end ? range : null
 }
 
-function loadSourceInfo(siteId: string, searchType: NonNullable<AnalysisParams['searchType']>, range: AnalyzerRange | null): Promise<SourceInfoResponse> {
-  return (useGscAnalyticsClient() as unknown as AnalysisSourcesClient).getSourceInfo(siteId, {
+type AnalyticsClient = ReturnType<typeof useGscAnalyticsClient>
+
+function loadSourceInfo(client: AnalyticsClient, siteId: string, searchType: NonNullable<AnalysisParams['searchType']>, range: AnalyzerRange | null): Promise<SourceInfoResponse> {
+  return client.getSourceInfo(siteId, {
     searchType,
     ...(range ? { start: range.start, end: range.end } : {}),
-  })
+  }) as Promise<SourceInfoResponse>
 }
 
-function loadAnalysisSources(siteId: string, searchType: NonNullable<AnalysisParams['searchType']>, range: AnalyzerRange | null): Promise<AnalysisSourcesResponse> {
-  return (useGscAnalyticsClient() as unknown as AnalysisSourcesClient).getAnalysisSources(siteId, undefined, {
+function loadAnalysisSources(client: AnalyticsClient, siteId: string, searchType: NonNullable<AnalysisParams['searchType']>, range: AnalyzerRange | null): Promise<AnalysisSourcesResponse> {
+  return client.getAnalysisSources(siteId, undefined, {
     searchType,
     ...(range ? { start: range.start, end: range.end } : {}),
-  })
+  }) as Promise<AnalysisSourcesResponse>
+}
+
+function loadDefaultAnalyzerRegistry(): Promise<AnalyzerRegistry> {
+  defaultAnalyzerRegistryPromise ??= import('@gscdump/analysis/registry')
+    .then(m => m.defaultAnalyzerRegistry)
+  return defaultAnalyzerRegistryPromise
 }
 
 /**
@@ -191,6 +191,8 @@ function createInstance(
   const attachedTables = ref<string[]>([])
   const timings = ref<GscAnalyzerTimings | null>(null)
   const manifestVersion = ref<string | undefined>(undefined)
+  const client = useGscAnalyticsClient()
+  const rpc = useGscRpc()
 
   function patch(p: Partial<SiteLoadProgress>): void {
     patchProgress(siteId, { source: 'duckdb', ...p })
@@ -266,7 +268,7 @@ function createInstance(
     patch({ stage: 'manifest', startedAt: Date.now(), filesAttached: 0, filesTotal: 0, error: undefined, endedAt: undefined })
     // Probe the server-resolved source first. Its kind + attachedTables bit
     // decides whether we boot DuckDB-WASM (expensive) or proxy to the server.
-    const info = await loadSourceInfo(siteId, searchType, range)
+    const info = await loadSourceInfo(client, siteId, searchType, range)
     mode = info.browserAttachEligible ? 'browser-attached' : 'server'
 
     if (mode === 'server') {
@@ -297,7 +299,7 @@ function createInstance(
 
     patch({ stage: 'manifest' })
     const t1 = performance.now()
-    const sources = await loadAnalysisSources(siteId, searchType, range)
+    const sources = await loadAnalysisSources(client, siteId, searchType, range)
     const manifestMs = performance.now() - t1
 
     const t2 = performance.now()
@@ -332,7 +334,11 @@ function createInstance(
   }
 
   async function runServerAnalyze(params: AnalysisParams, _signal?: AbortSignal): Promise<AnalysisResult & { queryMs: number }> {
-    const out = await useGscAnalyticsClient().analyze<AnalysisResult & { queryMs?: number }>(siteId, { ...params, searchType: params.searchType ?? searchType })
+    const out = await rpc.execute(
+      gscQueries.analyze(siteId),
+      { ...params, searchType: params.searchType ?? searchType } as never,
+      { silent: true },
+    ) as AnalysisResult & { queryMs?: number }
     return {
       results: coerceResults(out.results) as AnalysisResult['results'],
       meta: out.meta as AnalysisResult['meta'],
@@ -353,7 +359,9 @@ function createInstance(
     const p = (async () => {
       if (!rt)
         return runServerAnalyze(scopedParams, opts?.signal)
-      const out = await rt.analyze(scopedParams as never, defaultAnalyzerRegistry, { signal: opts?.signal })
+      const registry = await loadDefaultAnalyzerRegistry()
+      opts?.signal?.throwIfAborted?.()
+      const out = await rt.analyze(scopedParams as never, registry, { signal: opts?.signal })
       opts?.signal?.throwIfAborted?.()
       return {
         results: coerceResults(out.results) as AnalysisResult['results'],
@@ -376,7 +384,7 @@ function createInstance(
     await boot
     if (mode !== 'browser-attached' || !runtime || !bootedDb)
       return false
-    const sources = await loadAnalysisSources(siteId, searchType, range)
+    const sources = await loadAnalysisSources(client, siteId, searchType, range)
     if (!runtime.isStale(sources.manifestVersion))
       return false
     // Drop the stale views before swapping in the new partitions. The runtime

package/app/composables/useGscAnalyzerBatch.ts

@@ -16,7 +16,7 @@ export interface GscAnalyzerBatchEntry<TResult> {
 }
 
 export interface GscAnalyzerBatchRunner {
-  analyze: (params: { type: string, dateStart?: string, dateEnd?: string }) => Promise<unknown>
+  analyze: (params: { type: string, startDate?: string, endDate?: string }) => Promise<unknown>
 }
 
 export interface UseGscAnalyzerBatchOptions {
@@ -72,7 +72,7 @@ export function useGscAnalyzerBatch<TResult = unknown>(
         return
       states.value = { ...states.value, [id]: { status: 'running', result: null, error: null } }
       try {
-        const result = await runner.analyze({ type: id, dateStart: range.start, dateEnd: range.end })
+        const result = await runner.analyze({ type: id, startDate: range.start, endDate: range.end })
         if (token !== myToken)
           return
         states.value = { ...states.value, [id]: { status: 'done', result: result as TResult, error: null } }

package/app/composables/useGscAnalyzerDefs.ts

@@ -12,7 +12,8 @@
 // `ActionSource` union from `@gscdump/analysis`, so misspelt or unknown
 // sources fail at typecheck instead of at runtime in the priority runner.
 
-import type { ActionSource, AnalysisTool } from '@gscdump/analysis'
+import type { ActionSource } from '@gscdump/analysis'
+import type { AnalysisTool } from '@gscdump/engine/analysis-types'
 import type { Component } from '@vue/runtime-core'
 
 export type GscAnalyzerKind = 'analyzer' | 'semantic' | 'action'

package/app/composables/useGscCountries.ts

@@ -5,8 +5,8 @@
 import type { CountriesResponse, CountryRow, GscApiRange } from '@gscdump/contracts'
 import type { ComputedRef, Ref } from '@vue/runtime-core'
 import type { GscResourceStatus } from './_useGscResource'
+import { gscQueries } from '../queries/gsc'
 import { useGscResource } from './_useGscResource'
-import { useGscAnalyticsClient } from './useGscAnalyticsClient'
 
 export interface UseGscCountriesReturn {
   response: Readonly<Ref<CountriesResponse | null>>
@@ -14,8 +14,8 @@ export interface UseGscCountriesReturn {
   range: ComputedRef<GscApiRange | null>
   source: ComputedRef<CountriesResponse['source'] | null>
   loading: ComputedRef<boolean>
-  status: Ref<GscResourceStatus>
-  error: Ref<Error | null>
+  status: Readonly<Ref<GscResourceStatus>>
+  error: Readonly<Ref<Error | null>>
   refresh: () => Promise<void>
 }
 
@@ -23,14 +23,13 @@ export function useGscCountries(
   siteId: MaybeRefOrGetter<string | null | undefined>,
   range: MaybeRefOrGetter<{ start: string, end: string } | null | undefined>,
 ): UseGscCountriesReturn {
-  const { data, status, loading, error, refresh } = useGscResource({
+  const { data, status, loading, error, refresh } = useGscResource<[string, string, string], CountriesResponse>({
     keys: [
       siteId,
       () => toValue(range)?.start,
       () => toValue(range)?.end,
     ] as const,
-    fetcher: (id: string, start: string, end: string) =>
-      useGscAnalyticsClient().getCountries(id, { start, end }),
+    operation: (id, start, end) => gscQueries.countries(id, { start, end }),
     isEmpty: r => r.rows.length === 0,
   })
 

package/app/composables/useGscCurrentSite.ts

@@ -1,15 +1,36 @@
-// Dashboard route convention `/sites/[id]/*` ↔ analytics layer's
-// `useGscSite(siteId)`. Pages collapse to:
-//   const { siteId, site } = useGscCurrentSite()
-// The analytics layer is otherwise route-agnostic — this composable is the
-// one place the `id` param name is hard-coded. Hosts using a different param
-// name should provide their own equivalent.
-
-export function useGscCurrentSite(): {
+import type { ComputedRef, InjectionKey } from 'vue'
+
+export interface GscCurrentSiteContext {
   siteId: ComputedRef<string>
   site: ReturnType<typeof useGscSite>
-} {
+}
+
+export const gscCurrentSiteKey: InjectionKey<GscCurrentSiteContext> = Symbol('gsc-current-site')
+
+function createGscCurrentSiteContext(siteId: MaybeRefOrGetter<string | null | undefined>): GscCurrentSiteContext {
+  const resolvedSiteId = computed(() => String(toValue(siteId) ?? ''))
+  return { siteId: resolvedSiteId, site: useGscSite(resolvedSiteId) }
+}
+
+/**
+ * Provide the current-site context for a dashboard subtree. Hosts with a route
+ * shape other than `/sites/[id]/*` should call this from their layout/page.
+ */
+export function provideGscCurrentSite(siteId: MaybeRefOrGetter<string | null | undefined>): GscCurrentSiteContext {
+  const ctx = createGscCurrentSiteContext(siteId)
+  provide(gscCurrentSiteKey, ctx)
+  return ctx
+}
+
+/**
+ * Read the current-site context. Falls back to the historical `/sites/[id]/*`
+ * route convention for existing hosts that have not added a provider yet.
+ */
+export function useGscCurrentSite(): GscCurrentSiteContext {
+  const provided = inject(gscCurrentSiteKey, null)
+  if (provided)
+    return provided
+
   const route = useRoute()
-  const siteId = computed(() => String(route.params.id))
-  return { siteId, site: useGscSite(siteId) }
+  return createGscCurrentSiteContext(() => route.params.id as string | undefined)
 }

package/app/composables/useGscInspectionHistory.ts

@@ -5,16 +5,16 @@
 import type { InspectionHistoryRecord, InspectionHistoryResponse } from '@gscdump/contracts'
 import type { ComputedRef, Ref } from '@vue/runtime-core'
 import type { GscResourceStatus } from './_useGscResource'
+import { gscQueries } from '../queries/gsc'
 import { useGscResource } from './_useGscResource'
-import { useGscAnalyticsClient } from './useGscAnalyticsClient'
 
 export interface UseGscInspectionHistoryReturn {
   response: Readonly<Ref<InspectionHistoryResponse | null>>
   records: ComputedRef<InspectionHistoryRecord[]>
   url: ComputedRef<string | null>
   loading: ComputedRef<boolean>
-  status: Ref<GscResourceStatus>
-  error: Ref<Error | null>
+  status: Readonly<Ref<GscResourceStatus>>
+  error: Readonly<Ref<Error | null>>
   refresh: () => Promise<void>
 }
 
@@ -22,9 +22,9 @@ export function useGscInspectionHistory(
   siteId: MaybeRefOrGetter<string | null | undefined>,
   urlHash: MaybeRefOrGetter<string | null | undefined>,
 ): UseGscInspectionHistoryReturn {
-  const { data, status, loading, error, refresh } = useGscResource({
+  const { data, status, loading, error, refresh } = useGscResource<[string, string], InspectionHistoryResponse>({
     keys: [siteId, urlHash] as const,
-    fetcher: (id: string, hash: string) => useGscAnalyticsClient().getInspectionHistory(id, hash),
+    operation: (id, hash) => gscQueries.inspectionHistory(id, hash),
   })
 
   const records = computed(() => data.value?.records ?? [])

package/app/composables/useGscInspections.ts

@@ -5,23 +5,23 @@
 import type { InspectionHistoryRecord, InspectionIndex } from '@gscdump/contracts'
 import type { ComputedRef, Ref } from '@vue/runtime-core'
 import type { GscResourceStatus } from './_useGscResource'
+import { gscQueries } from '../queries/gsc'
 import { useGscResource } from './_useGscResource'
-import { useGscAnalyticsClient } from './useGscAnalyticsClient'
 
 export interface UseGscInspectionsReturn {
   index: Readonly<Ref<InspectionIndex | null>>
   records: ComputedRef<InspectionHistoryRecord[]>
   statusCounts: ComputedRef<{ PASS: number, NEUTRAL: number, FAIL: number, unknown: number }>
   loading: ComputedRef<boolean>
-  status: Ref<GscResourceStatus>
-  error: Ref<Error | null>
+  status: Readonly<Ref<GscResourceStatus>>
+  error: Readonly<Ref<Error | null>>
   refresh: () => Promise<void>
 }
 
 export function useGscInspections(siteId: MaybeRefOrGetter<string | null | undefined>): UseGscInspectionsReturn {
-  const { data, status, loading, error, refresh } = useGscResource({
+  const { data, status, loading, error, refresh } = useGscResource<[string], InspectionIndex>({
     keys: [siteId] as const,
-    fetcher: (id: string) => useGscAnalyticsClient().getInspections(id),
+    operation: (id: string) => gscQueries.inspections(id),
   })
 
   const records = computed<InspectionHistoryRecord[]>(() =>

package/app/composables/useGscPanelContext.ts

@@ -6,11 +6,18 @@
 // `/analyze` provides these once; panels inject. Type-only — runtime values
 // are the InjectionKey Symbols themselves.
 
+import type { AnalysisParams, AnalysisResult } from '@gscdump/engine/analysis-types'
 import type { InjectionKey } from '@vue/runtime-core'
-import type { GscAnalyzerInstance } from './useGscAnalyzer'
+
+export interface GscPanelRunner {
+  /** Positional-form SQL runner — `{ rows, queryMs }`. */
+  query: (sql: string, params?: readonly unknown[]) => Promise<{ rows: Record<string, unknown>[], queryMs: number }>
+  /** Registry-driven analyzer dispatch over the same per-site DuckDB-WASM runtime. */
+  analyze: (params: AnalysisParams, opts?: { signal?: AbortSignal }) => Promise<AnalysisResult & { queryMs: number }>
+}
 
 export interface GscPanelRunnerContext {
-  runner: GscAnalyzerInstance
+  runner: GscPanelRunner
   ready: Ref<boolean>
 }
 

package/app/composables/useGscQuery.ts

@@ -6,12 +6,13 @@
 // AnalysisParams to `/api/__gsc/sites/[siteId]/analyze`. Override if your server
 // uses a different contract.
 
-import type { AnalysisParams, AnalysisResult } from '@gscdump/analysis'
+import type { AnalysisParams, AnalysisResult } from '@gscdump/engine/analysis-types'
 import type { ComputedRef, Ref, WatchSource } from '@vue/runtime-core'
+import { gscQueries, withDefaultGscSearchType } from '../queries/gsc'
 import { classifyGscError } from '../utils/gsc-error'
+import { useGscRpc } from '../utils/gsc-rpc'
 import { useGscBackfill } from './_useGscBackfill'
 import { useGscQueryDispatcher } from './_useGscQueryDispatcher'
-import { useGscAnalyticsClient } from './useGscAnalyticsClient'
 import { useGscAnalyzer } from './useGscAnalyzer'
 import { _useGscAuthInternal } from './useGscAuth'
 
@@ -128,17 +129,14 @@ function isEmpty(v: unknown): boolean {
   return false
 }
 
-async function defaultServerFallback<T>(siteId: string, params: AnalysisParams): Promise<T> {
-  return await useGscAnalyticsClient().analyze<T>(siteId, params)
-}
-
 const DEFAULT_SEARCH_TYPE: NonNullable<AnalysisParams['searchType']> = 'web'
 
 function withDefaultSearchType(params: AnalysisParams): AnalysisParams {
-  return { ...params, searchType: params.searchType ?? DEFAULT_SEARCH_TYPE }
+  return withDefaultGscSearchType(params)
 }
 
 export function useGscQuery<T = AnalysisResult>(opts: UseGscQueryOptions<T>): UseGscQueryReturn<T> {
+  const rpc = useGscRpc()
   const querySearchType = computed(() => toValue(opts.params).searchType ?? DEFAULT_SEARCH_TYPE)
   const queryRange = computed(() => {
     const params = toValue(opts.params)
@@ -176,7 +174,7 @@ export function useGscQuery<T = AnalysisResult>(opts: UseGscQueryOptions<T>): Us
 
   async function runServer(siteId: string): Promise<void> {
     const t0 = performance.now()
-    const fn = opts.serverFallback ?? defaultServerFallback
+    const fn = opts.serverFallback ?? (async (siteId: string, params: AnalysisParams) => rpc.execute(gscQueries.analyze(siteId), params as never, { silent: true }) as Promise<T>)
     const out = await fn(siteId, withDefaultSearchType(toValue(opts.params))) as T
     data.value = out
     engine.value = 'server'

package/app/composables/useGscQueryDispatcher.ts

@@ -1,122 +1,14 @@
-// Per-query dispatch policy + fallback telemetry behind one swappable seam.
-//
-// `useGscQuery` owns *intent* (the caller's `engine: 'auto' | 'browser' | 'server'`);
-// the dispatcher owns *policy* (how `auto` resolves against current auth, what
-// to do with auto-fallback events). Default impl is no-op telemetry — hosts
-// that want fallback beacons override the provide with a configured factory.
-
-import type { _useGscAuthInternal } from './useGscAuth'
-import type { GscQueryDecisionReason, GscQueryEngine } from './useGscQuery'
-import { useGscEngine } from './useGscEngine'
-
-type InternalAuthState = ReturnType<typeof _useGscAuthInternal>['value']
-
-export interface GscEngineDecision {
-  mode: 'browser' | 'server'
-  reason: GscQueryDecisionReason
-  /** The resolved intent before the auth/optin mapping — useful for callers that branch on "did the user ask for auto?". */
-  requested: GscQueryEngine
-  detail?: string
-}
-
-export interface GscFallbackEvent {
-  reason: string
-  at: number
-  url: string
-}
-
-export interface PickEngineOpts {
-  /** Per-call override. Wins over `useGscEngine()` + `runtimeConfig.public.analytics.defaultEngine`. */
-  perCall?: GscQueryEngine
-}
-
-export interface GscQueryDispatcher {
-  /**
-   * Resolve the active engine into a concrete mode + reason. Consults the
-   * resolution chain: `opts.perCall` → `useGscEngine()` → runtimeConfig →
-   * `'auto'`. Then maps `auto` against `auth.browserAnalyzerEnabled`.
-   */
-  pickEngine: (auth: InternalAuthState, opts?: PickEngineOpts) => GscEngineDecision
-  /** Called once per auto-fallback. Default impl is a no-op. */
-  reportFallback: (event: GscFallbackEvent) => void
-}
-
-export interface CreateDefaultDispatcherOpts {
-  /** When set, fallbacks beacon to this URL with batched payloads. */
-  telemetryEndpoint?: string
-}
-
-const FLUSH_DELAY_MS = 5000
-
-function createReporter(endpoint: string): (event: GscFallbackEvent) => void {
-  const buffer: GscFallbackEvent[] = []
-  let flushScheduled = false
-
-  function flush(): void {
-    flushScheduled = false
-    if (buffer.length === 0)
-      return
-    const events = buffer.splice(0)
-    const body = JSON.stringify({ events })
-    if (typeof navigator !== 'undefined' && typeof navigator.sendBeacon === 'function') {
-      navigator.sendBeacon(endpoint, new Blob([body], { type: 'application/json' }))
-      return
-    }
-    fetch(endpoint, { method: 'POST', body, headers: { 'content-type': 'application/json' } }).catch(() => {})
-  }
-
-  function scheduleFlush(): void {
-    if (flushScheduled || typeof window === 'undefined')
-      return
-    flushScheduled = true
-    setTimeout(flush, FLUSH_DELAY_MS)
-    if (typeof document !== 'undefined') {
-      const handler = (): void => {
-        if (document.visibilityState === 'hidden')
-          flush()
-      }
-      document.addEventListener('visibilitychange', handler, { once: true })
-    }
-  }
-
-  return (event: GscFallbackEvent): void => {
-    buffer.push(event)
-    scheduleFlush()
-  }
-}
-
-export function createDefaultGscQueryDispatcher(
-  opts: CreateDefaultDispatcherOpts = {},
-): GscQueryDispatcher {
-  const reportFallback = opts.telemetryEndpoint
-    ? createReporter(opts.telemetryEndpoint)
-    : (): void => {}
-
-  return {
-    pickEngine(auth, opts = {}): GscEngineDecision {
-      const requested = opts.perCall ?? resolveDefaultEngine()
-      if (requested === 'server')
-        return { mode: 'server', reason: 'forced:server', requested }
-      if (requested === 'browser')
-        return { mode: 'browser', reason: 'forced:browser', requested }
-      // 'auto': when the host has wired setGscAuth, derive from the per-user
-      // browserAnalyzerEnabled flag. When unwired, preserve legacy 'auto' = browser.
-      if (auth._initialized && !auth.browserAnalyzerEnabled)
-        return { mode: 'server', reason: 'optin:off', requested }
-      return { mode: 'browser', reason: 'auto:browser', requested }
-    },
-    reportFallback,
-  }
-}
-
-function resolveDefaultEngine(): GscQueryEngine {
-  const override = useGscEngine().value
-  if (override)
-    return override
-  const cfg = useRuntimeConfig().public.analytics as { defaultEngine?: GscQueryEngine } | undefined
-  return cfg?.defaultEngine ?? 'auto'
-}
-
-export function useGscQueryDispatcher(): GscQueryDispatcher {
-  return useNuxtApp().$gscQueryDispatcher
-}
+// Public re-export. The implementation lives in `_useGscQueryDispatcher.ts`;
+// the module's `imports:extend` hook strips `_use*` from host auto-imports so
+// consumers see the wrapper at `useGscQueryDispatcher` and the layer's own
+// composables import the internal file directly. Named re-exports because
+// Nuxt's auto-import scanner doesn't traverse `export *`.
+export {
+  type CreateDefaultDispatcherOpts,
+  createDefaultGscQueryDispatcher,
+  type GscEngineDecision,
+  type GscFallbackEvent,
+  type GscQueryDispatcher,
+  type PickEngineOpts,
+  useGscQueryDispatcher,
+} from './_useGscQueryDispatcher'

package/app/composables/useGscRequestIndexingInspect.ts

@@ -1,20 +1,29 @@
 import type { IndexingInspectRateLimited, IndexingInspectResponse } from '@gscdump/contracts'
-import { useGscAnalyticsClient } from './useGscAnalyticsClient'
+import { invalidateNuxtQueries } from 'nuxt-use-query/query-cache'
+import { gscQueries } from '../queries/gsc'
+import { useGscRpc } from '../utils/gsc-rpc'
 
 export function useGscRequestIndexingInspect(): (
   siteId: string,
   urls: string[],
 ) => Promise<IndexingInspectResponse | IndexingInspectRateLimited> {
-  const client = useGscAnalyticsClient()
+  const rpc = useGscRpc()
   return async (siteId, urls) => {
-    return client.requestIndexingInspect(siteId, { urls }).catch((err: unknown) => {
-      const status = (err as { status?: number, statusCode?: number, response?: { status?: number } })?.status
-        ?? (err as { statusCode?: number })?.statusCode
-        ?? (err as { response?: { status?: number } })?.response?.status
-      const data = (err as { data?: unknown })?.data as IndexingInspectRateLimited | undefined
-      if (status === 429 && data && data.error === 'rate_limited')
-        return data
-      throw err
-    })
+    return rpc.execute(gscQueries.indexingInspect(siteId), { urls }, { silent: true })
+      .then((res) => {
+        invalidateNuxtQueries(`gsc:inspections:${siteId}`)
+        invalidateNuxtQueries(`gsc:inspection-history:${siteId}`)
+        return res as IndexingInspectResponse | IndexingInspectRateLimited
+      })
+      .catch((err: unknown) => {
+        const e = err as { type?: string, status?: number, statusCode?: number, response?: { status?: number }, data?: unknown }
+        const status = e.status
+          ?? e.statusCode
+          ?? e.response?.status
+        const data = e.data as IndexingInspectRateLimited | undefined
+        if (status === 429 && data && data.error === 'rate_limited')
+          return data
+        throw err
+      })
   }
 }