@sanity/sdk 2.5.0 → 2.7.0

package/dist/index.js

@@ -1,9 +1,9 @@
-import { Observable, share, map, distinctUntilChanged, skip, filter, exhaustMap, from, timer, switchMap, takeWhile, firstValueFrom, fromEvent, EMPTY, defer, asapScheduler, combineLatest, of, concatMap, withLatestFrom, concat, throwError, first as first$1, Subject, takeUntil, partition, merge, shareReplay, tap as tap$1, catchError as catchError$1, startWith as startWith$1, pairwise as pairwise$1, groupBy as groupBy$1, mergeMap as mergeMap$1, throttle, race, NEVER, Subscription, retry, debounceTime as debounceTime$1 } from "rxjs";
+import { Observable, share, map, distinctUntilChanged, skip, filter, exhaustMap, from, timer, switchMap, takeWhile, firstValueFrom, fromEvent, EMPTY, defer, asapScheduler, combineLatest, of, concatMap, withLatestFrom, concat, throwError, first as first$1, Subject, takeUntil, partition, merge, shareReplay, tap as tap$1, catchError as catchError$1, startWith as startWith$1, pairwise as pairwise$1, groupBy as groupBy$1, mergeMap as mergeMap$1, throttle, race, NEVER, Subscription, debounceTime } from "rxjs";
 import { createClient, CorsOriginError } from "@sanity/client";
 import { pick, omit, isEqual, isObject } from "lodash-es";
 import { devtools } from "zustand/middleware";
 import { createStore } from "zustand/vanilla";
-import { first, switchMap as switchMap$1, groupBy, mergeMap, startWith, pairwise, filter as filter$1, map as map$1, delay, tap, catchError, scan, share as share$1, take, debounceTime } from "rxjs/operators";
+import { first, switchMap as switchMap$1, groupBy, mergeMap, startWith, pairwise, filter as filter$1, map as map$1, delay, tap, catchError, scan, share as share$1 } from "rxjs/operators";
 import { createController, createNode } from "@sanity/comlink";
 import { createSelector } from "reselect";
 import { SanityEncoder } from "@sanity/mutate";
@@ -17,16 +17,17 @@ import { isKeySegment, isKeyedObject } from "@sanity/types";
 import { createDocumentLoaderFromClient } from "@sanity/mutate/_unstable_store";
 import { SDK_CHANNEL_NAME, SDK_NODE_NAME } from "@sanity/message-protocol";
 import { fromUrl } from "@sanity/bifur-client";
-const SOURCE_ID = "__sanity_internal_sourceId";
-function datasetSource(projectId, dataset) {
-  return { [SOURCE_ID]: { projectId, dataset } };
+import { DocumentId, getPublishedId as getPublishedId$2, getDraftId as getDraftId$1, getVersionId, isDraftId, isVersionId, isPublishedId } from "@sanity/id-utils";
+function isDatasetSource(source) {
+  return "projectId" in source && "dataset" in source;
 }
-function mediaLibrarySource(id) {
-  return { [SOURCE_ID]: ["media-library", id] };
+function isMediaLibrarySource(source) {
+  return "mediaLibraryId" in source;
 }
-function canvasSource(id) {
-  return { [SOURCE_ID]: ["canvas", id] };
+function isCanvasSource(source) {
+  return "canvasId" in source;
 }
+const isReleasePerspective = (perspective) => typeof perspective == "object" && perspective !== null && "releaseName" in perspective;
 function getPublishedId(id) {
   const draftsPrefix = "drafts.";
   return id.startsWith(draftsPrefix) ? id.slice(draftsPrefix.length) : id;
@@ -38,13 +39,154 @@ function getDraftId(id) {
 function insecureRandomId() {
   return Array.from({ length: 16 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
 }
+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: {
+    // eslint-disable-next-line no-console
+    error: console.error.bind(console),
+    // eslint-disable-next-line no-console
+    warn: console.warn.bind(console),
+    // eslint-disable-next-line no-console
+    info: console.info.bind(console),
+    // eslint-disable-next-line no-console
+    debug: console.debug.bind(console),
+    // eslint-disable-next-line no-console
+    trace: console.debug.bind(console)
+    // trace uses console.debug
+  }
+};
+function parseDebugEnvVar() {
+  if (typeof process > "u" || !process.env?.DEBUG)
+    return null;
+  const debug = process.env.DEBUG;
+  if (!debug.includes("sanity"))
+    return null;
+  const config = {}, levelMatch = debug.match(/sanity:(trace|debug|info|warn|error):/), hasLevelSpecifier = !!levelMatch;
+  if (levelMatch ? config.level = levelMatch[1] : config.level = "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 {
+    const namespaces = debug.split(",").filter((s) => s.includes("sanity:")).map((s) => {
+      const 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 ?? {}
+};
+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
+  }
+);
+function configureLogging$1(config) {
+  globalConfig = {
+    ...globalConfig,
+    ...config,
+    handler: config.handler ?? globalConfig.handler
+  };
+}
+function isLoggingEnabled() {
+  return typeof process < "u" && process.env?.NODE_ENV === "production" ? globalConfig.enableInProduction : !0;
+}
+function isNamespaceEnabled(namespace) {
+  return isLoggingEnabled() ? globalConfig.namespaces.includes("*") ? !0 : globalConfig.namespaces.includes(namespace) : !1;
+}
+function isLevelEnabled(level) {
+  return isLoggingEnabled() ? LOG_LEVEL_PRIORITY[level] <= LOG_LEVEL_PRIORITY[globalConfig.level] : !1;
+}
+function formatMessage(namespace, level, message, context) {
+  const parts = [];
+  if (globalConfig.timestamps) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    parts.push(`[${timestamp}]`);
+  }
+  parts.push(`[${level.toUpperCase()}]`), parts.push(`[${namespace}]`);
+  const 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];
+}
+function sanitizeContext(context) {
+  if (!context || Object.keys(context).length === 0) return;
+  const sanitized = { ...context }, sensitiveKeys = ["token", "password", "secret", "apiKey", "authorization"];
+  for (const key of Object.keys(sanitized))
+    sensitiveKeys.some((sensitive) => key.toLowerCase().includes(sensitive)) && (sanitized[key] = "[REDACTED]");
+  return sanitized;
+}
+function createLogger(namespace, baseContext) {
+  const logAtLevel = (level, message, context) => {
+    if (!isNamespaceEnabled(namespace) || !isLevelEnabled(level) || context?.internal && !globalConfig.internal) return;
+    const mergedContext = { ...baseContext, ...context }, sanitized = sanitizeContext(mergedContext), [formatted, finalContext] = formatMessage(namespace, level, message, sanitized);
+    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
+  };
+}
 function createSanityInstance(config = {}) {
-  const instanceId = crypto.randomUUID(), disposeListeners = /* @__PURE__ */ new Map(), disposed = { current: !1 }, instance = {
+  const instanceId = crypto.randomUUID(), disposeListeners = /* @__PURE__ */ new Map(), disposed = { current: !1 }, instanceContext = {
+    instanceId,
+    projectId: config.projectId,
+    dataset: config.dataset
+  }, logger = createLogger("sdk", { instanceContext });
+  logger.info("Sanity instance created", {
+    hasProjectId: !!config.projectId,
+    hasDataset: !!config.dataset,
+    hasAuth: !!config.auth,
+    hasPerspective: !!config.perspective
+  }), logger.debug("Instance configuration", {
+    projectId: config.projectId,
+    dataset: config.dataset,
+    perspective: config.perspective,
+    hasStudioConfig: !!config.studio,
+    hasStudioTokenSource: !!config.studio?.auth?.token,
+    legacyStudioMode: config.studioMode?.enabled,
+    hasAuthProviders: !!config.auth?.providers,
+    hasAuthToken: !!config.auth?.token
+  });
+  const instance = {
     instanceId,
     config,
     isDisposed: () => disposed.current,
     dispose: () => {
-      disposed.current || (disposed.current = !0, disposeListeners.forEach((listener) => listener()), disposeListeners.clear());
+      if (disposed.current) {
+        logger.trace("Dispose called on already disposed instance", { internal: !0 });
+        return;
+      }
+      logger.trace("Disposing instance", {
+        internal: !0,
+        listenerCount: disposeListeners.size
+      }), disposed.current = !0, disposeListeners.forEach((listener) => listener()), disposeListeners.clear(), logger.info("Instance disposed");
     },
     onDispose: (cb) => {
       const listenerId = insecureRandomId();
@@ -54,14 +196,26 @@ function createSanityInstance(config = {}) {
     },
     getParent: () => {
     },
-    createChild: (next) => Object.assign(
-      createSanityInstance({
-        ...config,
-        ...next,
-        ...config.auth === next.auth ? config.auth : config.auth && next.auth && { auth: { ...config.auth, ...next.auth } }
-      }),
-      { getParent: () => instance }
-    ),
+    createChild: (next) => {
+      logger.debug("Creating child instance", {
+        parentInstanceId: instanceId.slice(0, 8),
+        overridingProjectId: !!next.projectId,
+        overridingDataset: !!next.dataset,
+        overridingAuth: !!next.auth
+      });
+      const child = Object.assign(
+        createSanityInstance({
+          ...config,
+          ...next,
+          ...config.auth === next.auth ? config.auth : config.auth && next.auth && { auth: { ...config.auth, ...next.auth } }
+        }),
+        { getParent: () => instance }
+      );
+      return logger.trace("Child instance created", {
+        internal: !0,
+        childInstanceId: child.instanceId.slice(0, 8)
+      }), child;
+    },
     match: (targetConfig) => {
       if (Object.entries(pick(targetConfig, "auth", "projectId", "dataset")).every(
         ([key, value]) => config[key] === value
@@ -129,16 +283,33 @@ const bindActionByDataset = createActionBinder((instance, options) => {
   if (!projectId || !dataset)
     throw new Error("This API requires a project ID and dataset configured.");
   return { name: `${projectId}.${dataset}`, projectId, dataset };
-}), bindActionBySource = createActionBinder((instance, { source }) => {
+}), createSourceKey = (instance, source) => {
+  let name, sourceForKey;
   if (source) {
-    const id = source[SOURCE_ID];
-    if (!id) throw new Error("Invalid source (missing ID information)");
-    return Array.isArray(id) ? { name: id.join(":") } : { name: `${id.projectId}.${id.dataset}` };
+    if (sourceForKey = source, isDatasetSource(source))
+      name = `${source.projectId}.${source.dataset}`;
+    else if (isMediaLibrarySource(source))
+      name = `media-library:${source.mediaLibraryId}`;
+    else if (isCanvasSource(source))
+      name = `canvas:${source.canvasId}`;
+    else
+      throw new Error(`Received invalid source: ${JSON.stringify(source)}`);
+    return { name, source: sourceForKey };
   }
   const { projectId, dataset } = instance.config;
   if (!projectId || !dataset)
     throw new Error("This API requires a project ID and dataset configured.");
-  return { name: `${projectId}.${dataset}` };
+  return { name: `${projectId}.${dataset}`, source: { projectId, dataset } };
+}, bindActionBySource = createActionBinder((instance, { source }) => createSourceKey(instance, source)), bindActionBySourceAndPerspective = createActionBinder((instance, options) => {
+  const { source, perspective } = options, utilizedPerspective = perspective ?? instance.config.perspective ?? "drafts";
+  let perspectiveKey;
+  isReleasePerspective(utilizedPerspective) ? perspectiveKey = utilizedPerspective.releaseName : typeof utilizedPerspective == "string" ? perspectiveKey = utilizedPerspective : perspectiveKey = JSON.stringify(utilizedPerspective);
+  const sourceKey = createSourceKey(instance, source);
+  return {
+    name: `${sourceKey.name}:${perspectiveKey}`,
+    source: sourceKey.source,
+    perspective: utilizedPerspective
+  };
 }), bindActionGlobally = createActionBinder((..._rest) => ({ name: "global" }));
 function createStateSourceAction(options) {
   const selector = typeof options == "function" ? options : options.selector, subscribeHandler = options && "onSubscribe" in options ? options.onSubscribe : void 0, isEqual2 = options && "isEqual" in options ? options.isEqual ?? Object.is : Object.is, selectorContextCache = /* @__PURE__ */ new WeakMap();
@@ -187,8 +358,25 @@ function createStateSourceAction(options) {
   }
   return stateSourceAction;
 }
+const DEFAULT_BASE = "http://localhost", AUTH_CODE_PARAM = "sid", DEFAULT_API_VERSION$1 = "2021-06-07", REQUEST_TAG_PREFIX = "sanity.sdk.auth";
+function resolveAuthMode(config, locationHref) {
+  return isStudioConfig(config) ? "studio" : detectDashboardContext(locationHref) ? "dashboard" : "standalone";
+}
+function isStudioConfig(config) {
+  return !!config.studio || !!config.studioMode?.enabled;
+}
+function detectDashboardContext(locationHref) {
+  try {
+    const contextParam = new URL(locationHref, DEFAULT_BASE).searchParams.get("_context");
+    if (!contextParam) return !1;
+    const parsed = JSON.parse(contextParam);
+    return typeof parsed == "object" && parsed !== null && !Array.isArray(parsed) && Object.keys(parsed).length > 0;
+  } catch (err) {
+    return console.error("Failed to parse dashboard context from initial location:", err), !1;
+  }
+}
 var AuthStateType = /* @__PURE__ */ ((AuthStateType2) => (AuthStateType2.LOGGED_IN = "logged-in", AuthStateType2.LOGGING_IN = "logging-in", AuthStateType2.ERROR = "error", AuthStateType2.LOGGED_OUT = "logged-out", AuthStateType2))(AuthStateType || {});
-const DEFAULT_BASE = "http://localhost", AUTH_CODE_PARAM = "sid", DEFAULT_API_VERSION$1 = "2021-06-07", REQUEST_TAG_PREFIX = "sanity.sdk.auth", REFRESH_INTERVAL = 720 * 60 * 1e3, LOCK_NAME = "sanity-token-refresh-lock";
+const REFRESH_INTERVAL = 720 * 60 * 1e3, LOCK_NAME = "sanity-token-refresh-lock";
 function getLastRefreshTime(storageArea, storageKey) {
   try {
     const data = storageArea?.getItem(`${storageKey}_last_refresh`), parsed = data ? parseInt(data, 10) : 0;
@@ -351,6 +539,47 @@ const refreshStampedToken = ({ state }) => {
       state.set("setRefreshStampedTokenError", { authState: { type: AuthStateType.ERROR, error } });
     }
   });
+}, subscribeToStateAndFetchCurrentUser = ({ state, instance }, fetchOptions) => {
+  const { clientFactory, apiHost } = state.get().options, useProjectHostname = fetchOptions?.useProjectHostname ?? isStudioConfig(instance.config), projectId = instance.config.projectId;
+  return state.observable.pipe(
+    map(({ authState, options: storeOptions }) => ({
+      authState,
+      authMethod: storeOptions.authMethod
+    })),
+    filter(
+      (value) => value.authState.type === AuthStateType.LOGGED_IN && !value.authState.currentUser
+    ),
+    map((value) => ({ token: value.authState.token, authMethod: value.authMethod })),
+    distinctUntilChanged(
+      (prev, curr) => prev.token === curr.token && prev.authMethod === curr.authMethod
+    )
+  ).pipe(
+    map(
+      ({ token, authMethod }) => clientFactory({
+        apiVersion: DEFAULT_API_VERSION$1,
+        requestTagPrefix: REQUEST_TAG_PREFIX,
+        token: authMethod === "cookie" ? void 0 : token,
+        ignoreBrowserTokenWarning: !0,
+        useProjectHostname,
+        useCdn: !1,
+        ...authMethod === "cookie" ? { withCredentials: !0 } : {},
+        ...useProjectHostname && projectId ? { projectId } : {},
+        ...apiHost && { apiHost }
+      })
+    ),
+    switchMap(
+      (client) => client.observable.request({ uri: "/users/me", method: "GET" })
+    )
+  ).subscribe({
+    next: (currentUser) => {
+      state.set("setCurrentUser", (prev) => ({
+        authState: prev.authState.type === AuthStateType.LOGGED_IN ? { ...prev.authState, currentUser } : prev.authState
+      }));
+    },
+    error: (error) => {
+      state.set("setError", { authState: { type: AuthStateType.ERROR, error } });
+    }
+  });
 };
 function getAuthCode(callbackUrl, locationHref) {
   const loc = new URL(locationHref, DEFAULT_BASE), callbackLocation = callbackUrl ? new URL(callbackUrl, DEFAULT_BASE) : void 0, callbackLocationMatches = callbackLocation ? loc.pathname.toLowerCase().startsWith(callbackLocation.pathname.toLowerCase()) : !0;
@@ -425,66 +654,53 @@ function getClientErrorApiDescription(error) {
 function isProjectUserNotFoundClientError(error) {
   return getClientErrorApiType(error) === "projectUserNotFoundError";
 }
-async function checkForCookieAuth(projectId, clientFactory) {
-  if (!projectId) return !1;
+function parseDashboardContext(locationHref) {
   try {
-    return typeof (await clientFactory({
-      projectId,
-      useCdn: !1
-    }).request({
-      uri: "/users/me",
-      withCredentials: !0,
-      tag: "users.get-current"
-    }))?.id == "string";
-  } catch {
-    return !1;
+    const contextParam = new URL(locationHref, DEFAULT_BASE).searchParams.get("_context");
+    if (contextParam) {
+      const parsedContext = JSON.parse(contextParam);
+      if (parsedContext && typeof parsedContext == "object" && !Array.isArray(parsedContext) && Object.keys(parsedContext).length > 0)
+        return delete parsedContext.sid, parsedContext;
+    }
+  } catch (err) {
+    console.error("Failed to parse dashboard context from initial location:", err);
   }
+  return {};
 }
-function getStudioTokenFromLocalStorage(storageArea, storageKey) {
-  return !storageArea || !storageKey ? null : getTokenFromStorage(storageArea, storageKey) || null;
+function getDashboardInitialState(options) {
+  const { authConfig, initialLocationHref } = options, providedToken = authConfig.token, callbackUrl = authConfig.callbackUrl, storageKey = "__sanity_auth_token", dashboardContext = parseDashboardContext(initialLocationHref), storageArea = void 0;
+  return providedToken ? {
+    authState: { type: AuthStateType.LOGGED_IN, token: providedToken, currentUser: null },
+    storageKey,
+    storageArea,
+    authMethod: void 0,
+    dashboardContext
+  } : getAuthCode(callbackUrl, initialLocationHref) || getTokenFromLocation(initialLocationHref) ? {
+    authState: { type: AuthStateType.LOGGING_IN, isExchangingToken: !1 },
+    storageKey,
+    storageArea,
+    authMethod: void 0,
+    dashboardContext
+  } : {
+    authState: { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 },
+    storageKey,
+    storageArea,
+    authMethod: void 0,
+    dashboardContext
+  };
 }
-const subscribeToStateAndFetchCurrentUser = ({
-  state,
-  instance
-}) => {
-  const { clientFactory, apiHost } = state.get().options, useProjectHostname = !!instance.config.studioMode?.enabled, projectId = instance.config.projectId;
-  return state.observable.pipe(
-    map(({ authState, options }) => ({ authState, authMethod: options.authMethod })),
-    filter(
-      (value) => value.authState.type === AuthStateType.LOGGED_IN && !value.authState.currentUser
-    ),
-    map((value) => ({ token: value.authState.token, authMethod: value.authMethod })),
-    distinctUntilChanged(
-      (prev, curr) => prev.token === curr.token && prev.authMethod === curr.authMethod
-    )
-  ).pipe(
-    map(
-      ({ token, authMethod }) => clientFactory({
-        apiVersion: DEFAULT_API_VERSION$1,
-        requestTagPrefix: REQUEST_TAG_PREFIX,
-        token: authMethod === "cookie" ? void 0 : token,
-        ignoreBrowserTokenWarning: !0,
-        useProjectHostname,
-        useCdn: !1,
-        ...authMethod === "cookie" ? { withCredentials: !0 } : {},
-        ...useProjectHostname && projectId ? { projectId } : {},
-        ...apiHost && { apiHost }
-      })
-    ),
-    switchMap(
-      (client) => client.observable.request({ uri: "/users/me", method: "GET" })
-    )
-  ).subscribe({
-    next: (currentUser) => {
-      state.set("setCurrentUser", (prev) => ({
-        authState: prev.authState.type === AuthStateType.LOGGED_IN ? { ...prev.authState, currentUser } : prev.authState
-      }));
+function initializeDashboardAuth(context, tokenRefresherRunning2) {
+  const subscriptions = [];
+  let startedRefresher = !1;
+  return subscriptions.push(subscribeToStateAndFetchCurrentUser(context, { useProjectHostname: !1 })), tokenRefresherRunning2 || (startedRefresher = !0, subscriptions.push(refreshStampedToken(context))), {
+    dispose: () => {
+      for (const subscription of subscriptions)
+        subscription.unsubscribe();
     },
-    error: (error) => {
-      state.set("setError", { authState: { type: AuthStateType.ERROR, error } });
-    }
-  });
-}, subscribeToStorageEventsAndSetToken = ({
+    tokenRefresherStarted: startedRefresher
+  };
+}
+const subscribeToStorageEventsAndSetToken = ({
   state
 }) => {
   const { storageArea, storageKey } = state.get().options;
@@ -500,6 +716,159 @@ const subscribeToStateAndFetchCurrentUser = ({
     });
   });
 };
+function getStandaloneInitialState(options) {
+  const { authConfig, initialLocationHref } = options, providedToken = authConfig.token, callbackUrl = authConfig.callbackUrl, storageKey = "__sanity_auth_token", storageArea = authConfig.storageArea ?? getDefaultStorage();
+  if (providedToken)
+    return {
+      authState: { type: AuthStateType.LOGGED_IN, token: providedToken, currentUser: null },
+      storageKey,
+      storageArea,
+      authMethod: void 0,
+      dashboardContext: {}
+    };
+  if (getAuthCode(callbackUrl, initialLocationHref) || getTokenFromLocation(initialLocationHref))
+    return {
+      authState: { type: AuthStateType.LOGGING_IN, isExchangingToken: !1 },
+      storageKey,
+      storageArea,
+      authMethod: void 0,
+      dashboardContext: {}
+    };
+  const token = getTokenFromStorage(storageArea, storageKey);
+  return token ? {
+    authState: { type: AuthStateType.LOGGED_IN, token, currentUser: null },
+    storageKey,
+    storageArea,
+    authMethod: "localstorage",
+    dashboardContext: {}
+  } : {
+    authState: { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 },
+    storageKey,
+    storageArea,
+    authMethod: void 0,
+    dashboardContext: {}
+  };
+}
+function initializeStandaloneAuth(context, tokenRefresherRunning2) {
+  const subscriptions = [];
+  let startedRefresher = !1;
+  return subscriptions.push(subscribeToStateAndFetchCurrentUser(context, { useProjectHostname: !1 })), context.state.get().options?.storageArea && subscriptions.push(subscribeToStorageEventsAndSetToken(context)), tokenRefresherRunning2 || (startedRefresher = !0, subscriptions.push(refreshStampedToken(context))), {
+    dispose: () => {
+      for (const subscription of subscriptions)
+        subscription.unsubscribe();
+    },
+    tokenRefresherStarted: startedRefresher
+  };
+}
+const COOKIE_AUTH_TIMEOUT_MS = 1e4;
+async function checkForCookieAuth(projectId, clientFactory) {
+  if (!projectId) return !1;
+  try {
+    const user = await clientFactory({
+      projectId,
+      useCdn: !1,
+      requestTagPrefix: "sdk",
+      timeout: COOKIE_AUTH_TIMEOUT_MS
+    }).request({
+      uri: "/users/me",
+      withCredentials: !0,
+      tag: "users.get-current"
+    });
+    return user != null && typeof user == "object" && typeof user.id == "string";
+  } catch {
+    return !1;
+  }
+}
+function getStudioTokenFromLocalStorage(storageArea, storageKey) {
+  return !storageArea || !storageKey ? null : getTokenFromStorage(storageArea, storageKey) || null;
+}
+function getStudioInitialState(options) {
+  const { authConfig, projectId, tokenSource } = options, storageArea = authConfig.storageArea ?? getDefaultStorage(), studioStorageKey = `__studio_auth_token_${projectId ?? ""}`;
+  if (tokenSource)
+    return {
+      authState: { type: AuthStateType.LOGGING_IN, isExchangingToken: !1 },
+      storageKey: studioStorageKey,
+      storageArea,
+      authMethod: void 0,
+      dashboardContext: {}
+    };
+  const providedToken = authConfig.token;
+  let authMethod;
+  const token = getStudioTokenFromLocalStorage(storageArea, studioStorageKey);
+  return token && (authMethod = "localstorage"), providedToken ? {
+    authState: { type: AuthStateType.LOGGED_IN, token: providedToken, currentUser: null },
+    storageKey: studioStorageKey,
+    storageArea,
+    authMethod,
+    dashboardContext: {}
+  } : token ? {
+    authState: { type: AuthStateType.LOGGED_IN, token, currentUser: null },
+    storageKey: studioStorageKey,
+    storageArea,
+    authMethod: "localstorage",
+    dashboardContext: {}
+  } : {
+    authState: { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 },
+    storageKey: studioStorageKey,
+    storageArea,
+    authMethod: void 0,
+    dashboardContext: {}
+  };
+}
+function initializeStudioAuth(context, tokenRefresherRunning2) {
+  const tokenSource = context.instance.config.studio?.auth?.token;
+  return tokenSource ? initializeWithTokenSource(context, tokenSource) : initializeWithFallback(context, tokenRefresherRunning2);
+}
+function initializeWithTokenSource(context, tokenSource) {
+  const subscriptions = [];
+  subscriptions.push(subscribeToStateAndFetchCurrentUser(context, { useProjectHostname: !0 }));
+  const tokenSub = tokenSource.subscribe({
+    next: (token) => {
+      const { state } = context;
+      token ? state.set("studioTokenSource", (prev) => ({
+        options: { ...prev.options, authMethod: void 0 },
+        authState: { type: AuthStateType.LOGGED_IN, token, currentUser: null }
+      })) : state.set("studioTokenSourceLoggedOut", (prev) => ({
+        options: { ...prev.options, authMethod: void 0 },
+        authState: { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }
+      }));
+    }
+  });
+  return {
+    dispose: () => {
+      tokenSub.unsubscribe();
+      for (const subscription of subscriptions)
+        subscription.unsubscribe();
+    },
+    // Studio handles token refresh — do not start the SDK's refresher
+    tokenRefresherStarted: !1
+  };
+}
+function initializeWithFallback(context, tokenRefresherRunning2) {
+  const subscriptions = [];
+  let startedRefresher = !1;
+  subscriptions.push(subscribeToStateAndFetchCurrentUser(context, { useProjectHostname: !0 })), context.state.get().options?.storageArea && subscriptions.push(subscribeToStorageEventsAndSetToken(context));
+  try {
+    const { instance, state } = context;
+    if (!(state.get().authState?.type === AuthStateType.LOGGED_IN && state.get().authState.token)) {
+      const projectIdValue = instance.config.projectId, clientFactory = state.get().options.clientFactory;
+      checkForCookieAuth(projectIdValue, clientFactory).then((isCookieAuthEnabled) => {
+        isCookieAuthEnabled && state.set("enableCookieAuth", (prev) => ({
+          options: { ...prev.options, authMethod: "cookie" },
+          authState: prev.authState.type === AuthStateType.LOGGED_IN ? prev.authState : { type: AuthStateType.LOGGED_IN, token: "", currentUser: null }
+        }));
+      });
+    }
+  } catch {
+  }
+  return tokenRefresherRunning2 || (startedRefresher = !0, subscriptions.push(refreshStampedToken(context))), {
+    dispose: () => {
+      for (const subscription of subscriptions)
+        subscription.unsubscribe();
+    },
+    tokenRefresherStarted: startedRefresher
+  };
+}
 let tokenRefresherRunning = !1;
 const authStore = {
   name: "Auth",
@@ -511,9 +880,7 @@ const authStore = {
       token: providedToken,
       clientFactory = createClient,
       initialLocationHref = getDefaultLocation()
-    } = instance.config.auth ?? {};
-    let storageArea = instance.config.auth?.storageArea, storageKey = "__sanity_auth_token";
-    const studioModeEnabled = instance.config.studioMode?.enabled;
+    } = instance.config.auth ?? {}, authConfig = instance.config.auth ?? {};
     let loginDomain = "https://www.sanity.io";
     try {
       apiHost && new URL(apiHost).hostname.endsWith(".sanity.work") && (loginDomain = "https://www.sanity.work");
@@ -521,27 +888,27 @@ const authStore = {
     }
     const loginUrl = new URL("/login", loginDomain);
     loginUrl.searchParams.set("origin", getCleanedUrl(initialLocationHref)), loginUrl.searchParams.set("type", "stampedToken"), loginUrl.searchParams.set("withSid", "true");
-    let dashboardContext = {}, isInDashboard = !1;
-    try {
-      const contextParam = new URL(initialLocationHref).searchParams.get("_context");
-      if (contextParam) {
-        const parsedContext = JSON.parse(contextParam);
-        parsedContext && typeof parsedContext == "object" && Object.keys(parsedContext).length > 0 && (delete parsedContext.sid, dashboardContext = parsedContext, isInDashboard = !0);
-      }
-    } catch (err) {
-      console.error("Failed to parse dashboard context from initial location:", err);
+    const mode = resolveAuthMode(instance.config, initialLocationHref), strategyOptions = {
+      authConfig,
+      projectId: instance.config.projectId,
+      initialLocationHref,
+      tokenSource: instance.config.studio?.auth?.token
+    };
+    let result;
+    switch (mode) {
+      case "studio":
+        result = getStudioInitialState(strategyOptions);
+        break;
+      case "dashboard":
+        result = getDashboardInitialState(strategyOptions);
+        break;
+      case "standalone":
+        result = getStandaloneInitialState(strategyOptions);
+        break;
     }
-    (!isInDashboard || studioModeEnabled) && (storageArea = storageArea ?? getDefaultStorage());
-    let token, authMethod;
-    if (studioModeEnabled) {
-      const studioStorageKey = `__studio_auth_token_${instance.config.projectId ?? ""}`;
-      storageKey = studioStorageKey, token = getStudioTokenFromLocalStorage(storageArea, studioStorageKey), token && (authMethod = "localstorage");
-    } else
-      token = getTokenFromStorage(storageArea, storageKey), token && (authMethod = "localstorage");
-    let authState;
-    return providedToken ? authState = { type: AuthStateType.LOGGED_IN, token: providedToken, currentUser: null } : token && studioModeEnabled ? authState = { type: AuthStateType.LOGGED_IN, token: token ?? "", currentUser: null } : getAuthCode(callbackUrl, initialLocationHref) || getTokenFromLocation(initialLocationHref) ? authState = { type: AuthStateType.LOGGING_IN, isExchangingToken: !1 } : token && !isInDashboard && !studioModeEnabled ? authState = { type: AuthStateType.LOGGED_IN, token, currentUser: null } : authState = { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }, {
-      authState,
-      dashboardContext,
+    return {
+      authState: result.authState,
+      dashboardContext: result.dashboardContext,
       options: {
         apiHost,
         loginUrl: loginUrl.toString(),
@@ -550,32 +917,27 @@ const authStore = {
         providedToken,
         clientFactory,
         initialLocationHref,
-        storageKey,
-        storageArea,
-        authMethod
+        storageKey: result.storageKey,
+        storageArea: result.storageArea,
+        authMethod: result.authMethod
       }
     };
   },
   initialize(context) {
-    const subscriptions = [];
-    subscriptions.push(subscribeToStateAndFetchCurrentUser(context)), context.state.get().options?.storageArea && subscriptions.push(subscribeToStorageEventsAndSetToken(context));
-    try {
-      const { instance, state } = context, studioModeEnabled = !!instance.config.studioMode?.enabled, token = state.get().authState?.type === AuthStateType.LOGGED_IN ? state.get().authState.token : null;
-      if (studioModeEnabled && !token) {
-        const projectId = instance.config.projectId, clientFactory = state.get().options.clientFactory;
-        checkForCookieAuth(projectId, clientFactory).then((isCookieAuthEnabled) => {
-          isCookieAuthEnabled && state.set("enableCookieAuth", (prev) => ({
-            options: { ...prev.options, authMethod: "cookie" },
-            authState: prev.authState.type === AuthStateType.LOGGED_IN ? prev.authState : { type: AuthStateType.LOGGED_IN, token: "", currentUser: null }
-          }));
-        });
-      }
-    } catch {
+    const initialLocationHref = context.state.get().options?.initialLocationHref ?? getDefaultLocation(), mode = resolveAuthMode(context.instance.config, initialLocationHref);
+    let initResult;
+    switch (mode) {
+      case "studio":
+        initResult = initializeStudioAuth(context, tokenRefresherRunning);
+        break;
+      case "dashboard":
+        initResult = initializeDashboardAuth(context, tokenRefresherRunning);
+        break;
+      case "standalone":
+        initResult = initializeStandaloneAuth(context, tokenRefresherRunning);
+        break;
     }
-    return tokenRefresherRunning || (tokenRefresherRunning = !0, subscriptions.push(refreshStampedToken(context))), () => {
-      for (const subscription of subscriptions)
-        subscription.unsubscribe();
-    };
+    return initResult.tokenRefresherStarted && (tokenRefresherRunning = !0), initResult.dispose;
   }
 }, getCurrentUserState = bindActionGlobally(
   authStore,
@@ -673,12 +1035,12 @@ const authStore = {
         `The client options provided contains unsupported properties: ${listFormatter.format(disallowedKeys)}. Allowed keys are: ${listFormatter.format(allowedKeys)}.`
       );
     }
-    const tokenFromState = state.get().token, { clients, authMethod } = state.get(), hasSource = !!options.source;
-    let sourceId = options.source?.[SOURCE_ID], resource;
-    Array.isArray(sourceId) && (resource = { type: sourceId[0], id: sourceId[1] }, sourceId = void 0);
+    const tokenFromState = state.get().token, { clients, authMethod } = state.get();
+    let resource;
+    options.source && (isDatasetSource(options.source) ? resource = { type: "dataset", id: `${options.source.projectId}.${options.source.dataset}` } : isMediaLibrarySource(options.source) ? resource = { type: "media-library", id: options.source.mediaLibraryId } : isCanvasSource(options.source) && (resource = { type: "canvas", id: options.source.canvasId }));
     const projectId = options.projectId ?? instance.config.projectId, dataset = options.dataset ?? instance.config.dataset, apiHost = options.apiHost ?? instance.config.auth?.apiHost, effectiveOptions = {
       ...DEFAULT_CLIENT_CONFIG,
-      ...(options.scope === "global" || !projectId || hasSource) && { useProjectHostname: !1 },
+      ...(options.scope === "global" || !projectId || resource) && { useProjectHostname: !1 },
       token: authMethod === "cookie" ? void 0 : tokenFromState ?? void 0,
       ...options,
       ...projectId && { projectId },
@@ -686,7 +1048,7 @@ const authStore = {
       ...apiHost && { apiHost },
       ...resource && { "~experimental_resource": resource }
     };
-    hasSource && ((options.projectId || options.dataset) && console.warn(
+    resource && ((options.projectId || options.dataset) && console.warn(
       "Both source and explicit projectId/dataset are provided. The source will be used and projectId/dataset will be ignored."
     ), delete effectiveOptions.projectId, delete effectiveOptions.dataset), effectiveOptions.token === null || typeof effectiveOptions.token > "u" ? (delete effectiveOptions.token, authMethod === "cookie" && (effectiveOptions.withCredentials = !0)) : delete effectiveOptions.withCredentials;
     const key = getClientConfigKey(effectiveOptions);
@@ -1144,6 +1506,21 @@ function createProjectHandle(handle) {
 function createDatasetHandle(handle) {
   return handle;
 }
+function configureLogging(config) {
+  configureLogging$1(config);
+  const configLevel = config.level || "warn", shouldLog = ["info", "debug", "trace"].includes(configLevel) || configLevel === "warn";
+  shouldLog && config.handler?.info ? config.handler.info(`[${(/* @__PURE__ */ new Date()).toISOString()}] [INFO] [sdk] Logging configured`, {
+    level: configLevel,
+    namespaces: config.namespaces || [],
+    internal: config.internal || !1,
+    source: "programmatic"
+  }) : shouldLog && console.info(`[${(/* @__PURE__ */ new Date()).toISOString()}] [INFO] [sdk] Logging configured`, {
+    level: configLevel,
+    namespaces: config.namespaces || [],
+    internal: config.internal || !1,
+    source: "programmatic"
+  });
+}
 const API_VERSION$4 = "v2025-02-19", datasets = createFetcherStore({
   name: "Datasets",
   getKey: (instance, options) => {
@@ -1621,7 +1998,7 @@ function sortListenerEvents(options) {
     mergeMap((state) => of(...state.emitEvents))
   );
 }
-const listen$1 = ({ state }, documentId) => {
+const listen = ({ state }, documentId) => {
   const { sharedListener, fetchDocument } = state.get();
   return sharedListener.events.pipe(
     concatMap((e) => e.type === "welcome" ? fetchDocument(documentId).pipe(
@@ -2775,9 +3152,9 @@ const _resolveDocument = bindActionByDataset(
     groupBy$1((i) => i.id),
     mergeMap$1(
       (group) => group.pipe(
-        switchMap((e) => e.add ? listen$1(context, e.id).pipe(
+        switchMap((e) => e.add ? listen(context, e.id).pipe(
           catchError$1((error) => {
-            throw error instanceof OutOfSyncError && listen$1(context, e.id), error;
+            throw error instanceof OutOfSyncError && listen(context, e.id), error;
           }),
           tap$1(
             (remote) => state.set(
@@ -3258,40 +3635,7 @@ const handleIncomingMessage = (event) => {
       return () => subscription.unsubscribe();
     }
   })
-), fetch = (client, query, params, options) => defer(
-  () => client.observable.fetch(query, params, {
-    tag: options.tag,
-    filterResponse: !0
-  })
-), listen = (client, query, params, options) => defer(
-  () => client.listen(query, params, {
-    events: ["welcome", "mutation", "reconnect"],
-    includeResult: !1,
-    visibility: "query",
-    tag: options.tag
-  })
 );
-function isWelcomeEvent(event) {
-  return event.type === "welcome";
-}
-const listenQuery = (client, query, params = {}, options = {}) => {
-  const fetchQuery = query, listenerQuery = query, fetchOnce$ = fetch(client, fetchQuery, params, options), events$ = listen(client, listenerQuery, params, options).pipe(
-    mergeMap((ev, i) => i === 0 && !isWelcomeEvent(ev) ? throwError(
-      () => new Error(
-        ev.type === "reconnect" ? "Could not establish EventSource connection" : `Received unexpected type of first event "${ev.type}"`
-      )
-    ) : of(ev)),
-    share$1()
-  ), [welcome$, mutationAndReconnect$] = partition(events$, isWelcomeEvent), isRelevantEvent = (event) => !options.transitions || event.type !== "mutation" ? !0 : options.transitions.includes(event.transition);
-  return merge(
-    welcome$.pipe(take(1)),
-    mutationAndReconnect$.pipe(filter$1(isRelevantEvent), debounceTime(options.throttleTime || 1e3))
-  ).pipe(
-    // will cancel any in-flight request when a new one comes in
-    // but ensures we always get the latest data
-    switchMap(() => fetchOnce$)
-  );
-};
 function sortReleases(releases = []) {
   return [...releases].sort((a, b) => {
     if (a.metadata.releaseType === "undecided" && b.metadata.releaseType !== "undecided")
@@ -3310,7 +3654,7 @@ function sortReleases(releases = []) {
     return a.metadata.releaseType === "asap" && b.metadata.releaseType !== "asap" ? 1 : a.metadata.releaseType !== "asap" && b.metadata.releaseType === "asap" ? -1 : a.metadata.releaseType === "asap" && b.metadata.releaseType === "asap" ? new Date(b._createdAt).getTime() - new Date(a._createdAt).getTime() : 0;
   });
 }
-const ARCHIVED_RELEASE_STATES = ["archived", "published"], releasesStore = {
+const ARCHIVED_RELEASE_STATES = ["archived", "published"], STABLE_EMPTY_RELEASES = [], releasesStore = {
   name: "Releases",
   getInitialState: () => ({
     activeReleases: void 0
@@ -3324,43 +3668,26 @@ const ARCHIVED_RELEASE_STATES = ["archived", "published"], releasesStore = {
   createStateSourceAction({
     selector: ({ state }, _) => state.activeReleases
   })
-), RELEASES_QUERY = "releases::all()", QUERY_PARAMS = {}, subscribeToReleases = ({
+), RELEASES_QUERY = "releases::all()", subscribeToReleases = ({
   instance,
   state,
   key: { projectId, dataset }
-}) => getClientState(instance, {
-  apiVersion: "2025-04-10",
-  perspective: "raw",
-  projectId,
-  dataset
-}).observable.pipe(
-  switchMap(
-    (client) => (
-      // releases are system documents, and are not supported by useQueryState
-      listenQuery(client, RELEASES_QUERY, QUERY_PARAMS, {
-        tag: "releases-listener",
-        throttleTime: 1e3,
-        transitions: ["update", "appear", "disappear"]
-      }).pipe(
-        retry({
-          count: 3,
-          delay: (error, retryCount) => (console.error("[releases] Error in subscription:", error, "Retry count:", retryCount), timer(Math.min(1e3 * Math.pow(2, retryCount), 1e4)))
-        }),
-        catchError$1((error) => (state.set("setError", { error }), EMPTY))
-      )
-    )
-  )
-).subscribe({
-  next: (releases) => {
-    state.set("setActiveReleases", {
-      activeReleases: sortReleases(releases ?? []).filter((release) => !ARCHIVED_RELEASE_STATES.includes(release.state)).reverse()
-    });
-  }
-});
-function isReleasePerspective(perspective) {
-  return typeof perspective == "object" && perspective !== null && "releaseName" in perspective;
-}
-const DEFAULT_PERSPECTIVE = "drafts", optionsCache = /* @__PURE__ */ new Map(), selectInstancePerspective = (context, _) => context.instance.config.perspective, selectActiveReleases = (context) => context.state.activeReleases, selectOptions = (_context, options) => options, memoizedOptionsSelector = createSelector(
+}) => {
+  const { observable: releases$ } = getQueryState(instance, {
+    query: RELEASES_QUERY,
+    perspective: "raw",
+    projectId,
+    dataset,
+    tag: "releases"
+  });
+  return releases$.pipe(
+    map((releases) => {
+      state.set("setActiveReleases", {
+        activeReleases: sortReleases(releases ?? STABLE_EMPTY_RELEASES).filter((release) => !ARCHIVED_RELEASE_STATES.includes(release.state)).reverse()
+      });
+    })
+  ).subscribe({ error: (error) => state.set("setError", { error }) });
+}, DEFAULT_PERSPECTIVE = "drafts", optionsCache = /* @__PURE__ */ new Map(), selectInstancePerspective = (context, _) => context.instance.config.perspective, selectActiveReleases = (context) => context.state.activeReleases, selectOptions = (_context, options) => options, memoizedOptionsSelector = createSelector(
   [selectActiveReleases, selectOptions],
   (activeReleases, options) => {
     if (!options || !activeReleases) return options;
@@ -3371,25 +3698,25 @@ const DEFAULT_PERSPECTIVE = "drafts", optionsCache = /* @__PURE__ */ new Map(),
     let cachedOptions = nestedCache.get(optionsKey);
     return cachedOptions || (cachedOptions = options, nestedCache.set(optionsKey, cachedOptions)), cachedOptions;
   }
-), getPerspectiveState = bindActionByDataset(
+), _getPerspectiveStateSelector = createStateSourceAction({
+  selector: createSelector(
+    [selectInstancePerspective, selectActiveReleases, memoizedOptionsSelector],
+    (instancePerspective, activeReleases, memoizedOptions) => {
+      const perspective = memoizedOptions?.perspective ?? instancePerspective ?? DEFAULT_PERSPECTIVE;
+      if (!isReleasePerspective(perspective)) return perspective;
+      if (!activeReleases || activeReleases.length === 0) return;
+      const releaseNames = sortReleases(activeReleases).map((release) => release.name), index = releaseNames.findIndex((name) => name === perspective.releaseName);
+      if (index < 0)
+        throw new Error(`Release "${perspective.releaseName}" not found in active releases`);
+      return ["drafts", ...releaseNames.slice(0, index + 1)].filter((name) => !perspective.excludedPerspectives?.includes(name)).reverse();
+    }
+  )
+});
+let _boundGetPerspectiveState;
+const getPerspectiveState = (...args) => (_boundGetPerspectiveState || (_boundGetPerspectiveState = bindActionByDataset(
   releasesStore,
-  createStateSourceAction({
-    selector: createSelector(
-      [selectInstancePerspective, selectActiveReleases, memoizedOptionsSelector],
-      (instancePerspective, activeReleases, memoizedOptions) => {
-        const perspective = memoizedOptions?.perspective ?? instancePerspective ?? DEFAULT_PERSPECTIVE;
-        if (!isReleasePerspective(perspective)) return perspective;
-        if (!activeReleases || activeReleases.length === 0) return;
-        const releaseNames = sortReleases(activeReleases).map((release) => release.name), index = releaseNames.findIndex((name) => name === perspective.releaseName);
-        if (index < 0)
-          throw new Error(`Release "${perspective.releaseName}" not found in active releases`);
-        return ["drafts", ...releaseNames.slice(0, index + 1)].filter(
-          (name) => !perspective.excludedPerspectives?.includes(name)
-        );
-      }
-    )
-  })
-), QUERY_STATE_CLEAR_DELAY = 1e3, QUERY_STORE_API_VERSION = "v2025-05-06", QUERY_STORE_DEFAULT_PERSPECTIVE = "drafts", setQueryError = (key, error) => (prev) => {
+  _getPerspectiveStateSelector
+)), _boundGetPerspectiveState(...args)), QUERY_STATE_CLEAR_DELAY = 1e3, QUERY_STORE_API_VERSION = "v2025-05-06", QUERY_STORE_DEFAULT_PERSPECTIVE = "drafts", setQueryError = (key, error) => (prev) => {
   const prevQuery = prev.queries[key];
   return prevQuery ? { ...prev, queries: { ...prev.queries, [key]: { ...prevQuery, error } } } : prev;
 }, setQueryData = (key, result, syncTags) => (prev) => {
@@ -3463,17 +3790,21 @@ const queryStore = {
           source,
           perspective: perspectiveFromOptions,
           ...restOptions
-        } = parseQueryKey(group$.key), perspective$ = getPerspectiveState(instance, {
+        } = parseQueryKey(group$.key), perspective$ = isReleasePerspective(perspectiveFromOptions) ? getPerspectiveState(instance, {
           perspective: perspectiveFromOptions
-        }).observable.pipe(filter(Boolean)), client$ = getClientState(instance, {
+        }).observable.pipe(filter(Boolean)) : of(perspectiveFromOptions ?? QUERY_STORE_DEFAULT_PERSPECTIVE), client$ = getClientState(instance, {
           apiVersion: QUERY_STORE_API_VERSION,
           projectId,
           dataset,
           source
         }).observable;
-        return combineLatest([lastLiveEventId$, client$, perspective$]).pipe(
+        return combineLatest({
+          lastLiveEventId: lastLiveEventId$,
+          client: client$,
+          perspective: perspective$
+        }).pipe(
           switchMap(
-            ([lastLiveEventId, client, perspective]) => client.observable.fetch(query, params, {
+            ({ lastLiveEventId, client, perspective }) => client.observable.fetch(query, params, {
               ...restOptions,
               perspective,
               filterResponse: !1,
@@ -3492,10 +3823,13 @@ const queryStore = {
   )
 ).subscribe({ error: errorHandler(state) }), listenToLiveClientAndSetLastLiveEventIds = ({
   state,
-  instance
+  instance,
+  key: { source }
 }) => {
   const liveMessages$ = getClientState(instance, {
-    apiVersion: QUERY_STORE_API_VERSION
+    apiVersion: QUERY_STORE_API_VERSION,
+    // temporary guard here until we're ready for everything to be queried via global api
+    ...source && !isDatasetSource(source) ? { source } : {}
   }).observable.pipe(
     switchMap(
       (client) => defer(
@@ -3685,7 +4019,7 @@ const BATCH_DEBOUNCE_TIME$1 = 50, isSetEqual$1 = (a, b) => a.size === b.size &&
 }) => state.observable.pipe(
   map(({ subscriptions }) => new Set(Object.keys(subscriptions))),
   distinctUntilChanged(isSetEqual$1),
-  debounceTime$1(BATCH_DEBOUNCE_TIME$1),
+  debounceTime(BATCH_DEBOUNCE_TIME$1),
   startWith$1(/* @__PURE__ */ new Set()),
   pairwise$1(),
   tap$1(([prevIds, currIds]) => {
@@ -3784,7 +4118,7 @@ const _getPreviewState = bindActionByDataset(
 ), resolvePreview = bindActionByDataset(
   previewStore,
   ({ instance }, docHandle) => firstValueFrom(getPreviewState(instance, docHandle).observable.pipe(filter((i) => !!i.data)))
-), PROJECTION_TAG = "projection", PROJECTION_PERSPECTIVE = "raw", PROJECTION_STATE_CLEAR_DELAY = 1e3, STABLE_EMPTY_PROJECTION = {
+), PROJECTION_TAG = "projection", PROJECTION_STATE_CLEAR_DELAY = 1e3, STABLE_EMPTY_PROJECTION = {
   data: null,
   isPending: !1
 };
@@ -3808,20 +4142,21 @@ function createProjectionQuery(documentIds, documentProjections) {
     return obj.documentIds.add(documentId), acc[projectionHash] = obj, acc;
   }, {}), query = `[${Object.entries(projections).map(([projectionHash, { projection }]) => `...*[_id in $__ids_${projectionHash}]{_id,_type,_updatedAt,"__projectionHash":"${projectionHash}","result":{...${projection}}}`).join(",")}]`, params = Object.fromEntries(
     Object.entries(projections).map(([projectionHash, value]) => {
-      const idsInProjection = Array.from(value.documentIds).flatMap((id) => [
-        getPublishedId(id),
-        getDraftId(id)
-      ]);
+      const idsInProjection = Array.from(value.documentIds).flatMap((id) => DocumentId(id));
       return [`__ids_${projectionHash}`, Array.from(idsInProjection)];
     })
   );
   return { query, params };
 }
-function processProjectionQuery({ ids, results }) {
+function processProjectionQuery({
+  ids,
+  results,
+  documentStatuses
+}) {
   const groupedResults = {};
   for (const result of results) {
-    const originalId = getPublishedId(result._id), hash = result.__projectionHash, isDraft = result._id.startsWith("drafts.");
-    ids.has(originalId) && (groupedResults[originalId] || (groupedResults[originalId] = {}), groupedResults[originalId][hash] || (groupedResults[originalId][hash] = {}), isDraft ? groupedResults[originalId][hash].draft = result : groupedResults[originalId][hash].published = result);
+    const originalId = getPublishedId(result._id), hash = result.__projectionHash;
+    ids.has(originalId) && (groupedResults[originalId] || (groupedResults[originalId] = {}), groupedResults[originalId][hash] || (groupedResults[originalId][hash] = void 0), groupedResults[originalId][hash] = result);
   }
   const finalValues = {};
   for (const originalId of ids) {
@@ -3829,27 +4164,40 @@ function processProjectionQuery({ ids, results }) {
     const projectionsForDoc = groupedResults[originalId];
     if (projectionsForDoc)
       for (const hash in projectionsForDoc) {
-        const { draft, published } = projectionsForDoc[hash], projectionResultData = draft?.result ?? published?.result;
+        const projectionResultData = projectionsForDoc[hash]?.result;
         if (!projectionResultData) {
           finalValues[originalId][hash] = { data: null, isPending: !1 };
           continue;
         }
-        const _status = {
-          ...draft?._updatedAt && { lastEditedDraftAt: draft._updatedAt },
-          ...published?._updatedAt && { lastEditedPublishedAt: published._updatedAt }
-        };
+        const statusFromStore = documentStatuses?.[originalId];
         finalValues[originalId][hash] = {
-          data: { ...projectionResultData, _status },
+          data: { ...projectionResultData, _status: statusFromStore },
           isPending: !1
         };
       }
   }
   return finalValues;
 }
+function buildStatusQueryIds(documentIds, perspective) {
+  const ids = [], releaseName = isReleasePerspective(perspective) ? perspective.releaseName : null;
+  for (const id of documentIds) {
+    const publishedId = getPublishedId$2(DocumentId(id)), draftId = getDraftId$1(publishedId);
+    ids.push(draftId, publishedId), releaseName && ids.push(getVersionId(publishedId, releaseName));
+  }
+  return ids;
+}
+function processStatusQueryResults(results) {
+  const documentStatuses = {};
+  for (const result of results) {
+    const id = DocumentId(result._id), updatedAt = result._updatedAt, publishedId = getPublishedId$2(id), statusData = documentStatuses[publishedId] ?? {};
+    isDraftId(id) ? statusData.lastEditedDraftAt = updatedAt : isVersionId(id) ? statusData.lastEditedVersionAt = updatedAt : isPublishedId(id) && (statusData.lastEditedPublishedAt = updatedAt), documentStatuses[publishedId] = statusData;
+  }
+  return documentStatuses;
+}
 const BATCH_DEBOUNCE_TIME = 50, isSetEqual = (a, b) => a.size === b.size && Array.from(a).every((i) => b.has(i)), subscribeToStateAndFetchBatches = ({
   state,
   instance,
-  key: { projectId, dataset }
+  key: { source, perspective }
 }) => {
   const documentProjections$ = state.observable.pipe(
     map((s) => s.documentProjections),
@@ -3858,7 +4206,7 @@ const BATCH_DEBOUNCE_TIME = 50, isSetEqual = (a, b) => a.size === b.size && Arra
     map(({ subscriptions }) => new Set(Object.keys(subscriptions))),
     distinctUntilChanged(isSetEqual)
   ), pendingUpdateSubscription = activeDocumentIds$.pipe(
-    debounceTime$1(BATCH_DEBOUNCE_TIME),
+    debounceTime(BATCH_DEBOUNCE_TIME),
     startWith$1(/* @__PURE__ */ new Set()),
     pairwise$1(),
     tap$1(([prevIds, currIds]) => {
@@ -3882,42 +4230,82 @@ const BATCH_DEBOUNCE_TIME = 50, isSetEqual = (a, b) => a.size === b.size && Arra
       });
     })
   ).subscribe(), queryExecutionSubscription = combineLatest([activeDocumentIds$, documentProjections$]).pipe(
-    debounceTime$1(BATCH_DEBOUNCE_TIME),
+    debounceTime(BATCH_DEBOUNCE_TIME),
     distinctUntilChanged(isEqual)
   ).pipe(
     switchMap(([ids, documentProjections]) => {
       if (!ids.size) return EMPTY;
-      const { query, params } = createProjectionQuery(ids, documentProjections), controller = new AbortController();
-      return new Observable((observer) => {
+      const { query, params } = createProjectionQuery(ids, documentProjections), controller = new AbortController(), statusQueryIds = buildStatusQueryIds(ids, perspective), statusQuery = "*[_id in $statusIds]{_id, _updatedAt}", statusParams = { statusIds: statusQueryIds }, projectionQuery$ = new Observable((observer) => {
         const { getCurrent, observable } = getQueryState(instance, {
           query,
           params,
-          projectId,
-          dataset,
           tag: PROJECTION_TAG,
-          perspective: PROJECTION_PERSPECTIVE
+          perspective,
+          // temporary guard here until we're ready for everything to be queried via global API
+          ...source && !isDatasetSource(source) ? { source } : {}
         }), subscription = defer(() => getCurrent() === void 0 ? from(
           resolveQuery(instance, {
             query,
             params,
-            projectId,
-            dataset,
             tag: PROJECTION_TAG,
-            perspective: PROJECTION_PERSPECTIVE,
-            signal: controller.signal
+            signal: controller.signal,
+            perspective,
+            // temporary guard here until we're ready for everything to be queried via global API in v3
+            ...source && !isDatasetSource(source) ? { source } : {}
           })
         ).pipe(switchMap(() => observable)) : observable).pipe(filter((result) => result !== void 0)).subscribe(observer);
         return () => {
           controller.signal.aborted || controller.abort(), subscription.unsubscribe();
         };
-      }).pipe(map((data) => ({ data, ids })));
+      }), statusQuery$ = new Observable((observer) => {
+        const { getCurrent, observable } = getQueryState(instance, {
+          query: statusQuery,
+          params: statusParams,
+          tag: PROJECTION_TAG,
+          perspective: "raw",
+          // temporary guard here until we're ready for everything to be queried via global API
+          ...source && !isDatasetSource(source) ? { source } : {}
+        }), subscription = defer(() => getCurrent() === void 0 ? from(
+          resolveQuery(instance, {
+            query: statusQuery,
+            params: statusParams,
+            tag: PROJECTION_TAG,
+            signal: controller.signal,
+            perspective: "raw",
+            // temporary guard here until we're ready for everything to be queried via global API
+            ...source && !isDatasetSource(source) ? { source } : {}
+          })
+        ).pipe(switchMap(() => observable)) : observable).pipe(filter((result) => result !== void 0)).subscribe(observer);
+        return () => {
+          subscription.unsubscribe();
+        };
+      });
+      return combineLatest([projectionQuery$, statusQuery$]).pipe(
+        filter(
+          (pair) => pair[0] !== void 0 && pair[1] !== void 0
+        ),
+        map(([projection, status]) => ({
+          data: projection,
+          ids,
+          statusResults: status
+        }))
+      );
     }),
-    map(
-      ({ ids, data }) => processProjectionQuery({
+    map(({ ids, data, statusResults }) => {
+      const documentStatuses = processStatusQueryResults(statusResults);
+      state.set("updateStatuses", (prev) => ({
+        documentStatuses: {
+          ...prev.documentStatuses,
+          ...documentStatuses
+        }
+      }));
+      const currentState = state.get();
+      return processProjectionQuery({
         ids,
-        results: data
-      })
-    )
+        results: data,
+        documentStatuses: currentState.documentStatuses
+      });
+    })
   ).subscribe({
     next: (processedValues) => {
       state.set("updateResult", (prev) => {
@@ -3943,7 +4331,8 @@ const BATCH_DEBOUNCE_TIME = 50, isSetEqual = (a, b) => a.size === b.size && Arra
     return {
       values: {},
       documentProjections: {},
-      subscriptions: {}
+      subscriptions: {},
+      documentStatuses: {}
     };
   },
   initialize(context) {
@@ -3954,15 +4343,15 @@ const BATCH_DEBOUNCE_TIME = 50, isSetEqual = (a, b) => a.size === b.size && Arra
 function getProjectionState(...args) {
   return _getProjectionState(...args);
 }
-const _getProjectionState = bindActionByDataset(
+const _getProjectionState = bindActionBySourceAndPerspective(
   projectionStore,
   createStateSourceAction({
     selector: ({ state }, options) => {
-      const documentId = getPublishedId(options.documentId), projectionHash = hashString(options.projection);
+      const documentId = getPublishedId$2(DocumentId(options.documentId)), projectionHash = hashString(options.projection);
       return state.values[documentId]?.[projectionHash] ?? STABLE_EMPTY_PROJECTION;
     },
     onSubscribe: ({ state }, options) => {
-      const { projection, ...docHandle } = options, subscriptionId = insecureRandomId(), documentId = getPublishedId(docHandle.documentId), validProjection = validateProjection(projection), projectionHash = hashString(validProjection);
+      const { projection, ...docHandle } = options, subscriptionId = insecureRandomId(), documentId = getPublishedId$2(DocumentId(docHandle.documentId)), validProjection = validateProjection(projection), projectionHash = hashString(validProjection);
       return state.set("addSubscription", (prev) => ({
         documentProjections: {
           ...prev.documentProjections,
@@ -4014,7 +4403,7 @@ const _getProjectionState = bindActionByDataset(
 function resolveProjection(...args) {
   return _resolveProjection(...args);
 }
-const _resolveProjection = bindActionByDataset(
+const _resolveProjection = bindActionBySourceAndPerspective(
   projectionStore,
   ({ instance }, options) => firstValueFrom(
     getProjectionState(instance, options).observable.pipe(
@@ -4122,7 +4511,7 @@ function getCorsErrorProjectId(error) {
   const projMatch = (error.message || "").match(/manage\/project\/([^/?#]+)/);
   return projMatch ? projMatch[1] : null;
 }
-var version = "2.5.0";
+var version = "2.7.0";
 const CORE_SDK_VERSION = getEnv("PKG_VERSION") || `${version}-development`;
 export {
   AuthStateType,
@@ -4133,7 +4522,7 @@ export {
   agentTransform,
   agentTranslate,
   applyDocumentActions,
-  canvasSource,
+  configureLogging,
   createDatasetHandle,
   createDocument,
   createDocumentHandle,
@@ -4141,7 +4530,6 @@ export {
   createGroqSearchFilter,
   createProjectHandle,
   createSanityInstance,
-  datasetSource,
   defineIntent,
   deleteDocument,
   destroyController,
@@ -4183,12 +4571,15 @@ export {
   getUsersKey,
   getUsersState,
   handleAuthCallback,
+  isCanvasSource,
+  isDatasetSource,
+  isMediaLibrarySource,
   isProjectUserNotFoundClientError,
+  isStudioConfig,
   joinPaths,
   jsonMatch2 as jsonMatch,
   loadMoreUsers,
   logout,
-  mediaLibrarySource,
   observeOrganizationVerificationState,
   parseQueryKey,
   parseUsersKey,