@sanity/sdk 2.20.1 → 2.20.2

package/dist/{telemetryManager-w-AMXtmz.js → telemetryManager-BmGqzj0b.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-vyAXikos.js";
 import { r as createLogger } from "./getEnv-76AjZd_f.js";
-import { t as CORE_SDK_VERSION } from "./version-ByqNiWrK.js";
+import { t as CORE_SDK_VERSION } from "./version-CPumgx0u.js";
 import "@sanity/client";
 import { createBatchedStore, defineEvent } from "@sanity/telemetry";
 /** @internal */
@@ -124,4 +124,4 @@ function createTelemetryManager(options) {
 }
 export { telemetryManager_exports as t };
 
-//# sourceMappingURL=telemetryManager-w-AMXtmz.js.map
+//# sourceMappingURL=telemetryManager-BmGqzj0b.js.map

package/dist/{telemetryManager-w-AMXtmz.js.map → telemetryManager-BmGqzj0b.js.map}

@@ -1 +1 @@
-{"version":3,"file":"telemetryManager-w-AMXtmz.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"}
+{"version":3,"file":"telemetryManager-BmGqzj0b.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-ByqNiWrK.js → version-CPumgx0u.js}

@@ -3,7 +3,7 @@ import { t as getEnv } from "./getEnv-76AjZd_f.js";
 * This version is provided by pkg-utils at build time
 * @internal
 */
-const CORE_SDK_VERSION = getEnv("PKG_VERSION") || "2.20.1-development";
+const CORE_SDK_VERSION = getEnv("PKG_VERSION") || "2.20.2-development";
 export { CORE_SDK_VERSION as t };
 
-//# sourceMappingURL=version-ByqNiWrK.js.map
+//# sourceMappingURL=version-CPumgx0u.js.map

package/dist/{version-ByqNiWrK.js.map → version-CPumgx0u.js.map}

@@ -1 +1 @@
-{"version":3,"file":"version-ByqNiWrK.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"}
+{"version":3,"file":"version-CPumgx0u.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/sdk",
-  "version": "2.20.1",
+  "version": "2.20.2",
   "private": false,
   "description": "Sanity SDK",
   "keywords": [

package/src/document/documentConstants.ts

@@ -9,6 +9,15 @@ export const DOCUMENT_STATE_CLEAR_DELAY = 1000
 export const INITIAL_OUTGOING_THROTTLE_TIME = 1000
 export const API_VERSION = 'v2025-05-06'
 
+/**
+ * How long a submitted transaction's revision is kept around waiting to be
+ * verified by its listener echo. After this, the transaction is no longer
+ * treated as in flight and a document held onto only for that verification can
+ * be evicted. Sized to match the listener's own chaining deadline, after which
+ * an echo that has not arrived is not going to.
+ */
+export const UNVERIFIED_REVISION_RETENTION_TIME = 30_000
+
 /**
  * Base delay (ms) before retrying a document listener after an `OutOfSyncError`.
  * Backoff doubles on each successive retry, capped at {@link OUT_OF_SYNC_RETRY_MAX_DELAY}.

package/src/document/documentStore.test.ts

@@ -357,6 +357,75 @@ it('emits remote-patches events distinguishing own and foreign transactions', as
   state2Unsubscribe()
 })
 
+it('labels an echo that arrives after the last subscriber left as its own', async () => {
+  const doc = createDocumentHandle({documentId: 'existing-doc', documentType: 'article'})
+  const draftId = getDraftId(DocumentId(doc.documentId))
+  const state = getDocumentState(instance, doc)
+  const unsubscribe = state.subscribe()
+  await vi.waitUntil(() => state.getCurrent() !== undefined)
+  const previousRev = state.getCurrent()?._rev
+
+  // ack without emitting the listener echo, so the echo can be delivered later
+  // and out of band, which is the ordering the real API produces
+  const clientActionMockImplementation = vi.mocked(client.action).getMockImplementation()!
+  vi.mocked(client.action).mockImplementation(
+    async (_input, {transactionId = crypto.randomUUID()} = {}) => ({transactionId}),
+  )
+
+  const patchEvents: DocumentRemotePatchesEvent[] = []
+  const unsubscribeEvents = subscribeDocumentEvents(instance, {
+    resource,
+    eventHandler: (e) => {
+      if (e.type === 'remote-patches') patchEvents.push(e)
+    },
+  })
+
+  const edited = await applyDocumentActions(instance, {
+    actions: [editDocument(doc, {set: {title: 'edited while leaving'}})],
+    resource,
+  })
+
+  // the last subscriber leaves before the ack comes back, which used to delete
+  // the document state (and with it the memory of our own transaction) as soon
+  // as the ack released the transaction's subscription
+  unsubscribe()
+  await new Promise((resolve) => setTimeout(resolve, 50))
+  await edited.submitted()
+
+  const {events: listenerEvents} = (
+    createSharedListener as () => {
+      dispose: () => void
+      events: Subject<ListenEvent<SanityDocument>>
+    }
+  )()
+  listenerEvents.next({
+    type: 'mutation',
+    documentId: draftId,
+    eventId: `${edited.transactionId}#${draftId}`,
+    identity: 'example-user',
+    mutations: [{patch: {id: draftId, set: {title: 'edited while leaving'}}}],
+    timestamp: new Date().toISOString(),
+    transactionId: edited.transactionId,
+    transactionCurrentEvent: 1,
+    transactionTotalEvents: 1,
+    transition: 'update',
+    visibility: 'query',
+    previousRev,
+    resultRev: edited.transactionId,
+  } satisfies MutationEvent)
+  await vi.waitUntil(() => patchEvents.length > 0)
+
+  expect(patchEvents).toHaveLength(1)
+  expect(patchEvents[0]).toMatchObject({
+    documentId: draftId,
+    transactionId: edited.transactionId,
+    origin: 'local',
+  })
+
+  unsubscribeEvents()
+  vi.mocked(client.action).mockImplementation(clientActionMockImplementation)
+})
+
 it('handles concurrent edits and resolves conflicts', async () => {
   const doc = createDocumentHandle({documentId: 'doc-concurrent', documentType: 'article'})
   const state1 = getDocumentState(instance1, doc)

package/src/document/reducers.test.ts

@@ -4,6 +4,7 @@ import {parse} from 'groq-js'
 import {Subject} from 'rxjs'
 import {describe, expect, it} from 'vitest'
 
+import {UNVERIFIED_REVISION_RETENTION_TIME} from './documentConstants'
 import {type DocumentEvent} from './events'
 import {type RemoteDocument} from './listen'
 import {type DocumentSet} from './processMutations'
@@ -556,6 +557,118 @@ describe('cleanupOutgoingTransaction', () => {
   })
 })
 
+describe('document state retention between ack and echo', () => {
+  const docId = 'doc1'
+  const justNow = new Date().toISOString()
+  const longAgo = new Date(Date.now() - UNVERIFIED_REVISION_RETENTION_TIME - 1000).toISOString()
+
+  const outgoing: NonNullable<SyncTransactionState['outgoing']> = {
+    transactionId: 'txnOut',
+    actions: [
+      {
+        type: 'document.edit',
+        documentId: docId,
+        documentType: 'book',
+        liveEdit: true,
+        patches: [{set: {foo: 'changed'}}],
+      },
+    ],
+    disableBatching: false,
+    batchedTransactionIds: ['txnOut'],
+    outgoingActions: [],
+    outgoingMutations: [],
+    base: {},
+    working: {},
+    previous: {},
+    previousRevs: {},
+    timestamp: justNow,
+  }
+
+  const unverifiedRevision = (timestamp: string) => ({
+    txnOut: {transactionId: 'txnOut', documentId: docId, previousRev: 'txn0', timestamp},
+  })
+
+  const stateAfterAck = (timestamp: string): SyncTransactionState => ({
+    queued: [],
+    applied: [],
+    outgoing,
+    grants,
+    documentStates: {
+      [docId]: {
+        id: docId,
+        // the UI unsubscribed before the ack arrived, so the transaction's
+        // own subscription id is the only one left
+        subscriptions: ['txnOut'],
+        local: {...exampleDoc, _id: docId, foo: 'changed'},
+        remote: {...exampleDoc, _id: docId, foo: 'old'},
+        unverifiedRevisions: unverifiedRevision(timestamp),
+        recentOwnTransactionIds: ['txnOut'],
+      },
+    },
+  })
+
+  it('keeps echo-recognition memory alive through cleanup so a late echo still labels "local"', () => {
+    // the HTTP ack arrives and cleans up the outgoing transaction's
+    // subscription. previously this deleted the whole DocumentState
+    // immediately, before the listener echo had a chance to arrive
+    const afterCleanup = cleanupOutgoingTransaction(stateAfterAck(justNow))
+    expect(afterCleanup.outgoing).toBeUndefined()
+
+    const docStateAfterCleanup = afterCleanup.documentStates[docId]
+    expect(docStateAfterCleanup).toBeDefined()
+    expect(docStateAfterCleanup?.subscriptions).toEqual([])
+    expect(docStateAfterCleanup?.unverifiedRevisions?.['txnOut']).toBeDefined()
+
+    // now the echo finally arrives over the shared listener
+    const events = new Subject<DocumentEvent>()
+    const received: DocumentEvent[] = []
+    events.subscribe((e) => received.push(e))
+
+    const echo: RemoteDocument = {
+      type: 'mutation',
+      documentId: docId,
+      document: {...exampleDoc, _id: docId, foo: 'changed'},
+      revision: 'txnOut',
+      previousRev: 'txn0',
+      timestamp: new Date().toISOString(),
+      mutations: [{patch: {id: docId, set: {foo: 'changed'}}}],
+    }
+
+    const afterEcho = applyRemoteDocument(afterCleanup, echo, events)
+
+    const remotePatchesEvents = received.filter((e) => e.type === 'remote-patches')
+    expect(remotePatchesEvents).toHaveLength(1)
+    expect(remotePatchesEvents[0]).toMatchObject({origin: 'local', transactionId: 'txnOut'})
+
+    // the echo verified the revision and nothing was subscribed any more, so
+    // the now fully-idle document state can finally be evicted
+    expect(afterEcho.documentStates[docId]).toBeUndefined()
+  })
+
+  it('stops waiting for an echo that is older than the retention time', () => {
+    // an accepted transaction whose operations all no-op server-side never
+    // produces an echo, so the wait has to expire or the document (and its
+    // listener) would be pinned for the lifetime of the store
+    const afterCleanup = cleanupOutgoingTransaction(stateAfterAck(longAgo))
+    expect(afterCleanup.documentStates[docId]).toBeUndefined()
+  })
+
+  it('does not extend the wait on `recentOwnTransactionIds` alone', () => {
+    const state = stateAfterAck(justNow)
+    const documentState = state.documentStates[docId]!
+    const withoutUnverifiedRevisions: SyncTransactionState = {
+      ...state,
+      documentStates: {
+        [docId]: {...documentState, unverifiedRevisions: {}, recentOwnTransactionIds: ['txnOut']},
+      },
+    }
+
+    expect(
+      cleanupOutgoingTransaction(withoutUnverifiedRevisions).documentStates[docId],
+    ).toBeUndefined()
+  })
+})
+
 describe('revertOutgoingTransaction', () => {
   it('reverts the outgoing transaction and updates documentStates by removing unverified revisions', () => {
     const draftId = getDraftId(DocumentId('doc1'))
@@ -686,6 +799,117 @@ describe('revertOutgoingTransaction', () => {
     // transaction id is gone from its subscriptions
     expect(newState.documentStates[pubId]?.subscriptions).toEqual(['sub-ui'])
   })
+
+  it('evicts a document left with no subscribers once its unverified revision is discarded', () => {
+    const docId = 'doc1'
+    const state: SyncTransactionState = {
+      queued: [],
+      applied: [],
+      outgoing: {
+        transactionId: 'txnOut',
+        actions: [
+          {
+            type: 'document.edit',
+            documentId: docId,
+            documentType: 'book',
+            liveEdit: true,
+            patches: [{set: {foo: 'changed'}}],
+          },
+        ],
+        disableBatching: false,
+        batchedTransactionIds: ['txnOut'],
+        outgoingActions: [],
+        outgoingMutations: [],
+        base: {},
+        working: {},
+        previous: {},
+        previousRevs: {},
+        timestamp: new Date().toISOString(),
+      },
+      grants,
+      documentStates: {
+        // the reverted transaction was this document's last subscriber, so the
+        // revision discarded below is the only thing keeping it around
+        [docId]: {
+          id: docId,
+          subscriptions: [],
+          local: {...exampleDoc, _id: docId, foo: 'changed'},
+          remote: {...exampleDoc, _id: docId, foo: 'old'},
+          unverifiedRevisions: {
+            txnOut: {
+              transactionId: 'txnOut',
+              documentId: docId,
+              previousRev: 'txn0',
+              timestamp: new Date().toISOString(),
+            },
+          },
+        },
+      },
+    }
+
+    expect(revertOutgoingTransaction(state).documentStates[docId]).toBeUndefined()
+  })
+
+  it('leaves `local` intact for a document still waiting on its own acked transaction', () => {
+    const revertedId = 'doc-reverted'
+    const retainedId = 'doc-retained'
+    const state: SyncTransactionState = {
+      queued: [],
+      applied: [],
+      outgoing: {
+        transactionId: 'txnOut',
+        actions: [
+          {
+            type: 'document.edit',
+            documentId: revertedId,
+            documentType: 'book',
+            liveEdit: true,
+            patches: [{set: {foo: 'changed'}}],
+          },
+        ],
+        disableBatching: false,
+        batchedTransactionIds: ['txnOut'],
+        outgoingActions: [],
+        outgoingMutations: [],
+        base: {},
+        working: {},
+        previous: {},
+        previousRevs: {},
+        timestamp: new Date().toISOString(),
+      },
+      grants,
+      documentStates: {
+        [revertedId]: {
+          id: revertedId,
+          subscriptions: ['txnOut'],
+          local: {...exampleDoc, _id: revertedId, foo: 'changed'},
+          remote: {...exampleDoc, _id: revertedId, foo: 'old'},
+        },
+        // unrelated to the reverted batch: acked, unsubscribed, and still
+        // waiting on the echo that will settle its optimistic value
+        [retainedId]: {
+          id: retainedId,
+          subscriptions: [],
+          local: {...exampleDoc, _id: retainedId, foo: 'acked'},
+          remote: {...exampleDoc, _id: retainedId, foo: 'old'},
+          unverifiedRevisions: {
+            txnAcked: {
+              transactionId: 'txnAcked',
+              documentId: retainedId,
+              previousRev: 'txn0',
+              timestamp: new Date().toISOString(),
+            },
+          },
+        },
+      },
+    }
+
+    const newState = revertOutgoingTransaction(state)
+    // the reverted document's only subscriber was the batch itself, so
+    // unregistering it evicts the state
+    expect(newState.documentStates[revertedId]).toBeUndefined()
+    expect(newState.documentStates[retainedId]?.local).toMatchObject({foo: 'acked'})
+  })
 })
 
 describe('applyRemoteDocument', () => {

package/src/document/reducers.ts

@@ -8,7 +8,7 @@ import {insecureRandomId} from '../utils/ids'
 import {isDeepEqual, omitProperty} from '../utils/object'
 import {setCleanupTimeout} from '../utils/setCleanupTimeout'
 import {type Action} from './actions'
-import {DOCUMENT_STATE_CLEAR_DELAY} from './documentConstants'
+import {DOCUMENT_STATE_CLEAR_DELAY, UNVERIFIED_REVISION_RETENTION_TIME} from './documentConstants'
 import {type DocumentState, type DocumentStoreState} from './documentStore'
 import {type RemoteDocument} from './listen'
 import {ActionError, processActions} from './processActions/processActions'
@@ -401,7 +401,13 @@ export function cleanupOutgoingTransaction(prev: SyncTransactionState): SyncTran
     }
   }
 
-  return {...next, outgoing: undefined}
+  // every ack is also when a previously retained document's echo may have
+  // stopped being expected, so re-make that eviction decision here
+  return {
+    ...next,
+    outgoing: undefined,
+    documentStates: evictOrphanedDocumentStates(next.documentStates),
+  }
 }
 
 export function revertOutgoingTransaction(prev: SyncTransactionState): SyncTransactionState {
@@ -446,20 +452,38 @@ export function revertOutgoingTransaction(prev: SyncTransactionState): SyncTrans
     ...base,
     applied: nextApplied,
     outgoing: undefined,
-    documentStates: Object.fromEntries(
-      Object.entries(base.documentStates)
-        .filter((e): e is [string, DocumentState] => !!e[1])
-        .map(([documentId, {unverifiedRevisions = {}, local, ...documentState}]) => {
-          const next: DocumentState = {
-            ...documentState,
-            local: documentId in working ? working[documentId] : local,
-            unverifiedRevisions:
-              prev.outgoing && prev.outgoing.transactionId in unverifiedRevisions
-                ? omitProperty(unverifiedRevisions, prev.outgoing.transactionId)
-                : unverifiedRevisions,
-          }
-          return [documentId, next] as const
-        }),
+    // discarding the outgoing transaction drops its echo-recognition memory,
+    // which can leave a document that was only being kept alive for that echo
+    // with nothing left to wait for, so sweep afterwards
+    documentStates: evictOrphanedDocumentStates(
+      Object.fromEntries(
+        Object.entries(base.documentStates)
+          .filter((e): e is [string, DocumentState] => !!e[1])
+          .map(([documentId, documentState]) => {
+            const {unverifiedRevisions = {}} = documentState
+            const next: DocumentState = {
+              ...documentState,
+              unverifiedRevisions:
+                prev.outgoing && prev.outgoing.transactionId in unverifiedRevisions
+                  ? omitProperty(unverifiedRevisions, prev.outgoing.transactionId)
+                  : unverifiedRevisions,
+            }
+
+            // a document with no subscribers that is still waiting on the echo
+            // of a different, already acked transaction of its own is not
+            // represented in `working` (only `applied` transactions are
+            // re-applied above), so rebuilding its `local` from `remote` would
+            // drop that transaction's effect. leave it for the echo to resolve
+            if (!next.subscriptions.length && isAwaitingOwnEcho(next)) {
+              return [documentId, next] as const
+            }
+
+            return [
+              documentId,
+              {...next, local: documentId in working ? working[documentId] : next.local},
+            ] as const
+          }),
+      ),
     ),
   }
 }
@@ -579,7 +603,7 @@ export function applyRemoteDocument(
 
     return {
       ...prev,
-      documentStates: {
+      documentStates: evictOrphanedDocumentStates({
         ...prev.documentStates,
         [documentId]: {
           ...prevDocState,
@@ -588,7 +612,7 @@ export function applyRemoteDocument(
           local,
           unverifiedRevisions,
         },
-      },
+      }),
     }
   }
 
@@ -645,7 +669,7 @@ export function applyRemoteDocument(
   return {
     ...prev,
     applied: nextApplied,
-    documentStates: {
+    documentStates: evictOrphanedDocumentStates({
       ...prev.documentStates,
       [documentId]: {
         ...prevDocState,
@@ -654,7 +678,7 @@ export function applyRemoteDocument(
         local,
         unverifiedRevisions,
       },
-    },
+    }),
   }
 }
 
@@ -685,22 +709,81 @@ export function removeSubscriptionIdFromDocument(
   subscriptionId: string,
 ): SyncTransactionState {
   const prevDocState = prev.documentStates?.[documentId]
-  const prevSubscriptions = prevDocState?.subscriptions ?? []
-  const subscriptions = prevSubscriptions.filter((id) => id !== subscriptionId)
-
   if (!prevDocState) return prev
-  if (!subscriptions.length) {
+
+  const subscriptions = prevDocState.subscriptions.filter((id) => id !== subscriptionId)
+
+  // a document with no subscribers left is normally evicted below, but if a
+  // transaction was just submitted for it, its echo-recognition memory
+  // (`unverifiedRevisions`) is still waiting on the listener echo.
+  // `cleanupOutgoingTransaction` removes the outgoing transaction's own
+  // subscription right at HTTP ack, before the echo arrives, so deleting the
+  // state here would lose that memory and make the echo mislabel as
+  // `origin: 'remote'` (or, worse, get skipped outright). keep the state
+  // alive, unsubscribed, until the echo verifies or the wait expires
+  if (!subscriptions.length && !isAwaitingOwnEcho(prevDocState)) {
     return {...prev, documentStates: omitProperty(prev.documentStates, documentId)}
   }
+
   return {
     ...prev,
     documentStates: {
       ...prev.documentStates,
-      [documentId]: {...prevDocState, subscriptions: subscriptions},
+      [documentId]: {...prevDocState, subscriptions},
     },
   }
 }
 
+/**
+ * Whether this document still expects the listener echo of one of its own
+ * submitted transactions. That expectation is the only reason a document state
+ * with no subscribers is kept around.
+ *
+ * Revisions stop counting after `UNVERIFIED_REVISION_RETENTION_TIME` because an
+ * echo is not guaranteed to arrive at all: Content Lake records no transaction
+ * when every operation resolves to a no-op (e.g. a keyed path that no longer
+ * exists), while the client bumps `_rev` regardless and so tracks a revision
+ * for it. Without the expiry, such a document (and the listener keyed off its
+ * state) would be pinned for the lifetime of the store.
+ *
+ * `recentOwnTransactionIds` deliberately does not extend the wait: it is capped
+ * rather than drained, so honoring it would keep every edited document alive.
+ */
+function isAwaitingOwnEcho(documentState: DocumentState): boolean {
+  const expiresAfter = Date.now() - UNVERIFIED_REVISION_RETENTION_TIME
+  return Object.values(documentState.unverifiedRevisions ?? {}).some(
+    (revision) => !!revision && new Date(revision.timestamp).getTime() > expiresAfter,
+  )
+}
+
+/**
+ * Removes every document state that has no subscribers left and no own
+ * transaction still awaiting its echo.
+ *
+ * This is a sweep rather than a decision made where the last subscriber leaves
+ * because `removeSubscriptionIdFromDocument` defers that eviction while an echo
+ * is in flight, and both halves of the condition can change without a
+ * subscriber going anywhere: the echo can verify, be dropped by a sync, be
+ * discarded by a revert, or simply never arrive. Every reducer that can settle
+ * an in-flight transaction sweeps, so the deferred decision is always re-made.
+ *
+ * Note this can evict the very document whose remote event is being processed,
+ * which synchronously unsubscribes that document's listener from inside its own
+ * emission (see `subscribeToSubscriptionsAndListenToDocuments`).
+ */
+function evictOrphanedDocumentStates(
+  documentStates: SyncTransactionState['documentStates'],
+): SyncTransactionState['documentStates'] {
+  let next = documentStates
+  for (const [documentId, documentState] of Object.entries(documentStates)) {
+    if (!documentState) continue
+    if (documentState.subscriptions.length) continue
+    if (isAwaitingOwnEcho(documentState)) continue
+    next = omitProperty(next, documentId)
+  }
+  return next
+}
+
 export function manageSubscriberIds(
   {state}: StoreContext<SyncTransactionState>,
   handles: DocumentHandleLike[],