@sanity/sdk 3.0.0-rc.2 → 3.1.0

package/src/users/usersStore.ts

@@ -30,7 +30,7 @@ import {bindActionGlobally} from '../store/createActionBinder'
 import {createStateSourceAction, type SelectorContext} from '../store/createStateSourceAction'
 import {type StoreState} from '../store/createStoreState'
 import {defineStore, type StoreContext} from '../store/defineStore'
-import {insecureRandomId} from '../utils/ids'
+import {randomId} from '../utils/ids'
 import {setCleanupTimeout} from '../utils/setCleanupTimeout'
 import {
   addSubscription,
@@ -130,7 +130,7 @@ const listenForLoadMoreAndFetch = ({state, instance}: StoreContext<UsersStoreSta
                 return client.observable
                   .request<PatchedSanityUserFromClient>({
                     method: 'GET',
-                    uri: `/users/${userId}`,
+                    url: `/users/${userId}`,
                     tag: 'users.get',
                   })
                   .pipe(
@@ -184,7 +184,7 @@ const listenForLoadMoreAndFetch = ({state, instance}: StoreContext<UsersStoreSta
               return client.observable
                 .request<SanityUser | SanityUserResponse>({
                   method: 'GET',
-                  uri: `access/${resourceType}/${resourceId}/users/${userId}`,
+                  url: `access/${resourceType}/${resourceId}/users/${userId}`,
                   tag: 'users.get',
                 })
                 .pipe(
@@ -253,7 +253,7 @@ const listenForLoadMoreAndFetch = ({state, instance}: StoreContext<UsersStoreSta
               switchMap(([[resource, client], cursor]) =>
                 client.observable.request<SanityUserResponse>({
                   method: 'GET',
-                  uri: `access/${resource.type}/${resource.id}/users`,
+                  url: `access/${resource.type}/${resource.id}/users`,
                   tag: 'users.list',
                   query: cursor
                     ? {nextCursor: cursor, limit: batchSize.toString()}
@@ -310,7 +310,7 @@ export const getUsersState = bindActionGlobally(
       },
     ),
     onSubscribe: ({instance, state}, options?: GetUsersOptions) => {
-      const subscriptionId = insecureRandomId()
+      const subscriptionId = randomId(16)
       const key = getUsersKey(instance, options)
       state.set('addSubscription', addSubscription(subscriptionId, key))
       return () => {

package/src/utils/ids.test.ts

@@ -1,26 +1,51 @@
-import {describe, expect, it} from 'vitest'
+import {afterEach, describe, expect, it, vi} from 'vitest'
 
-import {insecureRandomId} from './ids'
+import {randomId, randomUuid} from './ids'
 
-describe('insecureRandomId', () => {
-  it('should generate 16-character string', () => {
-    expect(insecureRandomId()).toHaveLength(16)
+describe('randomId', () => {
+  it('should generate an 8-character base62 id by default', () => {
+    expect(randomId()).toMatch(/^[a-zA-Z0-9]{8}$/)
   })
 
-  it('should generate hex string', () => {
-    expect(insecureRandomId()).toMatch(/^[0-9a-f]{16}$/)
+  it('should generate an id of the given length', () => {
+    expect(randomId(16)).toMatch(/^[a-zA-Z0-9]{16}$/)
   })
 
   it('should generate different ids on each call', () => {
-    const id1 = insecureRandomId()
-    const id2 = insecureRandomId()
-    expect(id1).not.toBe(id2)
+    expect(randomId()).not.toBe(randomId())
+  })
+})
+
+describe('randomUuid', () => {
+  const uuidV4Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('should generate a v4 UUID', () => {
+    expect(randomUuid()).toMatch(uuidV4Pattern)
+  })
+
+  it('should use crypto.randomUUID when available', () => {
+    vi.stubGlobal('crypto', {randomUUID: () => 'native-uuid'})
+    expect(randomUuid()).toBe('native-uuid')
+  })
+
+  it('should generate a v4 UUID when crypto.randomUUID is unavailable (insecure contexts)', () => {
+    const originalCrypto = globalThis.crypto
+    vi.stubGlobal('crypto', {
+      getRandomValues: (array: Uint8Array<ArrayBuffer>) => originalCrypto.getRandomValues(array),
+    })
+    expect(randomUuid()).toMatch(uuidV4Pattern)
   })
 
-  it('should generate properly formatted strings multiple times', () => {
-    for (let i = 0; i < 100; i++) {
-      const id = insecureRandomId()
-      expect(id).toMatch(/^[0-9a-f]{16}$/)
-    }
+  it('should generate unique ids when crypto.randomUUID is unavailable', () => {
+    const originalCrypto = globalThis.crypto
+    vi.stubGlobal('crypto', {
+      getRandomValues: (array: Uint8Array<ArrayBuffer>) => originalCrypto.getRandomValues(array),
+    })
+    const ids = new Set(Array.from({length: 100}, () => randomUuid()))
+    expect(ids.size).toBe(100)
   })
 })

package/src/utils/ids.ts

@@ -1,3 +1,48 @@
-export function insecureRandomId(): string {
-  return Array.from({length: 16}, () => Math.floor(Math.random() * 16).toString(16)).join('')
+const ID_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+
+/**
+ * Generates a random ID of the given length from the alphabet `[a-zA-Z0-9]`, the same shape
+ * `@sanity/client` and Sanity Studio use for short IDs such as release IDs.
+ *
+ * Ported from `@sanity/client`'s `generateReleaseId`, which uses rejection sampling to keep
+ * the output unbiased. Uses `crypto.getRandomValues`, which unlike `crypto.randomUUID` is
+ * also available on insecure origins (plain http).
+ *
+ * @internal
+ */
+export function randomId(length: number = 8): string {
+  let id = ''
+  while (id.length < length) {
+    const bytes = crypto.getRandomValues(new Uint8Array(length - id.length))
+    for (const byte of bytes) {
+      const index = byte & 63
+      if (index < ID_ALPHABET.length) id += ID_ALPHABET.charAt(index)
+    }
+  }
+  return id
+}
+
+/**
+ * Generates a random v4 UUID.
+ *
+ * Prefers the native `crypto.randomUUID`, which is only available in secure contexts
+ * (https, localhost). Falls back to deriving the UUID from `crypto.getRandomValues`,
+ * which has no such restriction, so ID generation also works when an app is served over
+ * plain http, e.g. when testing from a phone on a local network.
+ *
+ * @internal
+ */
+export function randomUuid(): string {
+  // eslint-disable-next-line no-restricted-properties -- this is the sanctioned wrapper around crypto.randomUUID
+  if (typeof crypto.randomUUID === 'function') return crypto.randomUUID()
+
+  const bytes = crypto.getRandomValues(new Uint8Array(16))
+  const hex = Array.from(bytes, (byte, index) => {
+    // Set the version (4) and variant (RFC 4122) bits
+    if (index === 6) byte = (byte & 0x0f) | 0x40
+    if (index === 8) byte = (byte & 0x3f) | 0x80
+    return byte.toString(16).padStart(2, '0')
+  }).join('')
+
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`
 }

package/dist/authStore-DKFX8fn7.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"authStore-DKFX8fn7.d.ts","names":[],"sources":["../src/store/createStoreState.ts","../src/store/defineStore.ts","../src/store/createActionBinder.ts","../src/store/createStateSourceAction.ts","../src/store/fetcherStore.ts","../src/access/checkPermissions.ts","../src/utils/includeShape.ts","../src/applications/applications.ts","../src/auth/authStateType.ts","../src/project/organizationVerification.ts","../src/auth/getOrganizationVerificationState.ts","../src/auth/handleAuthCallback.ts","../src/auth/logout.ts","../src/client/clientStore.ts","../src/comments/types.ts","../src/comments/commentActions.ts","../src/comments/commentsStore.ts","../src/config/handles.ts","../src/utils/logger.ts","../src/config/loggingConfig.ts","../src/datasets/datasets.ts","../src/document/actions.ts","../src/document/patchOperations.ts","../src/document/processMutations.ts","../src/document/permissions.ts","../src/document/sharedListener.ts","../src/document/documentStore.ts","../src/document/reducers.ts","../src/document/events.ts","../src/document/applyDocumentActions.ts","../src/document/processActions/releaseUtil.ts","../src/favorites/favorites.ts","../src/installations/installations.ts","../src/organization/organization.ts","../src/organizations/organizations.ts","../src/users/types.ts","../src/presence/types.ts","../src/presence/presenceStore.ts","../src/projection/types.ts","../src/preview/types.ts","../src/project/project.ts","../src/projection/getProjectionState.ts","../src/projection/resolveProjection.ts","../src/projects/projects.ts","../src/query/queryStore.ts","../src/releases/releasesStore.ts","../src/releases/getPerspectiveState.ts","../src/users/usersStore.ts","../src/utils/createFetcherStore.ts","../src/utils/getCorsErrorProjectId.ts","../src/utils/isImportError.ts","../src/version.ts","../src/_exports/index.ts","../src/auth/authStore.ts"],"mappings":"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"}

package/dist/clientStore-BtE2-q2i.js

@@ -1,90 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-vyAXikos.js";
-import { a as defineStore, c as isDatasetResource, i as bindActionGlobally, l as isMediaLibraryResource, s as isCanvasResource, t as createStateSourceAction } from "./createStateSourceAction-BOKtqFNm.js";
-import { T as getStagingApiHost, l as getTokenState, r as getAuthMethodState } from "./authStore-CtE9bLHW.js";
-import { i as pickProperties } from "./object-CxXlSVg7.js";
-import { createClient } from "@sanity/client";
-var clientStore_exports = /* @__PURE__ */ __exportAll({
-	getClient: () => getClient,
-	getClientState: () => getClientState
-});
-const allowedKeys = Object.keys({
-	apiHost: null,
-	useCdn: null,
-	token: null,
-	perspective: null,
-	proxy: null,
-	withCredentials: null,
-	timeout: null,
-	maxRetries: null,
-	dataset: null,
-	projectId: null,
-	scope: null,
-	apiVersion: null,
-	requestTagPrefix: null,
-	useProjectHostname: null,
-	resource: null
-}), DEFAULT_CLIENT_CONFIG = {
-	apiVersion: "2024-11-12",
-	useCdn: !1,
-	ignoreBrowserTokenWarning: !0,
-	allowReconfigure: !1,
-	requestTagPrefix: "sanity.sdk"
-}, clientStore = defineStore({
-	name: "clientStore",
-	getInitialState: (instance) => ({
-		clients: {},
-		token: getTokenState(instance).getCurrent()
-	}),
-	initialize(context) {
-		let subscription = listenToToken(context), authMethodSubscription = listenToAuthMethod(context);
-		return () => {
-			subscription.unsubscribe(), authMethodSubscription.unsubscribe();
-		};
-	}
-}), listenToToken = ({ instance, state }) => getTokenState(instance).observable.subscribe((token) => {
-	state.set("setTokenAndResetClients", {
-		token,
-		clients: {}
-	});
-}), listenToAuthMethod = ({ instance, state }) => getAuthMethodState(instance).observable.subscribe((authMethod) => {
-	state.set("setAuthMethod", { authMethod });
-}), getClientConfigKey = (options) => JSON.stringify(pickProperties(options, allowedKeys)), getClient = bindActionGlobally(clientStore, ({ state, instance }, options) => {
-	if (!options || typeof options != "object") throw Error("getClient() requires a configuration object with at least an \"apiVersion\" property. Example: getClient(instance, { apiVersion: \"2024-11-12\" })");
-	let disallowedKeys = Object.keys(options).filter((key) => !allowedKeys.includes(key));
-	if (disallowedKeys.length > 0) {
-		let listFormatter = new Intl.ListFormat("en", {
-			style: "long",
-			type: "conjunction"
-		});
-		throw Error(`The client options provided contains unsupported properties: ${listFormatter.format(disallowedKeys)}. Allowed keys are: ${listFormatter.format(allowedKeys)}.`);
-	}
-	let tokenFromState = state.get().token, { clients, authMethod } = state.get(), projectId = options.projectId ?? instance.config.projectId, dataset = options.dataset ?? instance.config.dataset, resource;
-	options.resource && (isMediaLibraryResource(options.resource) ? resource = {
-		type: "media-library",
-		id: options.resource.mediaLibraryId
-	} : isCanvasResource(options.resource) ? resource = {
-		type: "canvas",
-		id: options.resource.canvasId
-	} : isDatasetResource(options.resource) && (projectId = options.resource.projectId, dataset = options.resource.dataset));
-	let apiHost = options.apiHost ?? instance.config.auth?.apiHost ?? getStagingApiHost(), effectiveOptions = {
-		...DEFAULT_CLIENT_CONFIG,
-		...(options.scope === "global" || !projectId || resource) && { useProjectHostname: !1 },
-		token: authMethod === "cookie" ? void 0 : tokenFromState ?? void 0,
-		...options,
-		...projectId && { projectId },
-		...dataset && { dataset },
-		...resource ? { resource } : { resource: void 0 },
-		...apiHost && { apiHost }
-	};
-	resource && (delete effectiveOptions.projectId, delete effectiveOptions.dataset), effectiveOptions.token === null || effectiveOptions.token === void 0 ? (delete effectiveOptions.token, authMethod === "cookie" && (effectiveOptions.withCredentials = !0)) : delete effectiveOptions.withCredentials;
-	let key = getClientConfigKey(effectiveOptions);
-	if (clients[key]) return clients[key];
-	let client = createClient(effectiveOptions);
-	return state.set("addClient", (prev) => ({ clients: {
-		...prev.clients,
-		[key]: client
-	} })), client;
-}), getClientState = bindActionGlobally(clientStore, createStateSourceAction(({ instance }, options) => getClient(instance, options)));
-export { getClient as n, getClientState as r, clientStore_exports as t };
-
-//# sourceMappingURL=clientStore-BtE2-q2i.js.map

package/dist/clientStore-BtE2-q2i.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"clientStore-BtE2-q2i.js","names":[],"sources":["../src/client/clientStore.ts"],"sourcesContent":["import {type ClientConfig, createClient, type SanityClient} from '@sanity/client'\n\nimport {getAuthMethodState, getTokenState} from '../auth/authStore'\nimport {\n  type DocumentResource,\n  isCanvasResource,\n  isDatasetResource,\n  isMediaLibraryResource,\n} from '../config/sanityConfig'\nimport {bindActionGlobally} from '../store/createActionBinder'\nimport {createStateSourceAction} from '../store/createStateSourceAction'\nimport {defineStore, type StoreContext} from '../store/defineStore'\nimport {getStagingApiHost} from '../utils/getStagingApiHost'\nimport {pickProperties} from '../utils/object'\n\nconst DEFAULT_API_VERSION = '2024-11-12'\nconst DEFAULT_REQUEST_TAG_PREFIX = 'sanity.sdk'\n\ntype AllowedClientConfigKey =\n  | 'useCdn'\n  | 'token'\n  | 'perspective'\n  | 'apiHost'\n  | 'proxy'\n  | 'withCredentials'\n  | 'timeout'\n  | 'maxRetries'\n  | 'dataset'\n  | 'projectId'\n  | 'requestTagPrefix'\n  | 'useProjectHostname'\n\nconst allowedKeys = Object.keys({\n  apiHost: null,\n  useCdn: null,\n  token: null,\n  perspective: null,\n  proxy: null,\n  withCredentials: null,\n  timeout: null,\n  maxRetries: null,\n  dataset: null,\n  projectId: null,\n  scope: null,\n  apiVersion: null,\n  requestTagPrefix: null,\n  useProjectHostname: null,\n  resource: null,\n} satisfies Record<keyof ClientOptions, null>) as (keyof ClientOptions)[]\n\nconst DEFAULT_CLIENT_CONFIG: ClientConfig = {\n  apiVersion: DEFAULT_API_VERSION,\n  useCdn: false,\n  ignoreBrowserTokenWarning: true,\n  allowReconfigure: false,\n  requestTagPrefix: DEFAULT_REQUEST_TAG_PREFIX,\n}\n\n/**\n * States tracked by the client store\n * @public\n */\nexport interface ClientStoreState {\n  token: string | null\n  clients: {[TKey in string]?: SanityClient}\n  authMethod?: 'localstorage' | 'cookie'\n}\n\n/**\n * Options used when retrieving a client instance from the client store.\n *\n * This interface extends the base {@link ClientConfig} and adds:\n *\n * - **apiVersion:** A required string indicating the API version for the client.\n * - **scope:** An optional flag to choose between the project-specific client\n *   ('project') and the global client ('global'). When set to `'global'`, the\n *   global client is used.\n *\n * These options are utilized by `getClient` and `getClientState` to configure and\n * return appropriate client instances that automatically handle authentication\n * updates and configuration changes.\n *\n * @public\n */\nexport interface ClientOptions extends Pick<ClientConfig, AllowedClientConfigKey> {\n  /**\n   * An optional flag to choose between the default client (typically project-level)\n   * and the global client ('global'). When set to `'global'`, the global client\n   * is used.\n   */\n  scope?: 'default' | 'global'\n  /**\n   * A required string indicating the API version for the client.\n   */\n  apiVersion: string\n\n  /**\n   * @internal\n   * The SDK resource to use for the client -- this will get transformed into a ClientConfig resource.\n   */\n  resource?: DocumentResource\n}\n\nconst clientStore = defineStore<ClientStoreState>({\n  name: 'clientStore',\n\n  getInitialState: (instance) => ({\n    clients: {},\n    token: getTokenState(instance).getCurrent(),\n  }),\n\n  initialize(context) {\n    const subscription = listenToToken(context)\n    const authMethodSubscription = listenToAuthMethod(context)\n    return () => {\n      subscription.unsubscribe()\n      authMethodSubscription.unsubscribe()\n    }\n  },\n})\n\n/**\n * Updates the client store state when a token is received.\n * @internal\n */\nconst listenToToken = ({instance, state}: StoreContext<ClientStoreState>) => {\n  return getTokenState(instance).observable.subscribe((token) => {\n    state.set('setTokenAndResetClients', {token, clients: {}})\n  })\n}\n\nconst listenToAuthMethod = ({instance, state}: StoreContext<ClientStoreState>) => {\n  return getAuthMethodState(instance).observable.subscribe((authMethod) => {\n    state.set('setAuthMethod', {authMethod})\n  })\n}\n\ntype ClientInstanceCacheKeyInput = ClientConfig &\n  Partial<Pick<ClientOptions, 'scope'>> & {\n    apiVersion: string\n  }\n\nconst getClientConfigKey = (options: ClientInstanceCacheKeyInput) =>\n  JSON.stringify(pickProperties(options, allowedKeys))\n\n/**\n * Retrieves a Sanity client instance configured with the provided options.\n *\n * This function returns a client instance configured for the project or as a\n * global client based on the options provided. It ensures efficient reuse of\n * client instances by returning the same instance for the same options.\n * For automatic handling of authentication token updates, consider using\n * `getClientState`.\n *\n * @public\n */\nexport const getClient = bindActionGlobally(\n  clientStore,\n  ({state, instance}, options: ClientOptions) => {\n    if (!options || typeof options !== 'object') {\n      throw new Error(\n        'getClient() requires a configuration object with at least an \"apiVersion\" property. ' +\n          'Example: getClient(instance, { apiVersion: \"2024-11-12\" })',\n      )\n    }\n\n    // Check for disallowed keys\n    const providedKeys = Object.keys(options) as (keyof ClientOptions)[]\n    const disallowedKeys = providedKeys.filter((key) => !allowedKeys.includes(key))\n\n    if (disallowedKeys.length > 0) {\n      const listFormatter = new Intl.ListFormat('en', {style: 'long', type: 'conjunction'})\n      throw new Error(\n        `The client options provided contains unsupported properties: ${listFormatter.format(disallowedKeys)}. ` +\n          `Allowed keys are: ${listFormatter.format(allowedKeys)}.`,\n      )\n    }\n\n    const tokenFromState = state.get().token\n    const {clients, authMethod} = state.get()\n    let projectId = options.projectId ?? instance.config.projectId\n    let dataset = options.dataset ?? instance.config.dataset\n\n    let resource: ClientConfig['resource'] | undefined\n\n    if (options.resource) {\n      if (isMediaLibraryResource(options.resource)) {\n        resource = {type: 'media-library', id: options.resource.mediaLibraryId}\n      } else if (isCanvasResource(options.resource)) {\n        resource = {type: 'canvas', id: options.resource.canvasId}\n      } else if (isDatasetResource(options.resource)) {\n        // use project-based routes for datasets to avoid existing CORS and Studio auth cookie issues\n        projectId = options.resource.projectId\n        dataset = options.resource.dataset\n      }\n    }\n\n    const apiHost = options.apiHost ?? instance.config.auth?.apiHost ?? getStagingApiHost()\n\n    const effectiveOptions: ClientConfig & {apiVersion: string} = {\n      ...DEFAULT_CLIENT_CONFIG,\n      ...((options.scope === 'global' || !projectId || resource) && {useProjectHostname: false}),\n      token: authMethod === 'cookie' ? undefined : (tokenFromState ?? undefined),\n      ...options,\n      ...(projectId && {projectId}),\n      ...(dataset && {dataset}),\n      ...(resource ? {resource} : {resource: undefined}),\n      ...(apiHost && {apiHost}),\n    }\n\n    // When a resource is provided, don't use projectId/dataset - the client should be \"projectless\"\n    // The client code itself will ignore the non-resource config, so we do this to prevent confusing the user.\n    // (ref: https://github.com/sanity-io/client/blob/5c23f81f5ab93a53f5b22b39845c867988508d84/src/data/dataMethods.ts#L691)\n    if (resource) {\n      delete effectiveOptions.projectId\n      delete effectiveOptions.dataset\n    }\n\n    if (effectiveOptions.token === null || typeof effectiveOptions.token === 'undefined') {\n      delete effectiveOptions.token\n      if (authMethod === 'cookie') {\n        effectiveOptions.withCredentials = true\n      }\n    } else {\n      delete effectiveOptions.withCredentials\n    }\n\n    const key = getClientConfigKey(effectiveOptions)\n\n    if (clients[key]) return clients[key]\n\n    const client = createClient(effectiveOptions)\n    state.set('addClient', (prev) => ({clients: {...prev.clients, [key]: client}}))\n\n    return client\n  },\n)\n\n/**\n * Returns a state source for the Sanity client instance.\n *\n * This function provides a subscribable state source that emits updated client\n * instances whenever relevant configurations change (such as authentication tokens).\n * Use this when you need to react to client configuration changes in your application.\n *\n * @public\n */\nexport const getClientState = bindActionGlobally(\n  clientStore,\n  createStateSourceAction(({instance}, options: ClientOptions) => getClient(instance, options)),\n)\n"],"mappings":"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"}

package/dist/createStateSourceAction-BOKtqFNm.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createStateSourceAction-BOKtqFNm.js","names":[],"sources":["../src/config/sanityConfig.ts","../src/releases/utils/isReleasePerspective.ts","../src/store/createStoreState.ts","../src/store/defineStore.ts","../src/store/createStoreInstance.ts","../src/store/createActionBinder.ts","../src/store/createStateSourceAction.ts"],"sourcesContent":["import {type ClientPerspective, type StackablePerspective} from '@sanity/client'\n\nimport {type AuthConfig} from './authConfig'\n\n/**\n * A minimal Observable-compatible interface for subscribing to token changes.\n * Any object with a `subscribe` method that follows this contract will work,\n * including RxJS Observables. This avoids coupling the SDK to a specific\n * reactive library.\n *\n * @public\n */\nexport interface TokenSource {\n  /** Subscribe to token emissions. Emits `null` when logged out. */\n  subscribe(observer: {next: (token: string | null) => void}): {unsubscribe(): void}\n}\n\n/**\n * Studio-specific configuration for the SDK.\n * When present, the SDK operates in studio mode and derives auth from the\n * provided token source instead of discovering tokens independently.\n *\n * @public\n */\nexport interface StudioConfig {\n  /**\n   * Whether the Studio has already determined the user is authenticated.\n   * When `true` and the token source emits `null`, the SDK infers\n   * cookie-based auth is in use rather than transitioning to logged-out.\n   */\n  authenticated?: boolean\n  /** Reactive auth token source from the Studio's auth store. */\n  auth?: {\n    /**\n     * A reactive token source. The SDK subscribes and stays in sync — the\n     * Studio is the single authority for auth and handles token refresh.\n     *\n     * Optional because older Studios may not expose it. When absent, the\n     * SDK falls back to localStorage/cookie discovery.\n     */\n    token?: TokenSource\n  }\n}\n\n/**\n * Represents the minimal configuration required to identify a Sanity project.\n * @public\n */\nexport interface ProjectHandle<TProjectId extends string = string> {\n  projectId?: TProjectId\n}\n\n/**\n * @public\n */\nexport type ReleasePerspective = {\n  releaseName: string\n  excludedPerspectives?: StackablePerspective[]\n}\n\n/**\n * @public\n */\nexport interface PerspectiveHandle {\n  perspective?: ClientPerspective | ReleasePerspective\n}\n\n/**\n * @public\n */\nexport interface DatasetHandle<TDataset extends string = string, TProjectId extends string = string>\n  extends ProjectHandle<TProjectId>, PerspectiveHandle {\n  dataset?: TDataset\n  /**\n   * @beta\n   * Explicit resource to use. On an individual operation this overrides any default;\n   * on a `SanityConfig` it becomes the instance's default resource. Unlike\n   * `projectId`/`dataset`, this can also be a media library or canvas resource.\n   */\n  resource?: DocumentResource\n}\n\n/**\n * Identifies a specific document type within a Sanity dataset and project.\n * Includes `projectId`, `dataset`, and `documentType`.\n * Optionally includes a `documentId` and `liveEdit` flag.\n * @public\n */\nexport interface DocumentTypeHandle<\n  TDocumentType extends string = string,\n  TDataset extends string = string,\n  TProjectId extends string = string,\n> extends DatasetHandle<TDataset, TProjectId> {\n  documentId?: string\n  documentType: TDocumentType\n  /**\n   * Indicates whether this document uses liveEdit mode.\n   * When `true`, the document does not use the draft/published model and edits are applied directly to the document.\n   * @see https://www.sanity.io/docs/content-lake/drafts#ca0663a8f002\n   */\n  liveEdit?: boolean\n}\n\n/**\n * Uniquely identifies a specific document within a Sanity dataset and project.\n * Includes `projectId`, `dataset`, `documentType`, and the required `documentId`.\n * Commonly used by document-related hooks and components to reference a document without fetching its full content initially.\n * @public\n */\nexport interface DocumentHandle<\n  TDocumentType extends string = string,\n  TDataset extends string = string,\n  TProjectId extends string = string,\n> extends DocumentTypeHandle<TDocumentType, TDataset, TProjectId> {\n  documentId: string\n}\n\n/**\n * Identifies a release within a Sanity dataset and project. `releaseId` is the\n * `name` parameter on the release document (e.g. `{name: 'r41035a4'}`).\n * The underlying release document ID is `_.releases.<releaseId>`.\n * It's also the `id` parameter sent to the Actions API.\n * (This type doesn't need to have ProjectId / Dataset generics since it's always the same shape)\n * @beta\n */\nexport interface ReleaseHandle extends DatasetHandle {\n  releaseId: string\n}\n\n/**\n * Represents the complete configuration for a Sanity SDK instance\n * @public\n */\nexport interface SanityConfig extends DatasetHandle, PerspectiveHandle {\n  /**\n   * Authentication configuration for the instance\n   */\n  auth?: AuthConfig\n  /**\n   * Studio configuration provided by a Sanity Studio workspace.\n   * When present, the SDK operates in studio mode and derives auth from the\n   * workspace's reactive token source — no manual configuration needed.\n   *\n   * @remarks Typically set automatically by `SanityApp` when it detects an\n   * `SDKStudioContext` provider. Can also be set explicitly for programmatic use.\n   */\n  studio?: StudioConfig\n}\n\n/**\n * A document resource can be used for querying.\n * This will soon be the default way to identify where you are querying from.\n *\n * @beta\n */\nexport type DocumentResource = DatasetResource | MediaLibraryResource | CanvasResource\n\n/**\n * @beta\n */\nexport type DatasetResource = {projectId: string; dataset: string}\n\n/**\n * @beta\n */\nexport type MediaLibraryResource = {mediaLibraryId: string}\n\n/**\n * @beta\n */\nexport type CanvasResource = {canvasId: string}\n\n/**\n * @beta\n */\nexport function isDatasetResource(resource: DocumentResource): resource is DatasetResource {\n  return 'projectId' in resource && 'dataset' in resource\n}\n\n/**\n * @beta\n */\nexport function isMediaLibraryResource(\n  resource: DocumentResource,\n): resource is MediaLibraryResource {\n  return 'mediaLibraryId' in resource\n}\n\n/**\n * @beta\n */\nexport function isCanvasResource(resource: DocumentResource): resource is CanvasResource {\n  return 'canvasId' in resource\n}\n","import {type PerspectiveHandle, type ReleasePerspective} from '../../config/sanityConfig'\n\nexport const isReleasePerspective = (\n  perspective: PerspectiveHandle['perspective'],\n): perspective is ReleasePerspective => {\n  return typeof perspective === 'object' && perspective !== null && 'releaseName' in perspective\n}\n","import {Observable} from 'rxjs'\nimport {devtools, type DevtoolsOptions} from 'zustand/middleware'\nimport {createStore} from 'zustand/vanilla'\n\n/**\n * Represents a reactive store state container with multiple access patterns\n */\nexport interface StoreState<TState> {\n  /**\n   * Gets the current state value\n   *\n   * @remarks\n   * This is a direct synchronous accessor that doesn't trigger subscriptions\n   */\n  get: () => TState\n\n  /**\n   * Updates the store state\n   * @param name - Action name for devtools tracking\n   * @param updatedState - New state value or updater function\n   *\n   * @remarks\n   * When providing a partial object, previous top-level keys not included in\n   * the update will be preserved.\n   */\n  set: (name: string, updatedState: Partial<TState> | ((s: TState) => Partial<TState>)) => void\n\n  /**\n   * Observable stream of state changes\n   * @remarks\n   * - Emits immediately with current state on subscription\n   * - Shares underlying subscription between observers\n   * - Only emits when state reference changes\n   * - Completes when store is disposed\n   */\n  observable: Observable<TState>\n}\n\n/**\n * Creates a reactive store state container with multiple access patterns\n * @param initialState - Initial state value for the store\n * @param devToolsOptions - Configuration for Zustand devtools integration\n * @returns StoreState instance with get/set/observable interface\n *\n * @example\n * ```typescript\n * // Create a simple counter store\n * const counterStore = createStoreState({ count: 0 });\n *\n * // Update state\n * counterStore.set('increment', { count: 1 });\n *\n * // Observe changes\n * counterStore.observable.subscribe(console.log);\n * ```\n *\n * @remarks\n * Uses Zustand for state management under the hood with RxJS for observable interface.\n * Designed to work with both imperative and reactive programming patterns.\n */\nexport function createStoreState<TState>(\n  initialState: TState,\n  devToolsOptions?: DevtoolsOptions,\n): StoreState<TState> {\n  // Create underlying Zustand store with devtools integration\n  const store = createStore<TState>()(devtools(() => initialState, devToolsOptions))\n\n  return {\n    get: store.getState,\n    set: (actionKey, updatedState) => {\n      const currentState = store.getState()\n      const nextState =\n        typeof updatedState === 'function' ? updatedState(currentState) : updatedState\n\n      // Optimization: Skip update if state reference remains the same\n      if (currentState !== nextState) {\n        store.setState(nextState, false, actionKey)\n      }\n    },\n    observable: new Observable((observer) => {\n      // Emit current state immediately on subscription\n      const emit = () => observer.next(store.getState())\n      emit()\n\n      // Subscribe to Zustand store changes\n      const unsubscribe = store.subscribe(emit)\n\n      // Cleanup when observable unsubscribed\n      return () => unsubscribe()\n    }),\n  }\n}\n","import {type SanityInstance} from './createSanityInstance'\nimport {type StoreState} from './createStoreState'\n\n/**\n * Context object provided to store initialization functions\n */\nexport interface StoreContext<TState, TKey = unknown> {\n  /**\n   * Sanity instance associated with this store\n   *\n   * @remarks\n   * Provides access to the Sanity configuration and instance lifecycle methods\n   */\n  instance: SanityInstance\n\n  /**\n   * Reactive store state management utilities\n   *\n   * @remarks\n   * Contains methods for getting/setting state and observing changes\n   */\n  state: StoreState<TState>\n\n  /**\n   * The key used to instantiate the store.\n   */\n  key: TKey\n}\n\n/**\n * Defines the structure and behavior of a store\n *\n * @remarks\n * Stores are isolated state containers that can be associated with Sanity instances.\n * Each store definition creates a separate state instance per composite key.\n */\nexport interface StoreDefinition<TState, TKey = unknown> {\n  /**\n   * Unique name for the store\n   *\n   * @remarks\n   * Used for debugging, devtools integration, and store identification\n   */\n  name: string\n\n  /**\n   * Creates the initial state for the store\n   * @param instance - Sanity instance the store is being created for\n   * @returns Initial state value\n   *\n   * @remarks\n   * Called when a new store instance is created. Can use Sanity instance\n   * configuration to determine initial state.\n   */\n  getInitialState: (instance: SanityInstance, key: TKey) => TState\n\n  /**\n   * Optional initialization function\n   * @param context - Store context with state and instance access\n   * @returns Optional cleanup function for store disposal\n   *\n   * @remarks\n   * Use this for:\n   * - Setting up event listeners\n   * - Initial data fetching\n   * - Connecting external services\n   *\n   * Return a cleanup function to:\n   * - Remove event listeners\n   * - Cancel pending operations\n   * - Dispose external connections\n   */\n  initialize?: (context: StoreContext<TState, TKey>) => (() => void) | undefined\n}\n\n/**\n * Typescript helper function for creating store definitions\n *\n * @param storeDefinition - Configuration object defining the store\n * @returns The finalized store definition\n */\nexport function defineStore<TState, TKey = unknown>(\n  storeDefinition: StoreDefinition<TState, TKey>,\n): StoreDefinition<TState, TKey> {\n  return storeDefinition\n}\n","import {getEnv} from '../utils/getEnv'\nimport {type SanityInstance} from './createSanityInstance'\nimport {createStoreState, type StoreState} from './createStoreState'\nimport {type StoreDefinition} from './defineStore'\n\n/**\n * Represents a running instance of a store with its own state and lifecycle\n *\n * @remarks\n * Each StoreInstance is tied to a specific SanityInstance, manages its own state,\n * and can be independently disposed when no longer needed.\n */\nexport interface StoreInstance<TState> {\n  /**\n   * Access to the reactive state container for this store instance\n   */\n  state: StoreState<TState>\n\n  /**\n   * Checks if this store instance has been disposed\n   * @returns Boolean indicating disposed state\n   */\n  isDisposed: () => void\n\n  /**\n   * Cleans up this store instance and runs any initialization cleanup functions\n   * @remarks Triggers the cleanup function returned from the initialize method\n   */\n  dispose: () => void\n}\n\n/**\n * Creates a new instance of a store from a store definition\n *\n * @param instance - The Sanity instance this store will be associated with\n * @param storeDefinition - The store definition containing initial state and initialization logic\n * @returns A store instance with state management and lifecycle methods\n *\n * @remarks\n * The store instance maintains its own state that is scoped to the given Sanity instance.\n * If the store definition includes an initialize function, it will be called during\n * instance creation, and its cleanup function will be called during disposal.\n *\n * @example\n * ```ts\n * const counterStore = defineStore({\n *   name: 'Counter',\n *   getInitialState: () => ({ count: 0 }),\n *   initialize: ({state}) => {\n *     console.log('Counter store initialized')\n *     return () => console.log('Counter store disposed')\n *   }\n * })\n *\n * const instance = createStoreInstance(sanityInstance, counterStore)\n * // Later when done with the store:\n * instance.dispose()\n * ```\n */\nexport function createStoreInstance<TState, TKey extends {name: string}>(\n  instance: SanityInstance,\n  key: TKey,\n  {name, getInitialState, initialize}: StoreDefinition<TState, TKey>,\n): StoreInstance<TState> {\n  const state = createStoreState(getInitialState(instance, key), {\n    enabled: !!getEnv('DEV'),\n    name: `${name}-${key.name}`,\n  })\n  const dispose = initialize?.({state, instance, key})\n  const disposed = {current: false}\n\n  return {\n    state,\n    dispose: () => {\n      if (disposed.current) return\n      disposed.current = true\n      dispose?.()\n    },\n    isDisposed: () => disposed.current,\n  }\n}\n","import {type ClientPerspective} from '@sanity/client'\n\nimport {\n  type DatasetHandle,\n  type DocumentResource,\n  isCanvasResource,\n  isDatasetResource,\n  isMediaLibraryResource,\n  type ReleasePerspective,\n} from '../config/sanityConfig'\nimport {isReleasePerspective} from '../releases/utils/isReleasePerspective'\nimport {type SanityInstance} from './createSanityInstance'\nimport {createStoreInstance, type StoreInstance} from './createStoreInstance'\nimport {type StoreState} from './createStoreState'\nimport {type StoreContext, type StoreDefinition} from './defineStore'\n\nexport interface BoundResourceKey {\n  name: string\n  resource: DocumentResource\n}\nexport interface BoundPerspectiveKey extends BoundResourceKey {\n  perspective: ClientPerspective | ReleasePerspective\n}\n/**\n * Defines a store action that operates on a specific state type\n */\nexport type StoreAction<TState, TParams extends unknown[], TReturn, TKey = unknown> = (\n  context: StoreContext<TState, TKey>,\n  ...params: TParams\n) => TReturn\n\n/**\n * Represents a store action that has been bound to a specific store instance\n */\nexport type BoundStoreAction<_TState, TParams extends unknown[], TReturn> = (\n  instance: SanityInstance,\n  ...params: TParams\n) => TReturn\n\n/**\n * Creates an action binder function that uses the provided key function\n * to determine how store instances are shared between Sanity instances\n *\n * @param keyFn - Function that generates a key from a Sanity config\n * @returns A function that binds store actions to Sanity instances\n *\n * @remarks\n * Action binders determine how store instances are shared across multiple\n * Sanity instances. The key function determines which instances share state.\n *\n * @example\n * ```ts\n * // Create a custom binder that uses a tenant ID for isolation\n * const bindActionByTenant = createActionBinder(config => config.tenantId || 'default')\n *\n * // Use the custom binder with a store definition\n * const getTenantUsers = bindActionByTenant(\n *   userStore,\n *   ({state}) => state.get().users\n * )\n * ```\n */\nexport function createActionBinder<\n  TKey extends {name: string},\n  TKeyParams extends unknown[] = unknown[],\n>(keyFn: (instance: SanityInstance, ...params: TKeyParams) => TKey) {\n  const instanceRegistry = new Map<string, Set<string>>()\n  const storeRegistry = new Map<string, StoreInstance<unknown>>()\n\n  /**\n   * Binds a store action to a store definition\n   *\n   * @param storeDefinition - The store definition\n   * @param action - The action to bind\n   * @returns A function that executes the action with a Sanity instance\n   */\n  return function bindAction<TState, TParams extends TKeyParams, TReturn>(\n    storeDefinition: StoreDefinition<TState, TKey>,\n    action: StoreAction<TState, TParams, TReturn, TKey>,\n  ): BoundStoreAction<TState, TParams, TReturn> {\n    return function boundAction(instance: SanityInstance, ...params: TParams) {\n      const key = keyFn(instance, ...params)\n      const compositeKey = storeDefinition.name + (key.name ? `:${key.name}` : '')\n\n      // Get or create instance set for this composite key\n      let instances = instanceRegistry.get(compositeKey)\n      if (!instances) {\n        instances = new Set<string>()\n        instanceRegistry.set(compositeKey, instances)\n      }\n\n      // Register instance for disposal tracking\n      if (!instances.has(instance.instanceId)) {\n        instances.add(instance.instanceId)\n        instance.onDispose(() => {\n          instances.delete(instance.instanceId)\n\n          // Clean up when last instance is disposed\n          if (instances.size === 0) {\n            storeRegistry.get(compositeKey)?.dispose()\n            storeRegistry.delete(compositeKey)\n            instanceRegistry.delete(compositeKey)\n          }\n        })\n      }\n\n      // Get or create store instance\n      let storeInstance = storeRegistry.get(compositeKey)\n      if (!storeInstance) {\n        storeInstance = createStoreInstance(instance, key, storeDefinition)\n        storeRegistry.set(compositeKey, storeInstance)\n      }\n\n      // Execute action with store context\n      return action({instance, state: storeInstance.state as StoreState<TState>, key}, ...params)\n    }\n  }\n}\n\nconst createResourceKey = (\n  instance: SanityInstance,\n  resource?: DocumentResource,\n): BoundResourceKey => {\n  let name: string | undefined\n  let resourceForKey: DocumentResource | undefined\n  // A per-call resource wins; otherwise use the instance's default resource.\n  const effectiveResource = resource ?? instance.config.resource\n  if (effectiveResource) {\n    resourceForKey = effectiveResource\n    if (isDatasetResource(effectiveResource)) {\n      name = `${effectiveResource.projectId}.${effectiveResource.dataset}`\n    } else if (isMediaLibraryResource(effectiveResource)) {\n      name = `media-library:${effectiveResource.mediaLibraryId}`\n    } else if (isCanvasResource(effectiveResource)) {\n      name = `canvas:${effectiveResource.canvasId}`\n    } else {\n      throw new Error(`Received invalid resource: ${JSON.stringify(effectiveResource)}`)\n    }\n    return {name, resource: resourceForKey}\n  }\n\n  // `projectId`/`dataset` on the config are shorthand for a dataset resource.\n  const {projectId, dataset} = instance.config\n  if (!projectId || !dataset) {\n    throw new Error('This API requires a project ID and dataset configured.')\n  }\n  return {name: `${projectId}.${dataset}`, resource: {projectId, dataset}}\n}\n\n/**\n * Binds an action to a store that's scoped to a specific document resource.\n **/\nexport const bindActionByResource = createActionBinder<\n  BoundResourceKey,\n  // `resource` is optional because it falls back to the instance config in\n  // `createResourceKey` — see the note there on why that fallback still exists.\n  [{resource?: DocumentResource}, ...unknown[]]\n>((instance, {resource}) => {\n  return createResourceKey(instance, resource)\n})\n\n/**\n * Binds an action to a store that's scoped to a specific document resource and perspective.\n *\n * @remarks\n * This creates actions that operate on state isolated to a specific document resource and perspective.\n * Different document resources and perspectives will have separate states.\n *\n * This is mostly useful for stores that do batch fetching operations, since the query store\n * can isolate single queries by perspective.\n *\n * @throws Error if resource or perspective is missing from the Sanity instance config\n *\n * @example\n * ```ts\n * // Define a store\n * const documentStore = defineStore<DocumentState>({\n *   name: 'Document',\n *   getInitialState: () => ({ documents: {} }),\n *   // ...\n * })\n *\n * // Create resource-and-perspective-specific actions\n * export const fetchDocuments = bindActionByResourceAndPerspective(\n *   documentStore,\n *   ({instance, state}, documentId) => {\n *     // This state is isolated to the specific document resource and perspective\n *     // ...fetch logic...\n *   }\n * )\n *\n * // Usage\n * fetchDocument(sanityInstance, 'doc123')\n * ```\n */\nexport const bindActionByResourceAndPerspective = createActionBinder<\n  BoundPerspectiveKey,\n  [DatasetHandle, ...unknown[]]\n>((instance, options): BoundPerspectiveKey => {\n  const {resource, perspective} = options\n  // Same trade-off as the resource fallback in `createResourceKey`: configured once on the\n  // instance rather than passed to every call. Kept for the same reason.\n  const utilizedPerspective = perspective ?? instance.config.perspective ?? 'drafts'\n  let perspectiveKey: string\n  if (isReleasePerspective(utilizedPerspective)) {\n    perspectiveKey = utilizedPerspective.releaseName\n  } else if (typeof utilizedPerspective === 'string') {\n    perspectiveKey = utilizedPerspective\n  } else {\n    // \"StackablePerspective\", shouldn't be a common case, but just in case\n    perspectiveKey = JSON.stringify(utilizedPerspective)\n  }\n  const sourceKey = createResourceKey(instance, resource)\n\n  return {\n    name: `${sourceKey.name}:${perspectiveKey}`,\n    resource: sourceKey.resource,\n    perspective: utilizedPerspective,\n  }\n})\n\n/**\n * Binds an action to a global store that's shared across all Sanity instances\n *\n * @remarks\n * This creates actions that operate on state shared globally across all Sanity instances.\n * Use this for features like authentication where the state should be the same\n * regardless of which project or dataset is being used.\n *\n * @example\n * ```ts\n * // Define a store\n * const authStore = defineStore<AuthState>({\n *   name: 'Auth',\n *   getInitialState: () => ({\n *     user: null,\n *     isAuthenticated: false\n *   }),\n *   // ...\n * })\n *\n * // Create global actions\n * export const getCurrentUser = bindActionGlobally(\n *   authStore,\n *   ({state}) => state.get().user\n * )\n *\n * export const login = bindActionGlobally(\n *   authStore,\n *   ({state, instance}, credentials) => {\n *     // Login logic that affects global state\n *     // ...\n *   }\n * )\n *\n * // Usage with any instance\n * getCurrentUser(sanityInstance)\n * ```\n */\nexport const bindActionGlobally = createActionBinder((..._rest) => ({name: 'global'}))\n","import {defer, distinctUntilChanged, finalize, map, Observable, shareReplay, skip} from 'rxjs'\n\nimport {type StoreAction} from './createActionBinder'\nimport {type SanityInstance} from './createSanityInstance'\nimport {type StoreContext} from './defineStore'\n\n/**\n * Represents a reactive state source that provides synchronized access to store data\n *\n * @remarks\n * Designed to work with React's useSyncExternalStore hook. Provides three ways to access data:\n * 1. `getCurrent()` for synchronous current value access\n * 2. `subscribe()` for imperative change notifications\n * 3. `observable` for reactive stream access\n *\n * @public\n */\nexport interface StateSource<T> {\n  /**\n   * Subscribes to state changes with optional callback\n   * @param onStoreChanged - Called whenever relevant state changes occur\n   * @returns Unsubscribe function to clean up the subscription\n   */\n  subscribe: (onStoreChanged?: () => void) => () => void\n\n  /**\n   * Gets the current derived state value\n   *\n   * @remarks\n   * Safe to call without subscription. Will always return the latest value\n   * based on the current store state and selector parameters.\n   */\n  getCurrent: () => T\n\n  /**\n   * Observable stream of state values\n   *\n   * @remarks\n   * Shares a single underlying subscription between all observers. Emits:\n   * - Immediately with current value on subscription\n   * - On every relevant state change\n   * - Errors if selector throws\n   */\n  observable: Observable<T>\n}\n\n/**\n * Context passed to selectors when deriving state\n *\n * @remarks\n * Provides access to both the current state value and the Sanity instance,\n * allowing selectors to use configuration values when computing derived state.\n * The context is memoized for each state object and instance combination\n * to optimize performance and prevent unnecessary recalculations.\n *\n * @example\n * ```ts\n * // Using both state and instance in a selector (psuedo example)\n * const getUserByProjectId = createStateSourceAction(\n *   ({ state, instance }: SelectorContext<UsersState>, options?: ProjectHandle) => {\n *     const allUsers = state.users\n *     const projectId = options?.projectId ?? instance.config.projectId\n *     return allUsers.filter(user => user.projectId === projectId)\n *   }\n * )\n * ```\n */\nexport interface SelectorContext<TState> {\n  /**\n   * The current state object from the store\n   */\n  state: TState\n\n  /**\n   * The Sanity instance associated with this state\n   */\n  instance: SanityInstance\n}\n\n/**\n * Function type for selecting derived state from store state and parameters\n * @public\n */\nexport type Selector<TState, TParams extends unknown[], TReturn> = (\n  context: SelectorContext<TState>,\n  ...params: TParams\n) => TReturn\n\n/**\n * Configuration options for creating a state source action\n */\ninterface StateSourceOptions<TState, TParams extends unknown[], TReturn, TKey> {\n  /**\n   * Selector function that derives the desired value from store state\n   *\n   * @remarks\n   * Will be called on every store change. Should be pure function.\n   * Thrown errors will propagate to observable subscribers.\n   */\n  selector: Selector<TState, TParams, TReturn>\n\n  /**\n   * Optional setup/cleanup handler for subscriptions\n   *\n   * @param context - Store context containing state and instance\n   * @param params - Action parameters provided during invocation\n   * @returns Optional cleanup function called when subscription ends\n   */\n  onSubscribe?: (context: StoreContext<TState, TKey>, ...params: TParams) => void | (() => void)\n\n  /**\n   * Equality function to prevent unnecessary updates\n   */\n  isEqual?: (prev: TReturn, curr: TReturn) => boolean\n}\n\n/**\n * Creates a state source action that generates StateSource instances\n *\n * @remarks\n * The returned action can be bound to a store using createActionBinder.\n * When invoked, returns a StateSource that stays synchronized with the store.\n *\n * Key performance features:\n * - Memoizes selector contexts to prevent redundant object creation\n * - Only runs selectors when the underlying state changes\n *\n * For complex data transformations, consider using memoized selectors\n * (like those from Reselect) to prevent expensive recalculations.\n *\n * @example\n * ```ts\n * // Create a simple counter source\n * const getCount = createStateSourceAction(({state}: SelectorContext<CounterState>) => state.count)\n * ```\n *\n * @example\n * ```ts\n * // Create a parameterized source with setup/cleanup\n * const getItem = createStateSourceAction({\n *   selector: ({state}, index: number) => state.items[index],\n *   onSubscribe: (context, index) => {\n *     trackItemSubscription(index)\n *     return () => untrackItem(index)\n *   }\n * })\n * ```\n *\n * @example\n * ```ts\n * // Binding a state source to a specific store\n * const documentStore = defineStore<DocumentState>({\n *   name: 'Documents',\n *   getInitialState: () => ({ documents: {} }),\n *   // ...\n * })\n *\n * const getDocument = bindActionByResource(\n *   documentStore,\n *   createStateSourceAction(({state}, documentId: string) => state.documents[documentId])\n * )\n *\n * // Usage\n * const documentSource = getDocument(sanityInstance, 'doc123')\n * const doc = documentSource.getCurrent()\n * const subscription = documentSource.observable.subscribe(updatedDoc => {\n *   console.log('Document changed:', updatedDoc)\n * })\n * ```\n */\nexport function createStateSourceAction<TState, TParams extends unknown[], TReturn, TKey = unknown>(\n  options: Selector<TState, TParams, TReturn> | StateSourceOptions<TState, TParams, TReturn, TKey>,\n): StoreAction<TState, TParams, StateSource<TReturn>, TKey> {\n  const selector = typeof options === 'function' ? options : options.selector\n  const subscribeHandler = options && 'onSubscribe' in options ? options.onSubscribe : undefined\n  const isEqual = options && 'isEqual' in options ? (options.isEqual ?? Object.is) : Object.is\n  const selectorContextCache = new WeakMap<\n    object,\n    WeakMap<SanityInstance, SelectorContext<TState>>\n  >()\n\n  /**\n   * The state source action implementation\n   * @param context - Store context providing access to state and instance\n   * @param params - Parameters provided when invoking the bound action\n   */\n  function stateSourceAction(context: StoreContext<TState, TKey>, ...params: TParams) {\n    const {state, instance} = context\n\n    const getCurrent = (currentState: TState) => {\n      if (typeof currentState !== 'object' || currentState === null) {\n        throw new Error(\n          `Expected store state to be an object but got \"${typeof currentState}\" instead`,\n        )\n      }\n\n      let instanceCache = selectorContextCache.get(currentState)\n      if (!instanceCache) {\n        instanceCache = new WeakMap<SanityInstance, SelectorContext<TState>>()\n        selectorContextCache.set(currentState, instanceCache)\n      }\n      let selectorContext = instanceCache.get(instance)\n      if (!selectorContext) {\n        selectorContext = {state: currentState, instance}\n        instanceCache.set(instance, selectorContext)\n      }\n      return selector(selectorContext, ...params)\n    }\n\n    // `state.observable` will emit the current value immediately and\n    // hence we inherit the same behavior here.\n    let values = state.observable.pipe(map(getCurrent), distinctUntilChanged(isEqual))\n\n    if (subscribeHandler) {\n      values = withSubscribeHook(values, () => subscribeHandler(context, ...params))\n    }\n\n    // Share but replay the latest value so every subscriber gets an\n    // initial synchronous emission, matching `state.observable`. That keeps\n    // `skip(1)` in `subscribe()` aligned with \"skip current snapshot\" rather than\n    // silently eating the first real update after multicasting.\n    const sharedValues = values.pipe(shareReplay({bufferSize: 1, refCount: true}))\n\n    const subscribe = (onStoreChanged?: () => void) => {\n      const subscription = sharedValues.pipe(skip(1)).subscribe({\n        next: () => onStoreChanged?.(),\n        // Propagate selector errors to both subscription types\n        error: () => onStoreChanged?.(),\n      })\n\n      return () => {\n        subscription.unsubscribe()\n      }\n    }\n\n    return {\n      getCurrent: () => getCurrent(state.get()),\n      subscribe,\n      observable: sharedValues,\n    }\n  }\n\n  return stateSourceAction\n}\n\n/**\n * Creates a new Observable which wraps an existing Observable which will invoke\n * the function when a new subscriber appears.\n */\nfunction withSubscribeHook<T>(obs: Observable<T>, fn: () => void | (() => void)): Observable<T> {\n  return defer(() => {\n    const cleanup = fn()\n    return cleanup ? obs.pipe(finalize(() => cleanup())) : obs\n  })\n}\n"],"mappings":"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"}

package/dist/getEnv-D5RGkQLu.js

@@ -1,8 +0,0 @@
-function getEnv(key) {
-	if (import.meta.env) return import.meta.env[key];
-	if (typeof process < "u" && process.env) return process.env[key];
-	if (typeof window < "u" && window.ENV) return window.ENV?.[key];
-}
-export { getEnv as t };
-
-//# sourceMappingURL=getEnv-D5RGkQLu.js.map

package/dist/getEnv-D5RGkQLu.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getEnv-D5RGkQLu.js","names":[],"sources":["../src/utils/getEnv.ts"],"sourcesContent":["// Local type declaration for Remix\ntype WindowWithEnv = Window &\n  typeof globalThis & {\n    ENV?: Record<string, unknown>\n  }\n\ntype KnownEnvVar = 'DEV' | 'PKG_VERSION'\n\nexport function getEnv(key: KnownEnvVar): unknown {\n  if (typeof import.meta !== 'undefined' && import.meta.env) {\n    // Vite environment variables\n    return (import.meta.env as unknown as Record<string, unknown>)[key]\n  } else if (typeof process !== 'undefined' && process.env) {\n    // Node.js or server-side environment variables\n    return process.env[key]\n  } else if (typeof window !== 'undefined' && (window as WindowWithEnv).ENV) {\n    // Remix-style client-side environment variables\n    return (window as WindowWithEnv).ENV?.[key]\n  }\n  return undefined\n}\n"],"mappings":"AAQA,SAAgB,OAAO,KAA2B;CAChD,IAA0C,YAAY,KAEpD,OAAQ,YAAY,IAA2C;CAC1D,IAAI,OAAO,UAAY,OAAe,QAAQ,KAEnD,OAAO,QAAQ,IAAI;CACd,IAAI,OAAO,SAAW,OAAgB,OAAyB,KAEpE,OAAQ,OAAyB,MAAM;AAG3C"}

package/dist/logger-DAtJb5RQ.js

@@ -1,173 +0,0 @@
-const LOG_LEVEL_PRIORITY = {
-	error: 0,
-	warn: 1,
-	info: 2,
-	debug: 3,
-	trace: 4
-}, DEFAULT_CONFIG = {
-	level: "warn",
-	namespaces: [],
-	internal: !1,
-	timestamps: !0,
-	enableInProduction: !1,
-	handler: {
-		error: console.error.bind(console),
-		warn: console.warn.bind(console),
-		info: console.info.bind(console),
-		debug: console.debug.bind(console),
-		trace: console.debug.bind(console)
-	}
-};
-/**
-* Parse DEBUG environment variable for automatic logging configuration
-*
-* Supports patterns similar to Sanity CLI/Studio:
-* - DEBUG=sanity:* (all namespaces, debug level)
-* - DEBUG=sanity:auth,sanity:document (specific namespaces)
-* - DEBUG=sanity:trace:* (all namespaces, trace level)
-* - DEBUG=sanity:*:internal (enable internal logs)
-*
-* @internal
-*/
-function parseDebugEnvVar() {
-	if (typeof process > "u" || !process.env?.DEBUG) return null;
-	let debug = process.env.DEBUG;
-	if (!debug.includes("sanity")) return null;
-	let config = {}, levelMatch = debug.match(/sanity:(trace|debug|info|warn|error):/), hasLevelSpecifier = !!levelMatch;
-	if (config.level = levelMatch ? levelMatch[1] : "debug", debug === "sanity") config.namespaces = ["*"];
-	else if (hasLevelSpecifier && debug.match(/sanity:(trace|debug|info|warn|error):\*/)) config.namespaces = ["*"];
-	else if (!hasLevelSpecifier && debug.includes("sanity:*")) config.namespaces = ["*"];
-	else {
-		let namespaces = debug.split(",").filter((s) => s.includes("sanity:")).map((s) => {
-			let cleaned = s.replace(/^sanity:/, "");
-			return hasLevelSpecifier && cleaned.match(/^(trace|debug|info|warn|error):/) ? cleaned.split(":").slice(1).join(":") : cleaned.split(":")[0];
-		}).filter(Boolean).filter((ns) => ns !== "*");
-		namespaces.length > 0 && (config.namespaces = namespaces);
-	}
-	return debug.includes(":internal") && (config.internal = !0), config;
-}
-const envConfig = parseDebugEnvVar();
-let globalConfig = {
-	...DEFAULT_CONFIG,
-	...envConfig ?? {}
-};
-/* c8 ignore next 14 */
-envConfig && ([
-	"info",
-	"debug",
-	"trace"
-].includes(globalConfig.level) || globalConfig.level === "warn") && console.info(`[${(/* @__PURE__ */ new Date()).toISOString()}] [INFO] [sdk] Logging auto-configured from DEBUG environment variable`, {
-	level: globalConfig.level,
-	namespaces: globalConfig.namespaces,
-	internal: globalConfig.internal,
-	source: "env:DEBUG",
-	value: typeof process < "u" ? process.env?.DEBUG : void 0
-});
-/**
-* Configure the global logging system
-* @public
-*/
-function configureLogging(config) {
-	globalConfig = {
-		...globalConfig,
-		...config,
-		handler: config.handler ?? globalConfig.handler
-	};
-}
-/**
-* Check if logging is enabled in the current environment
-* @internal
-*/
-function isLoggingEnabled() {
-	return typeof process < "u" && process.env?.NODE_ENV === "production" ? globalConfig.enableInProduction : !0;
-}
-/**
-* Check if a namespace is enabled
-* @internal
-*/
-function isNamespaceEnabled(namespace) {
-	return isLoggingEnabled() ? globalConfig.namespaces.includes("*") ? !0 : globalConfig.namespaces.includes(namespace) : !1;
-}
-/**
-* Check if a log level is enabled
-* @internal
-*/
-function isLevelEnabled(level) {
-	return isLoggingEnabled() ? LOG_LEVEL_PRIORITY[level] <= LOG_LEVEL_PRIORITY[globalConfig.level] : !1;
-}
-/**
-* Format a log message with timestamp, namespace, and instance context
-* @internal
-*/
-function formatMessage(namespace, level, message, context) {
-	let parts = [];
-	if (globalConfig.timestamps) {
-		let timestamp = (/* @__PURE__ */ new Date()).toISOString();
-		parts.push(`[${timestamp}]`);
-	}
-	parts.push(`[${level.toUpperCase()}]`), parts.push(`[${namespace}]`);
-	let instanceContext = context?.instanceContext;
-	return instanceContext && (instanceContext.projectId && parts.push(`[project:${instanceContext.projectId}]`), instanceContext.dataset && parts.push(`[dataset:${instanceContext.dataset}]`), instanceContext.instanceId && parts.push(`[instance:${instanceContext.instanceId.slice(0, 8)}]`)), parts.push(message), [parts.join(" "), context];
-}
-/**
-* Sanitize context for logging (remove sensitive data)
-* @internal
-* @remarks
-* This performs shallow sanitization only - it redacts top-level keys that contain
-* sensitive names (token, password, secret, apiKey, authorization).
-* Nested sensitive data (e.g., `\{auth: \{token: 'secret'\}\}`) will NOT be redacted.
-* If deep sanitization is needed in the future, this can be enhanced to recursively
-* traverse nested objects.
-*/
-function sanitizeContext(context) {
-	if (!context || Object.keys(context).length === 0) return;
-	let sanitized = { ...context }, sensitiveKeys = [
-		"token",
-		"password",
-		"secret",
-		"apiKey",
-		"authorization"
-	];
-	for (let key of Object.keys(sanitized)) sensitiveKeys.some((sensitive) => key.toLowerCase().includes(sensitive)) && (sanitized[key] = "[REDACTED]");
-	return sanitized;
-}
-/**
-* Create a logger for a specific namespace
-* @param namespace - A string identifier for the logging domain (e.g., 'auth', 'document')
-* @param baseContext - Optional base context to include in all log messages
-* @remarks
-* If baseContext includes an `instanceContext` property (with projectId, dataset, instanceId),
-* it will be automatically formatted into the log output for easier debugging of
-* multi-instance scenarios.
-* @public
-*/
-function createLogger(namespace, baseContext) {
-	let logAtLevel = (level, message, context) => {
-		if (!isNamespaceEnabled(namespace) || !isLevelEnabled(level) || context?.internal && !globalConfig.internal) return;
-		let [formatted, finalContext] = formatMessage(namespace, level, message, sanitizeContext({
-			...baseContext,
-			...context
-		}));
-		globalConfig.handler[level](formatted, finalContext);
-	};
-	return {
-		namespace,
-		error: (message, context) => logAtLevel("error", message, context),
-		warn: (message, context) => logAtLevel("warn", message, context),
-		info: (message, context) => logAtLevel("info", message, context),
-		debug: (message, context) => logAtLevel("debug", message, context),
-		trace: (message, context) => logAtLevel("trace", message, {
-			...context,
-			internal: !0
-		}),
-		isLevelEnabled: (level) => isNamespaceEnabled(namespace) && isLevelEnabled(level),
-		child: (childContext) => createLogger(namespace, {
-			...baseContext,
-			...childContext
-		}),
-		getInstanceContext: () => baseContext?.instanceContext
-	};
-}
-export { createLogger as n, configureLogging as t };
-
-//# sourceMappingURL=logger-DAtJb5RQ.js.map