@sanity/sdk 3.0.0-rc.2 → 3.1.0

package/dist/telemetryManager-Dq_qCkeI.js

@@ -1,127 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-vyAXikos.js";
-import { n as createLogger } from "./logger-DAtJb5RQ.js";
-import { t as CORE_SDK_VERSION } from "./version-BChjsi4u.js";
-import "@sanity/client";
-import { createBatchedStore, defineEvent } from "@sanity/telemetry";
-/** @internal */
-const SDKSessionStarted = defineEvent({
-	name: "SDK Session Started",
-	version: 1,
-	description: "SDK instance created (environment is recorded in the event context)"
-}), SDKHookMounted = defineEvent({
-	name: "SDK Hook Mounted",
-	version: 1,
-	description: "An SDK hook was mounted for the first time in this session"
-}), SDKSessionEnded = defineEvent({
-	name: "SDK Session Ended",
-	version: 1,
-	description: "SDK instance disposed (environment is recorded in the event context)"
-}), SDKError = defineEvent({
-	name: "SDK Error",
-	version: 1,
-	description: "Runtime error caught in the SDK"
-});
-var telemetryManager_exports = /* @__PURE__ */ __exportAll({ createTelemetryManager: () => createTelemetryManager });
-const log = createLogger("telemetry");
-/**
-* Creates a telemetry manager for a single SDK instance session.
-*
-* The manager initializes a `createBatchedStore` from `@sanity/telemetry`,
-* caches the consent check for the lifetime of the session, and provides
-* typed methods for each SDK telemetry event.
-*
-* @internal
-*/
-function createTelemetryManager(options) {
-	let { sessionId, getClient, projectId, environment } = options, startedAt = Date.now(), emittedHooks = /* @__PURE__ */ new Set(), cachedConsent = null, resolveConsent = async () => {
-		if (cachedConsent) return cachedConsent;
-		try {
-			cachedConsent = await getClient().request({
-				uri: "/intake/telemetry-status",
-				tag: "telemetry-consent.sdk"
-			});
-		} catch {
-			cachedConsent = { status: "undetermined" };
-		}
-		return cachedConsent;
-	}, enrichBatch = (batch) => batch.map((event) => {
-		let existing = "context" in event ? event.context : void 0;
-		return {
-			...event,
-			context: {
-				...existing,
-				version: CORE_SDK_VERSION,
-				environment,
-				origin: typeof window < "u" ? window.location.origin : "node"
-			}
-		};
-	}), sendEvents = async (batch) => {
-		let client = getClient();
-		return log.debug("sending event batch", {
-			batchSize: batch.length,
-			environment
-		}), client.request({
-			uri: "/intake/batch",
-			method: "POST",
-			body: {
-				projectId,
-				batch: enrichBatch(batch)
-			},
-			tag: "telemetry.batch"
-		});
-	}, store = createBatchedStore(sessionId, {
-		flushInterval: 3e4,
-		resolveConsent,
-		sendEvents
-	}), logger = store.logger;
-	return {
-		async checkConsent() {
-			let { status } = await resolveConsent();
-			return status === "granted";
-		},
-		logSessionStarted(data) {
-			log.debug("event: SDK Session Started", {
-				projectId: data.projectId,
-				perspective: data.perspective,
-				authMethod: data.authMethod,
-				version: CORE_SDK_VERSION,
-				environment
-			}), logger.log(SDKSessionStarted, {
-				version: CORE_SDK_VERSION,
-				...data
-			});
-		},
-		logHookFirstUsed(hookName) {
-			emittedHooks.has(hookName) || (emittedHooks.add(hookName), log.debug("event: SDK Hook Mounted", { hookName }), logger.log(SDKHookMounted, { hookName }));
-		},
-		logError(errorType, hookName) {
-			log.debug("event: SDK Error", {
-				errorType,
-				hookName
-			}), logger.log(SDKError, {
-				errorType,
-				hookName
-			});
-		},
-		endSession() {
-			let durationSeconds = Math.round((Date.now() - startedAt) / 1e3);
-			log.debug("event: SDK Session Ended", {
-				durationSeconds,
-				hooksUsed: [...emittedHooks],
-				environment
-			}), logger.log(SDKSessionEnded, {
-				durationSeconds,
-				hooksUsed: [...emittedHooks]
-			}), store.flush().catch(() => {}), store.end();
-		},
-		dispose() {
-			store.end();
-		},
-		get hooksUsed() {
-			return emittedHooks;
-		}
-	};
-}
-export { telemetryManager_exports as t };
-
-//# sourceMappingURL=telemetryManager-Dq_qCkeI.js.map

package/dist/telemetryManager-Dq_qCkeI.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"telemetryManager-Dq_qCkeI.js","names":[],"sources":["../src/telemetry/events.ts","../src/telemetry/telemetryManager.ts"],"sourcesContent":["import {defineEvent} from '@sanity/telemetry'\n\n/** @internal */\nexport const SDKSessionStarted = defineEvent<{\n  version: string\n  projectId: string\n  perspective: string\n  authMethod: string\n}>({\n  name: 'SDK Session Started',\n  version: 1,\n  description: 'SDK instance created (environment is recorded in the event context)',\n})\n\n/** @internal */\nexport const SDKHookMounted = defineEvent<{\n  hookName: string\n}>({\n  name: 'SDK Hook Mounted',\n  version: 1,\n  description: 'An SDK hook was mounted for the first time in this session',\n})\n\n/** @internal */\nexport const SDKSessionEnded = defineEvent<{\n  durationSeconds: number\n  hooksUsed: string[]\n}>({\n  name: 'SDK Session Ended',\n  version: 1,\n  description: 'SDK instance disposed (environment is recorded in the event context)',\n})\n\n/** @internal */\nexport const SDKError = defineEvent<{\n  errorType: string\n  hookName: string\n}>({\n  name: 'SDK Error',\n  version: 1,\n  description: 'Runtime error caught in the SDK',\n})\n","import {type SanityClient} from '@sanity/client'\nimport {\n  type ConsentStatus,\n  createBatchedStore,\n  type SessionId,\n  type TelemetryEvent,\n  type TelemetryLogger,\n  type TelemetryStore,\n} from '@sanity/telemetry'\n\nimport {createLogger} from '../utils/logger'\nimport {CORE_SDK_VERSION} from '../version'\nimport {type TelemetryEnvironment} from './environment'\nimport {SDKError, SDKHookMounted, SDKSessionEnded, SDKSessionStarted} from './events'\n\nconst FLUSH_INTERVAL_MS = 30_000\nconst CONSENT_TAG = 'telemetry-consent.sdk'\nconst BATCH_TAG = 'telemetry.batch'\n\nconst log = createLogger('telemetry')\n\n/**\n * Manages telemetry for a single SDK instance.\n *\n * Wraps `@sanity/telemetry`'s batched store with SDK-specific concerns:\n * consent caching, session lifecycle events, and hook usage tracking.\n * The `environment` is captured at construction time and recorded in\n * the event context so downstream pipelines can distinguish dev and\n * production sessions.\n *\n * @internal\n */\nexport interface TelemetryManager {\n  /**\n   * Eagerly resolve and cache the user's consent status.\n   * Returns true only when the user has explicitly opted in (`granted`).\n   * Call this before logging any events to avoid buffering events that\n   * will be dropped on the first flush.\n   */\n  checkConsent(): Promise<boolean>\n\n  /** Log a \"SDK Session Started\" event */\n  logSessionStarted(data: {projectId: string; perspective: string; authMethod: string}): void\n\n  /** Log a \"SDK Hook Mounted\" event (deduplicated per hook name) */\n  logHookFirstUsed(hookName: string): void\n\n  /** Log a \"SDK Error\" event */\n  logError(errorType: string, hookName: string): void\n\n  /** Log a \"SDK Session Ended\" event and tear down the store */\n  endSession(): void\n\n  /** Tear down the store without logging a session-end event */\n  dispose(): void\n\n  /** The set of hook names used during this session */\n  readonly hooksUsed: ReadonlySet<string>\n}\n\ninterface TelemetryManagerOptions {\n  sessionId: string\n  getClient: () => SanityClient\n  projectId: string\n  environment: TelemetryEnvironment\n}\n\n/**\n * Creates a telemetry manager for a single SDK instance session.\n *\n * The manager initializes a `createBatchedStore` from `@sanity/telemetry`,\n * caches the consent check for the lifetime of the session, and provides\n * typed methods for each SDK telemetry event.\n *\n * @internal\n */\nexport function createTelemetryManager(options: TelemetryManagerOptions): TelemetryManager {\n  const {sessionId, getClient, projectId, environment} = options\n  const startedAt = Date.now()\n  const emittedHooks = new Set<string>()\n\n  let cachedConsent: {status: ConsentStatus} | null = null\n\n  const resolveConsent = async (): Promise<{status: ConsentStatus}> => {\n    if (cachedConsent) return cachedConsent\n    try {\n      const client = getClient()\n      const result = await client.request<{status: ConsentStatus}>({\n        uri: '/intake/telemetry-status',\n        tag: CONSENT_TAG,\n      })\n      cachedConsent = result\n    } catch {\n      cachedConsent = {status: 'undetermined'}\n    }\n    return cachedConsent\n  }\n\n  const enrichBatch = (batch: TelemetryEvent[]) =>\n    batch.map((event) => {\n      // Trace events (`trace.start` / `trace.log` / `trace.error` /\n      // `trace.complete`) arrive with their own caller-provided `context`.\n      // Log / userProperties events don't. Narrow via `in` so `event`\n      // stays typed as `TelemetryEvent`, then merge so we don't drop the\n      // trace context. SDK-owned fields below win on conflict.\n      const existing =\n        'context' in event ? (event.context as Record<string, unknown> | undefined) : undefined\n      return {\n        ...event,\n        context: {\n          ...existing,\n          version: CORE_SDK_VERSION,\n          environment,\n          origin: typeof window !== 'undefined' ? window.location.origin : 'node',\n        },\n      }\n    })\n\n  const sendEvents = async (batch: TelemetryEvent[]): Promise<unknown> => {\n    const client = getClient()\n    log.debug('sending event batch', {batchSize: batch.length, environment})\n    return client.request({\n      uri: '/intake/batch',\n      method: 'POST',\n      body: {projectId, batch: enrichBatch(batch)},\n      tag: BATCH_TAG,\n    })\n  }\n\n  const store: TelemetryStore<Record<string, unknown>> = createBatchedStore(\n    sessionId as SessionId,\n    {\n      flushInterval: FLUSH_INTERVAL_MS,\n      resolveConsent,\n      sendEvents,\n    },\n  )\n\n  const logger: TelemetryLogger<Record<string, unknown>> = store.logger\n\n  return {\n    async checkConsent() {\n      const {status} = await resolveConsent()\n      return status === 'granted'\n    },\n\n    logSessionStarted(data) {\n      log.debug('event: SDK Session Started', {\n        projectId: data.projectId,\n        perspective: data.perspective,\n        authMethod: data.authMethod,\n        version: CORE_SDK_VERSION,\n        environment,\n      })\n      logger.log(SDKSessionStarted, {\n        version: CORE_SDK_VERSION,\n        ...data,\n      })\n    },\n\n    logHookFirstUsed(hookName: string) {\n      if (emittedHooks.has(hookName)) return\n      emittedHooks.add(hookName)\n      log.debug('event: SDK Hook Mounted', {hookName})\n      logger.log(SDKHookMounted, {hookName})\n    },\n\n    logError(errorType: string, hookName: string) {\n      log.debug('event: SDK Error', {errorType, hookName})\n      logger.log(SDKError, {errorType, hookName})\n    },\n\n    endSession() {\n      const durationSeconds = Math.round((Date.now() - startedAt) / 1000)\n      log.debug('event: SDK Session Ended', {\n        durationSeconds,\n        hooksUsed: [...emittedHooks],\n        environment,\n      })\n      logger.log(SDKSessionEnded, {\n        durationSeconds,\n        hooksUsed: [...emittedHooks],\n      })\n\n      store.flush().catch(() => {\n        // Best-effort flush on dispose; swallow errors\n      })\n      store.end()\n    },\n\n    dispose() {\n      store.end()\n    },\n\n    get hooksUsed(): ReadonlySet<string> {\n      return emittedHooks\n    },\n  }\n}\n"],"mappings":";;;;;;AAGA,MAAa,oBAAoB,YAK9B;CACD,MAAM;CACN,SAAS;CACT,aAAa;AACf,CAAC,GAGY,iBAAiB,YAE3B;CACD,MAAM;CACN,SAAS;CACT,aAAa;AACf,CAAC,GAGY,kBAAkB,YAG5B;CACD,MAAM;CACN,SAAS;CACT,aAAa;AACf,CAAC,GAGY,WAAW,YAGrB;CACD,MAAM;CACN,SAAS;CACT,aAAa;AACf,CAAC;;AC1BD,MAIM,MAAM,aAAa,WAAW;;;;;;;;;;AAyDpC,SAAgB,uBAAuB,SAAoD;CACzF,IAAM,EAAC,WAAW,WAAW,WAAW,gBAAe,SACjD,YAAY,KAAK,IAAI,GACrB,+BAAe,IAAI,IAAY,GAEjC,gBAAgD,MAE9C,iBAAiB,YAA8C;EACnE,IAAI,eAAe,OAAO;EAC1B,IAAI;GAMF,gBAAgB,MALD,UACW,CAAC,CAAC,QAAiC;IAC3D,KAAK;IACL,KAAK;GACP,CAAC;EAEH,QAAQ;GACN,gBAAgB,EAAC,QAAQ,eAAc;EACzC;EACA,OAAO;CACT,GAEM,eAAe,UACnB,MAAM,KAAK,UAAU;EAMnB,IAAM,WACJ,aAAa,QAAS,MAAM,UAAkD,KAAA;EAChF,OAAO;GACL,GAAG;GACH,SAAS;IACP,GAAG;IACH,SAAS;IACT;IACA,QAAQ,OAAO,SAAW,MAAc,OAAO,SAAS,SAAS;GACnE;EACF;CACF,CAAC,GAEG,aAAa,OAAO,UAA8C;EACtE,IAAM,SAAS,UAAU;EAEzB,OADA,IAAI,MAAM,uBAAuB;GAAC,WAAW,MAAM;GAAQ;EAAW,CAAC,GAChE,OAAO,QAAQ;GACpB,KAAK;GACL,QAAQ;GACR,MAAM;IAAC;IAAW,OAAO,YAAY,KAAK;GAAC;GAC3C,KAAK;EACP,CAAC;CACH,GAEM,QAAiD,mBACrD,WACA;EACE,eAAe;EACf;EACA;CACF,CACF,GAEM,SAAmD,MAAM;CAE/D,OAAO;EACL,MAAM,eAAe;GACnB,IAAM,EAAC,WAAU,MAAM,eAAe;GACtC,OAAO,WAAW;EACpB;EAEA,kBAAkB,MAAM;GAQtB,AAPA,IAAI,MAAM,8BAA8B;IACtC,WAAW,KAAK;IAChB,aAAa,KAAK;IAClB,YAAY,KAAK;IACjB,SAAS;IACT;GACF,CAAC,GACD,OAAO,IAAI,mBAAmB;IAC5B,SAAS;IACT,GAAG;GACL,CAAC;EACH;EAEA,iBAAiB,UAAkB;GAC7B,aAAa,IAAI,QAAQ,MAC7B,aAAa,IAAI,QAAQ,GACzB,IAAI,MAAM,2BAA2B,EAAC,SAAQ,CAAC,GAC/C,OAAO,IAAI,gBAAgB,EAAC,SAAQ,CAAC;EACvC;EAEA,SAAS,WAAmB,UAAkB;GAE5C,AADA,IAAI,MAAM,oBAAoB;IAAC;IAAW;GAAQ,CAAC,GACnD,OAAO,IAAI,UAAU;IAAC;IAAW;GAAQ,CAAC;EAC5C;EAEA,aAAa;GACX,IAAM,kBAAkB,KAAK,OAAO,KAAK,IAAI,IAAI,aAAa,GAAI;GAclE,AAbA,IAAI,MAAM,4BAA4B;IACpC;IACA,WAAW,CAAC,GAAG,YAAY;IAC3B;GACF,CAAC,GACD,OAAO,IAAI,iBAAiB;IAC1B;IACA,WAAW,CAAC,GAAG,YAAY;GAC7B,CAAC,GAED,MAAM,MAAM,CAAC,CAAC,YAAY,CAE1B,CAAC,GACD,MAAM,IAAI;EACZ;EAEA,UAAU;GACR,MAAM,IAAI;EACZ;EAEA,IAAI,YAAiC;GACnC,OAAO;EACT;CACF;AACF"}

package/dist/version-BChjsi4u.js

@@ -1,9 +0,0 @@
-import { t as getEnv } from "./getEnv-D5RGkQLu.js";
-/**
-* This version is provided by pkg-utils at build time
-* @internal
-*/
-const CORE_SDK_VERSION = getEnv("PKG_VERSION") || "3.0.0-rc.2-development";
-export { CORE_SDK_VERSION as t };
-
-//# sourceMappingURL=version-BChjsi4u.js.map

package/dist/version-BChjsi4u.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"version-BChjsi4u.js","names":[],"sources":["../package.json","../src/version.ts"],"sourcesContent":["","import {version} from '../package.json'\nimport {getEnv} from './utils/getEnv'\n\n/**\n * This version is provided by pkg-utils at build time\n * @internal\n */\nexport const CORE_SDK_VERSION = getEnv('PKG_VERSION') || `${version}-development`\n"],"mappings":";;;;;ACOA,MAAa,mBAAmB,OAAO,aAAa,KAAK"}

package/src/utils/createFetcherStore.test.ts

@@ -1,171 +0,0 @@
-import {delay, firstValueFrom, of, throwError} from 'rxjs'
-import {filter, skip} from 'rxjs/operators'
-import {beforeEach, describe, expect, it, vi} from 'vitest'
-
-import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
-import {createFetcherStore} from './createFetcherStore'
-
-describe('createFetcherStore', () => {
-  let instance: SanityInstance
-
-  beforeEach(() => {
-    instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-    vi.useRealTimers()
-  })
-
-  afterEach(() => {
-    instance.dispose()
-  })
-
-  it('should fetch data and update state when subscribed', async () => {
-    const store = createFetcherStore({
-      name: 'test',
-      fetcher: () => (param: number) => of(`data-${param}`).pipe(delay(100)),
-      getKey: (_instance, param: number) => `key-${param}`,
-    })
-
-    const stateSource = store.getState(instance, 1)
-    const dataPromise = firstValueFrom(
-      stateSource.observable.pipe(filter((data) => data !== undefined)),
-    )
-
-    vi.useFakeTimers()
-    await vi.advanceTimersByTimeAsync(100)
-    const data = await dataPromise
-    expect(data).toBe('data-1')
-    vi.useRealTimers()
-
-    expect(stateSource.getCurrent()).toBe('data-1')
-  })
-
-  it('should only fetch once for multiple subscriptions within throttle interval', async () => {
-    const fetchSpy = vi.fn().mockImplementation((param: number) => of(`data-${param}`))
-    const store = createFetcherStore({
-      name: 'test-throttle',
-      fetcher: () => fetchSpy,
-      getKey: (_instance, param: number) => `key-${param}`,
-      fetchThrottleInternal: 1000,
-    })
-
-    const stateSource = store.getState(instance, 1)
-    const sub1 = stateSource.subscribe()
-    const sub2 = stateSource.subscribe()
-
-    await firstValueFrom(stateSource.observable)
-    expect(fetchSpy).toHaveBeenCalledTimes(1)
-
-    sub1()
-    sub2()
-  })
-
-  it('should propagate errors correctly', async () => {
-    const store = createFetcherStore({
-      name: 'test-error',
-      fetcher: () => () => throwError(() => new Error('test error')),
-      getKey: () => 'key',
-    })
-
-    const stateSource = store.getState(instance)
-    const dataPromise = firstValueFrom(
-      stateSource.observable.pipe(
-        // the first value will be `undefined` since the store is not populated
-        skip(1),
-      ),
-    )
-
-    await expect(dataPromise).rejects.toThrow()
-    expect(() => stateSource.getCurrent()).toThrow()
-  })
-
-  it('should clear state after expiration delay', async () => {
-    const fetchSpy = vi
-      .fn()
-      .mockImplementation((param: number) => of(`data-${param}`).pipe(delay(100)))
-    const store = createFetcherStore({
-      name: 'test-expiration',
-      fetcher: () => fetchSpy,
-      getKey: (_instance, param: number) => `key-${param}`,
-      stateExpirationDelay: 1000,
-    })
-
-    // First subscription
-    const stateSource1 = store.getState(instance, 1)
-    const sub1 = stateSource1.subscribe()
-    await firstValueFrom(stateSource1.observable.pipe(filter((data) => data !== undefined)))
-    expect(fetchSpy).toHaveBeenCalledTimes(1)
-
-    sub1()
-
-    // Wait for expiration delay
-    vi.useFakeTimers()
-    await vi.advanceTimersByTimeAsync(1000)
-
-    // Second subscription
-    const stateSource2 = store.getState(instance, 1)
-    const sub2 = stateSource2.subscribe()
-    await firstValueFrom(stateSource2.observable.pipe(filter((data) => data !== undefined)))
-    expect(fetchSpy).toHaveBeenCalledTimes(2)
-
-    sub2()
-    vi.useRealTimers()
-  })
-
-  it('should throttle fetches based on fetchThrottleInternal', async () => {
-    const fetchSpy = vi.fn().mockImplementation((param: number) => of(`data-${param}`))
-    const store = createFetcherStore({
-      name: 'test-throttle',
-      fetcher: () => fetchSpy,
-      getKey: (_instance, param: number) => `key-${param}`,
-      fetchThrottleInternal: 1000,
-    })
-
-    const stateSource = store.getState(instance, 1)
-
-    // First subscription
-    const sub1 = stateSource.subscribe()
-    await firstValueFrom(stateSource.observable)
-    expect(fetchSpy).toHaveBeenCalledTimes(1)
-
-    // Second subscription within throttle interval
-    const stateSource2 = store.getState(instance, 1)
-    const sub2 = stateSource2.subscribe()
-    await firstValueFrom(stateSource2.observable)
-    expect(fetchSpy).toHaveBeenCalledTimes(1)
-
-    // Advance past throttle interval
-    vi.useFakeTimers()
-    await vi.advanceTimersByTimeAsync(1000)
-
-    // Third subscription after throttle interval
-    const stateSource3 = store.getState(instance, 1)
-    const sub3 = stateSource3.subscribe()
-    await firstValueFrom(stateSource3.observable)
-    expect(fetchSpy).toHaveBeenCalledTimes(2)
-
-    sub1()
-    sub2()
-    sub3()
-    vi.useRealTimers()
-  })
-
-  it('should handle different parameters with different keys', async () => {
-    const store = createFetcherStore({
-      name: 'test-params',
-      fetcher: () => (param: number) => of(`data-${param}`),
-      getKey: (_instance, param: number) => `key-${param}`,
-    })
-
-    const stateSource1 = store.getState(instance, 1)
-    const stateSource2 = store.getState(instance, 2)
-
-    const data1 = await firstValueFrom(
-      stateSource1.observable.pipe(filter((data) => data !== undefined)),
-    )
-    const data2 = await firstValueFrom(
-      stateSource2.observable.pipe(filter((data) => data !== undefined)),
-    )
-
-    expect(data1).toBe('data-1')
-    expect(data2).toBe('data-2')
-  })
-})

package/src/utils/createFetcherStore.ts

@@ -1,284 +0,0 @@
-import {asapScheduler, EMPTY, firstValueFrom, from, Observable} from 'rxjs'
-import {
-  catchError,
-  delay,
-  filter,
-  first,
-  groupBy,
-  map,
-  mergeMap,
-  pairwise,
-  startWith,
-  switchMap,
-  tap,
-} from 'rxjs/operators'
-
-import {bindActionGlobally, type BoundStoreAction} from '../store/createActionBinder'
-import {type SanityInstance} from '../store/createSanityInstance'
-import {
-  createStateSourceAction,
-  type SelectorContext,
-  type StateSource,
-} from '../store/createStateSourceAction'
-import {defineStore, type StoreContext} from '../store/defineStore'
-import {insecureRandomId} from '../utils/ids'
-import {omitProperty} from '../utils/object'
-import {setCleanupTimeout} from './setCleanupTimeout'
-
-interface CreateFetcherStoreOptions<TParams extends unknown[], TData> {
-  /**
-   * A unique name for this store (for devtools)
-   */
-  name: string
-  /**
-   * A function that creates the observable that will be used to fetch the data.
-   */
-  fetcher: (instance: SanityInstance) => (...params: TParams) => Observable<TData>
-  /**
-   * The function used to convert the params into keys that state related to
-   * those params will be stored.
-   */
-  getKey: (instance: SanityInstance, ...params: TParams) => string
-  /**
-   * Delay in ms before clearing state after the last subscription is removed.
-   * This results in react components suspending again due to no previous state
-   * to show.
-   */
-  stateExpirationDelay?: number
-  /**
-   * The minimum time (ms) that must elapse since the last fetch for the same key
-   */
-  fetchThrottleInternal?: number
-}
-
-interface StoreEntry<TParams extends unknown[], TData> {
-  params: TParams
-  instance: SanityInstance
-  key: string
-  data?: TData
-  error?: unknown
-  subscriptions: string[]
-  lastFetchInitiatedAt?: string
-}
-
-/**
- * Internal helper type
- * @public
- */
-export interface FetcherStoreState<TParams extends unknown[], TData> {
-  stateByParams: {[TSerializedKey in string]?: StoreEntry<TParams, TData>}
-  error?: unknown
-}
-
-/**
- * Internal helper type
- * @public
- */
-export interface FetcherStore<TParams extends unknown[], TData> {
-  getState: BoundStoreAction<
-    FetcherStoreState<TParams, TData>,
-    TParams,
-    StateSource<TData | undefined>
-  >
-  resolveState: BoundStoreAction<FetcherStoreState<TParams, TData>, TParams, Promise<TData>>
-}
-
-/**
- * Creates a store from a function that returns an observable that fetches data
- * that supports parameterized state caching.
- *
- * This function creates a resource store keyed by parameter values (using the
- * provided `getKey` function) and returns a state source (via `getState`)
- * that components can subscribe to. When a new subscription is added, and if
- * enough time has passed since the last fetch (controlled by
- * `fetchThrottleInternal`), it invokes the observable factory (via
- * `getObservable`) to fetch fresh data. The data is stored in state and can be
- * accessed reactively.
- *
- * Additionally, the store provides a `resolveState` function that returns a
- * Promise resolving with the next non-undefined value from the state source.
- *
- * State expiration is implemented: after the last subscription for a key is
- * removed, its state is cleared after `stateExpirationDelay` ms, causing
- * components to suspend until fresh data is fetched.
- */
-export function createFetcherStore<TParams extends unknown[], TData>({
-  name,
-  fetcher: getObservable,
-  getKey,
-  fetchThrottleInternal = 1000,
-  stateExpirationDelay = 5000,
-}: CreateFetcherStoreOptions<TParams, TData>): FetcherStore<TParams, TData> {
-  const store = defineStore<FetcherStoreState<TParams, TData>>({
-    name,
-    getInitialState: () => ({
-      stateByParams: {},
-    }),
-    initialize: (context) => {
-      const subscription = subscribeToSubscriptionsAndFetch(context)
-      return () => subscription.unsubscribe()
-    },
-  })
-
-  /**
-   * For each key in state.stateByParams we set up a grouped stream.
-   * When a subscription is added (i.e. the subscriptions array length increases)
-   * and if enough time has elapsed since the last fetch, we update the timestamp
-   * and call the factory function for that key.
-   */
-  const subscribeToSubscriptionsAndFetch = ({
-    state,
-  }: StoreContext<FetcherStoreState<TParams, TData>>) => {
-    return state.observable
-      .pipe(
-        // Map the state to an array of [serialized, entry] pairs.
-        switchMap((s: FetcherStoreState<TParams, TData>) => {
-          const entries = Object.entries(s.stateByParams)
-          return entries.length > 0 ? from(entries) : EMPTY
-        }),
-        // Group by the serialized key.
-        groupBy(([key]) => key),
-        mergeMap((group$) =>
-          group$.pipe(
-            // Emit an initial value for pairwise comparisons.
-            startWith<[string, StoreEntry<TParams, TData> | undefined]>([group$.key, undefined]),
-            pairwise(),
-            // Trigger only when the subscriptions array grows.
-            filter(([[, prevEntry], [, currEntry]]) => {
-              const prevSubs = prevEntry?.subscriptions ?? []
-              const currSubs = currEntry?.subscriptions ?? []
-              return currSubs.length > prevSubs.length
-            }),
-            map(([, [, currEntry]]) => currEntry),
-
-            // Only trigger if we haven't fetched recently.
-            filter((entry) => {
-              const lastFetch = entry?.lastFetchInitiatedAt
-              if (!lastFetch) return true
-              return Date.now() - new Date(lastFetch).getTime() >= fetchThrottleInternal
-            }),
-            switchMap((entry) => {
-              // Retrieve params from the entry
-              if (!entry) return EMPTY
-
-              // Record that a fetch is being initiated.
-              state.set('setLastFetchInitiatedAt', (prev: FetcherStoreState<TParams, TData>) => ({
-                stateByParams: {
-                  ...prev.stateByParams,
-                  [entry.key]: {
-                    ...entry,
-                    ...prev.stateByParams[entry.key],
-                    lastFetchInitiatedAt: new Date().toISOString(),
-                  },
-                },
-              }))
-
-              const factoryFn = getObservable(entry.instance)
-              return factoryFn(...entry.params).pipe(
-                // the `createStateSourceAction` util requires the update
-                // to
-                delay(0, asapScheduler),
-                tap((data: TData) =>
-                  state.set('setData', (prev: FetcherStoreState<TParams, TData>) => ({
-                    stateByParams: {
-                      ...prev.stateByParams,
-                      [entry.key]: {
-                        ...omitProperty(entry, 'error'),
-                        ...(prev.stateByParams[entry.key]
-                          ? omitProperty(prev.stateByParams[entry.key], 'error')
-                          : {}),
-                        data,
-                      },
-                    },
-                  })),
-                ),
-                catchError((error) => {
-                  state.set('setError', (prev) => ({
-                    stateByParams: {
-                      ...prev.stateByParams,
-                      [entry.key]: {
-                        ...entry,
-                        ...prev.stateByParams[entry.key],
-                        error,
-                      },
-                    },
-                  }))
-
-                  return EMPTY
-                }),
-              )
-            }),
-          ),
-        ),
-      )
-      .subscribe({
-        error: (error) => state.set('setError', {error}),
-      })
-  }
-
-  const getState = bindActionGlobally(
-    store,
-    createStateSourceAction({
-      selector: (
-        {
-          instance,
-          state: {stateByParams, error},
-        }: SelectorContext<FetcherStoreState<TParams, TData>>,
-        ...params: TParams
-      ) => {
-        if (error) throw error
-        const key = getKey(instance, ...params)
-        const entry = stateByParams[key]
-        if (entry?.error) throw entry.error
-        return entry?.data
-      },
-      onSubscribe: ({instance, state}, ...params: TParams) => {
-        const subscriptionId = insecureRandomId()
-        const key = getKey(instance, ...params)
-
-        state.set('addSubscription', (prev: FetcherStoreState<TParams, TData>) => ({
-          stateByParams: {
-            ...prev.stateByParams,
-            [key]: {
-              ...prev.stateByParams[key],
-              instance,
-              key,
-              params: prev.stateByParams[key]?.params || params,
-              subscriptions: [...(prev.stateByParams[key]?.subscriptions || []), subscriptionId],
-            },
-          },
-        }))
-
-        return () => {
-          setCleanupTimeout(() => {
-            state.set('removeSubscription', (prev: FetcherStoreState<TParams, TData>) => {
-              const entry = prev.stateByParams[key]
-              if (!entry) return prev
-
-              const newSubs = (entry.subscriptions || []).filter((id) => id !== subscriptionId)
-              if (newSubs.length === 0) {
-                return {stateByParams: omitProperty(prev.stateByParams, key)}
-              }
-
-              return {
-                stateByParams: {
-                  ...prev.stateByParams,
-                  [key]: {
-                    ...entry,
-                    subscriptions: newSubs,
-                  },
-                },
-              }
-            })
-          }, stateExpirationDelay)
-        }
-      },
-    }),
-  )
-
-  const resolveState = bindActionGlobally(store, ({instance}, ...params: TParams) =>
-    firstValueFrom(getState(instance, ...params).observable.pipe(first((i) => i !== undefined))),
-  )
-
-  return {getState, resolveState}
-}