@gscdump/nuxt 0.22.1 → 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/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,7 +6,7 @@
 // `/analyze` provides these once; panels inject. Type-only — runtime values
 // are the InjectionKey Symbols themselves.
 
-import type { AnalysisParams, AnalysisResult } from '@gscdump/analysis'
+import type { AnalysisParams, AnalysisResult } from '@gscdump/engine/analysis-types'
 import type { InjectionKey } from '@vue/runtime-core'
 
 export interface GscPanelRunner {

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/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
+      })
   }
 }

package/app/composables/useGscRollup.ts

@@ -11,9 +11,10 @@
 
 import type { RollupEnvelope } from '@gscdump/contracts'
 import type { SiteListItem } from './useGscAnalytics'
+import { gscQueries } from '../queries/gsc'
+import { useGscRpc } from '../utils/gsc-rpc'
 import { useGscResource } from './_useGscResource'
 import { useGscAnalyticsContext } from './useGscAnalytics'
-import { useGscAnalyticsClient } from './useGscAnalyticsClient'
 
 type RollupsInput = MaybeRefOrGetter<string | readonly string[]>
 type SiteLike = string | { id: string } | SiteListItem
@@ -62,9 +63,11 @@ export function useGscRollup<T = unknown>(
   opts: UseGscRollupOptions = {},
 ): UseGscRollupReturn<T> {
   const ctx = useGscAnalyticsContext()
+  const rpc = useGscRpc()
   const resource = useGscResource<[string, string], RollupEnvelope<T> | null>({
+    namespace: 'gsc-rollup',
     keys: [siteId, rollupId],
-    fetcher: (id, rid) => fetchOne<T>(id, rid, ctx, toValue(opts.range) ?? null),
+    fetcher: (id, rid) => fetchOne<T>(rpc, id, rid, ctx, toValue(opts.range) ?? null),
     watchSources: [() => toValue(opts.range)?.start, () => toValue(opts.range)?.end],
     isEmpty: env => env == null,
   })
@@ -84,43 +87,31 @@ export function useGscRollups<T = unknown>(
   opts: UseGscRollupOptions = {},
 ): UseGscRollupsReturn<T> {
   const ctx = useGscAnalyticsContext()
-
-  const envelopes = ref<Record<string, RollupEnvelope<T> | null>>({})
-  const loading = ref(false)
-
-  async function refresh(): Promise<void> {
-    const sid = toValue(siteId)
-    const rids = normaliseRollups(toValue(rollupIds))
-    if (!sid || rids.length === 0) {
-      envelopes.value = {}
-      return
-    }
-    loading.value = true
-    const range = toValue(opts.range) ?? null
-    const next: Record<string, RollupEnvelope<T> | null> = {}
-    try {
+  const rpc = useGscRpc()
+  const rollupKey = computed(() => encodeStringList(normaliseRollups(toValue(rollupIds))))
+  const resource = useGscResource<[string, string], Record<string, RollupEnvelope<T> | null>>({
+    namespace: 'gsc-rollups',
+    keys: [siteId, rollupKey],
+    fetcher: async (sid, encoded) => {
+      const rids = decodeStringList(encoded)
+      const next: Record<string, RollupEnvelope<T> | null> = {}
+      const range = toValue(opts.range) ?? null
       await Promise.all(rids.map(async (rid) => {
-        next[rid] = await fetchOne<T>(sid, rid, ctx, range)
+        next[rid] = await fetchOne<T>(rpc, sid, rid, ctx, range)
       }))
-      envelopes.value = next
-    }
-    finally {
-      loading.value = false
-    }
-  }
-
-  watch(
-    () => [toValue(siteId), normaliseRollups(toValue(rollupIds)).join(','), toValue(opts.range)?.start, toValue(opts.range)?.end],
-    refresh,
-    { immediate: true },
-  )
+      return next
+    },
+    watchSources: [() => toValue(opts.range)?.start, () => toValue(opts.range)?.end],
+    isEmpty: value => Object.keys(value).length === 0,
+  })
+  const envelopes = computed<Record<string, RollupEnvelope<T> | null>>(() => resource.data.value ?? {})
 
   return {
     get: (rollupId: string) => envelopes.value[rollupId] ?? null,
     payload: (rollupId: string) => envelopes.value[rollupId]?.payload ?? null,
-    envelopes,
-    loading: loading as Readonly<Ref<boolean>>,
-    refresh,
+    envelopes: envelopes as unknown as Ref<Record<string, RollupEnvelope<T> | null>>,
+    loading: resource.loading as unknown as Readonly<Ref<boolean>>,
+    refresh: resource.refresh,
   }
 }
 
@@ -134,56 +125,39 @@ export function useGscRollupFanout<T = unknown>(
   opts: UseGscRollupOptions = {},
 ): UseGscRollupFanoutReturn<T> {
   const ctx = useGscAnalyticsContext()
-  const envelopes = ref<Record<string, RollupEnvelope<T> | null>>({})
-  const loading = ref(false)
+  const rpc = useGscRpc()
   const progress = ref<{ completed: number, total: number }>({ completed: 0, total: 0 })
-  // Ensures late-arriving promises from a superseded run don't mutate state
-  // for the current run (e.g. when the range changes rapidly).
-  let runToken = 0
-
-  async function refresh(): Promise<void> {
-    const token = ++runToken
-    const siteIds = normaliseSites(toValue(sites))
-    const rid = toValue(rollupId)
-    if (siteIds.length === 0 || !rid) {
-      envelopes.value = {}
-      progress.value = { completed: 0, total: 0 }
-      return
-    }
-    loading.value = true
-    // Seed envelopes with nulls so the UI can render skeleton rows before any
-    // fetch resolves. Writes land incrementally as each site returns.
-    const seeded: Record<string, RollupEnvelope<T> | null> = {}
-    for (const sid of siteIds) seeded[sid] = null
-    envelopes.value = seeded
-    progress.value = { completed: 0, total: siteIds.length }
-    const range = toValue(opts.range) ?? null
-    try {
+  const siteKey = computed(() => encodeStringList(normaliseSites(toValue(sites))))
+  const resource = useGscResource<[string, string], Record<string, RollupEnvelope<T> | null>>({
+    namespace: 'gsc-rollup-fanout',
+    keys: [siteKey, rollupId],
+    fetcher: async (encoded, rid) => {
+      const siteIds = decodeStringList(encoded)
+      progress.value = { completed: 0, total: siteIds.length }
+      const range = toValue(opts.range) ?? null
+      const next: Record<string, RollupEnvelope<T> | null> = {}
       await Promise.all(siteIds.map(async (sid) => {
-        const env = await fetchOne<T>(sid, rid, ctx, range)
-        if (token !== runToken)
-          return
-        envelopes.value = { ...envelopes.value, [sid]: env }
+        next[sid] = await fetchOne<T>(rpc, sid, rid, ctx, range)
         progress.value = { completed: progress.value.completed + 1, total: siteIds.length }
       }))
-    }
-    finally {
-      if (token === runToken)
-        loading.value = false
-    }
-  }
-
-  watch(
-    () => [normaliseSites(toValue(sites)).join(','), toValue(rollupId), toValue(opts.range)?.start, toValue(opts.range)?.end],
-    refresh,
-    { immediate: true },
-  )
+      return next
+    },
+    watchSources: [() => toValue(opts.range)?.start, () => toValue(opts.range)?.end],
+    isEmpty: value => Object.keys(value).length === 0,
+  })
+  const envelopes = computed<Record<string, RollupEnvelope<T> | null>>(() => resource.data.value ?? {})
+  watch(resource.loading, (loading) => {
+    if (loading)
+      return
+    if (!resource.data.value)
+      progress.value = { completed: 0, total: 0 }
+  }, { immediate: true })
 
   return {
-    envelopes,
-    loading: loading as Readonly<Ref<boolean>>,
+    envelopes: envelopes as unknown as Ref<Record<string, RollupEnvelope<T> | null>>,
+    loading: resource.loading as unknown as Readonly<Ref<boolean>>,
     progress: progress as Readonly<Ref<{ completed: number, total: number }>>,
-    refresh,
+    refresh: resource.refresh,
   }
 }
 
@@ -204,7 +178,19 @@ function normaliseSites(input: unknown): string[] {
   return out
 }
 
+function encodeStringList(values: string[]): string {
+  return values.length > 0 ? JSON.stringify(values) : ''
+}
+
+function decodeStringList(encoded: string): string[] {
+  const parsed = JSON.parse(encoded) as unknown
+  return Array.isArray(parsed)
+    ? parsed.filter((v): v is string => typeof v === 'string' && v.length > 0)
+    : []
+}
+
 async function fetchOne<T>(
+  rpc: ReturnType<typeof useGscRpc>,
   siteId: string,
   rollupId: string,
   ctx: ReturnType<typeof useGscAnalyticsContext>,
@@ -220,11 +206,10 @@ async function fetchOne<T>(
     endedAt: undefined,
   })
   try {
-    const env = await useGscAnalyticsClient().getRollup<T>(
-      siteId,
-      rollupId,
-      range ? { start: range.start, end: range.end } : undefined,
-    )
+    const env = await rpc.query(
+      gscQueries.rollup(siteId, rollupId, range ?? undefined),
+      { silent: true },
+    ) as RollupEnvelope<T>
     ctx.patchProgress(siteId, { stage: 'ready', filesAttached: 1, endedAt: Date.now() })
     return env
   }

package/app/composables/useGscSearchAppearance.ts

@@ -5,8 +5,8 @@
 import type { GscApiRange, SearchAppearanceResponse, SearchAppearanceRow } 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 UseGscSearchAppearanceReturn {
   response: Readonly<Ref<SearchAppearanceResponse | null>>
@@ -14,8 +14,8 @@ export interface UseGscSearchAppearanceReturn {
   range: ComputedRef<GscApiRange | null>
   source: ComputedRef<SearchAppearanceResponse['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 useGscSearchAppearance(
   siteId: MaybeRefOrGetter<string | null | undefined>,
   range: MaybeRefOrGetter<{ start: string, end: string } | null | undefined>,
 ): UseGscSearchAppearanceReturn {
-  const { data, status, loading, error, refresh } = useGscResource({
+  const { data, status, loading, error, refresh } = useGscResource<[string, string, string], SearchAppearanceResponse>({
     keys: [
       siteId,
       () => toValue(range)?.start,
       () => toValue(range)?.end,
     ] as const,
-    fetcher: (id: string, start: string, end: string) =>
-      useGscAnalyticsClient().getSearchAppearance(id, { start, end }),
+    operation: (id, start, end) => gscQueries.searchAppearance(id, { start, end }),
     isEmpty: r => r.rows.length === 0,
   })