@sanity/sdk 2.8.0 → 2.10.0

package/dist/index.js

@@ -1,13 +1,11 @@
-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 } from "rxjs/operators";
+import { switchMap, from, firstValueFrom, EMPTY, asapScheduler, distinctUntilChanged, map as map$1, combineLatest, of, concatMap, withLatestFrom, filter as filter$1, concat, timer, throwError, first as first$1, Subject, takeUntil, share, 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, skip, Observable, NEVER, fromEvent, Subscription, debounceTime, defer } from "rxjs";
+import { createLogger, pickProperties, insecureRandomId, getClientState, bindActionGlobally, createStateSourceAction, setCleanupTimeout, omitProperty, defineStore, authStore, AuthStateType, getCleanedUrl, getTokenFromLocation, createLoggedInAuthState, getAuthCode, REQUEST_TAG_PREFIX, DEFAULT_API_VERSION, getDefaultLocation, isDeepEqual, configureLogging as configureLogging$1, isReleasePerspective, isDatasetResource, bindActionByResource, isMediaLibraryResource, isCanvasResource, getUsersKey, addSubscription, parseUsersKey, getClient, PROJECT_API_VERSION, setUsersError, setUsersData, API_VERSION as API_VERSION$6, getDashboardOrganizationId as getDashboardOrganizationId$1, USERS_STATE_CLEAR_DELAY, removeSubscription, updateLastLoadMoreRequest, cancelRequest, initializeRequest, getTokenState, getQueryState, resolveQuery, bindActionByResourceAndPerspective, PREVIEW_PROJECTION, transformProjectionToPreview } from "./_chunks-es/createGroqSearchFilter.js";
+import { createGroqSearchFilter, getActiveReleasesState, getAuthState, getClientErrorApiBody, getClientErrorApiDescription, getClientErrorApiType, getCurrentUserState, getIsInDashboardState, getLoginUrlState, getPerspectiveState, getQueryKey, isCanvasSource, isDatasetSource, isMediaLibrarySource, isProjectUserNotFoundClientError, isStudioConfig, parseQueryKey, setAuthToken } from "./_chunks-es/createGroqSearchFilter.js";
+import { first, switchMap as switchMap$1, groupBy, mergeMap, startWith, pairwise, filter, map, 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";
-import { getPublishedId as getPublishedId$1 } from "@sanity/client/csm";
+import { getVersionId, DocumentId, getPublishedId, getDraftId, isDraftId, isVersionId, isPublishedId } from "@sanity/id-utils";
 import { jsonMatch, stringifyPath, slicePath, getIndexForKey } from "@sanity/json-match";
 import { getIndexForKey as getIndexForKey2, getPathDepth, joinPaths, jsonMatch as jsonMatch2, slicePath as slicePath2, stringifyPath as stringifyPath2 } from "@sanity/json-match";
 import { evaluateSync, parse } from "groq-js";
@@ -17,142 +15,8 @@ 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";
-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 isMediaLibrarySource(source) {
-  return "mediaLibraryId" in source;
-}
-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;
-}
-function getDraftId(id) {
-  const draftsPrefix = "drafts.";
-  return id.startsWith(draftsPrefix) ? id : `${draftsPrefix}${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
-  };
-}
+import { CorsOriginError } from "@sanity/client";
+import { CORE_SDK_VERSION } from "./_chunks-es/version.js";
 function createSanityInstance(config = {}) {
   const instanceId = crypto.randomUUID(), disposeListeners = /* @__PURE__ */ new Map(), disposed = { current: !1 }, instanceContext = {
     instanceId,
@@ -217,7 +81,7 @@ function createSanityInstance(config = {}) {
       }), child;
     },
     match: (targetConfig) => {
-      if (Object.entries(pick(targetConfig, "auth", "projectId", "dataset")).every(
+      if (Object.entries(pickProperties(targetConfig, ["auth", "projectId", "dataset"])).every(
         ([key, value]) => config[key] === value
       ))
         return instance;
@@ -227,870 +91,38 @@ function createSanityInstance(config = {}) {
   };
   return instance;
 }
-function getEnv(key) {
-  if (typeof import.meta < "u" && 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];
-}
-function createStoreState(initialState, devToolsOptions) {
-  const store = createStore()(devtools(() => initialState, devToolsOptions));
-  return {
-    get: store.getState,
-    set: (actionKey, updatedState) => {
-      const currentState = store.getState(), nextState = typeof updatedState == "function" ? updatedState(currentState) : updatedState;
-      currentState !== nextState && store.setState(nextState, !1, actionKey);
-    },
-    observable: new Observable((observer) => {
-      const emit = () => observer.next(store.getState());
-      emit();
-      const unsubscribe = store.subscribe(emit);
-      return () => unsubscribe();
-    })
-  };
-}
-function createStoreInstance(instance, key, { name, getInitialState: getInitialState2, initialize }) {
-  const state = createStoreState(getInitialState2(instance, key), {
-    enabled: !!getEnv("DEV"),
-    name: `${name}-${key.name}`
-  }), dispose = initialize?.({ state, instance, key }), disposed = { current: !1 };
-  return {
-    state,
-    dispose: () => {
-      disposed.current || (disposed.current = !0, dispose?.());
-    },
-    isDisposed: () => disposed.current
-  };
-}
-function createActionBinder(keyFn) {
-  const instanceRegistry = /* @__PURE__ */ new Map(), storeRegistry = /* @__PURE__ */ new Map();
-  return function(storeDefinition, action) {
-    return function(instance, ...params) {
-      const key = keyFn(instance, ...params), compositeKey = storeDefinition.name + (key.name ? `:${key.name}` : "");
-      let instances = instanceRegistry.get(compositeKey);
-      instances || (instances = /* @__PURE__ */ new Set(), instanceRegistry.set(compositeKey, instances)), instances.has(instance.instanceId) || (instances.add(instance.instanceId), instance.onDispose(() => {
-        instances.delete(instance.instanceId), instances.size === 0 && (storeRegistry.get(compositeKey)?.dispose(), storeRegistry.delete(compositeKey), instanceRegistry.delete(compositeKey));
-      }));
-      let storeInstance = storeRegistry.get(compositeKey);
-      return storeInstance || (storeInstance = createStoreInstance(instance, key, storeDefinition), storeRegistry.set(compositeKey, storeInstance)), action({ instance, state: storeInstance.state, key }, ...params);
-    };
-  };
-}
-const bindActionByDataset = createActionBinder((instance, options) => {
-  const projectId = options?.projectId ?? instance.config.projectId, dataset = options?.dataset ?? instance.config.dataset;
-  if (!projectId || !dataset)
-    throw new Error("This API requires a project ID and dataset configured.");
-  return { name: `${projectId}.${dataset}`, projectId, dataset };
-}), createSourceKey = (instance, source) => {
-  let name, sourceForKey;
-  if (source) {
-    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}`, 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();
-  function stateSourceAction(context, ...params) {
-    const { state, instance } = context, getCurrent = () => {
-      const currentState = state.get();
-      if (typeof currentState != "object" || currentState === null)
-        throw new Error(
-          `Expected store state to be an object but got "${typeof currentState}" instead`
-        );
-      let instanceCache = selectorContextCache.get(currentState);
-      instanceCache || (instanceCache = /* @__PURE__ */ new WeakMap(), selectorContextCache.set(currentState, instanceCache));
-      let selectorContext = instanceCache.get(instance);
-      return selectorContext || (selectorContext = { state: currentState, instance }, instanceCache.set(instance, selectorContext)), selector(selectorContext, ...params);
-    }, subscribe = (onStoreChanged) => {
-      const cleanup = subscribeHandler?.(context, ...params), subscription = state.observable.pipe(
-        // Derive value from current state
-        map(getCurrent),
-        // Filter unchanged values using custom equality check
-        distinctUntilChanged(isEqual2),
-        // Skip initial emission since we only want changes
-        skip(1)
-      ).subscribe({
-        next: () => onStoreChanged?.(),
-        // Propagate selector errors to both subscription types
-        error: () => onStoreChanged?.()
-      });
-      return () => {
-        subscription.unsubscribe(), cleanup?.();
-      };
-    }, observable = new Observable((observer) => {
-      const emitCurrent = () => {
-        try {
-          observer.next(getCurrent());
-        } catch (error) {
-          observer.error(error);
-        }
-      };
-      return emitCurrent(), subscribe(emitCurrent);
-    }).pipe(share());
-    return {
-      getCurrent,
-      subscribe,
-      observable
-    };
-  }
-  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 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;
-    return isNaN(parsed) ? 0 : parsed;
-  } catch {
-    return 0;
-  }
-}
-function setLastRefreshTime(storageArea, storageKey) {
-  try {
-    storageArea?.setItem(`${storageKey}_last_refresh`, Date.now().toString());
-  } catch {
-  }
-}
-function getNextRefreshDelay(storageArea, storageKey) {
-  const lastRefresh = getLastRefreshTime(storageArea, storageKey);
-  if (!lastRefresh) return 0;
-  const now = Date.now(), nextRefreshTime = lastRefresh + REFRESH_INTERVAL;
-  return Math.max(0, nextRefreshTime - now);
-}
-function createTokenRefreshStream(token, clientFactory, apiHost) {
-  return new Observable((subscriber) => {
-    const subscription = clientFactory({
-      apiVersion: DEFAULT_API_VERSION$1,
-      requestTagPrefix: "token-refresh",
-      useProjectHostname: !1,
-      useCdn: !1,
-      token,
-      ignoreBrowserTokenWarning: !0,
-      ...apiHost && { apiHost }
-    }).observable.request({
-      uri: "auth/refresh-token",
-      method: "POST",
-      body: {
-        token
-      }
-    }).subscribe(subscriber);
-    return () => subscription.unsubscribe();
-  });
-}
-async function acquireTokenRefreshLock(refreshFn, storageArea, storageKey) {
-  if (!navigator.locks)
-    return console.warn("Web Locks API not supported. Proceeding with uncoordinated refresh."), await refreshFn(), setLastRefreshTime(storageArea, storageKey), !0;
-  try {
-    return await navigator.locks.request(LOCK_NAME, { mode: "exclusive" }, async (lock) => {
-      if (!lock) return !1;
-      for (; ; ) {
-        const delay2 = getNextRefreshDelay(storageArea, storageKey);
-        delay2 > 0 && await new Promise((resolve) => setTimeout(resolve, delay2));
-        try {
-          await refreshFn(), setLastRefreshTime(storageArea, storageKey);
-        } catch (error) {
-          console.error("Token refresh failed within lock:", error);
-        }
-        await new Promise((resolve) => setTimeout(resolve, REFRESH_INTERVAL));
-      }
-    }) === !0;
-  } catch (error) {
-    return console.error("Failed to request token refresh lock:", error), !1;
-  }
-}
-function shouldRefreshToken(lastRefresh) {
-  return lastRefresh ? Date.now() - lastRefresh >= REFRESH_INTERVAL : !0;
-}
-const refreshStampedToken = ({ state }) => {
-  const { clientFactory, apiHost, storageArea, storageKey } = state.get().options;
-  return state.observable.pipe(
-    map((storeState) => ({
-      authState: storeState.authState,
-      dashboardContext: storeState.dashboardContext
-    })),
-    filter(
-      (storeState) => storeState.authState.type === AuthStateType.LOGGED_IN
-    ),
-    distinctUntilChanged(
-      (prev, curr) => prev.authState.type === curr.authState.type && prev.authState.token === curr.authState.token && // Only care about token for distinctness here
-      prev.dashboardContext === curr.dashboardContext
-    ),
-    // Make distinctness check explicit
-    filter((storeState) => storeState.authState.token.includes("-st")),
-    // Ensure we only try to refresh stamped tokens
-    exhaustMap((storeState) => {
-      const performRefresh = async () => {
-        const currentState = state.get();
-        if (currentState.authState.type !== AuthStateType.LOGGED_IN)
-          throw new Error("User logged out before refresh could complete");
-        const currentToken = currentState.authState.token, response = await firstValueFrom(
-          createTokenRefreshStream(currentToken, clientFactory, apiHost)
-        );
-        state.set("setRefreshStampedToken", (prev) => ({
-          authState: prev.authState.type === AuthStateType.LOGGED_IN ? { ...prev.authState, token: response.token } : prev.authState
-        })), storageArea?.setItem(storageKey, JSON.stringify({ token: response.token }));
-      };
-      return storeState.dashboardContext ? new Observable((subscriber) => {
-        const visibilityHandler = () => {
-          const currentState = state.get();
-          document.visibilityState === "visible" && currentState.authState.type === AuthStateType.LOGGED_IN && shouldRefreshToken(currentState.authState.lastTokenRefresh) && createTokenRefreshStream(
-            currentState.authState.token,
-            clientFactory,
-            apiHost
-          ).subscribe({
-            next: (response) => {
-              state.set("setRefreshStampedToken", (prev) => ({
-                authState: prev.authState.type === AuthStateType.LOGGED_IN ? {
-                  ...prev.authState,
-                  token: response.token,
-                  lastTokenRefresh: Date.now()
-                } : prev.authState
-              })), subscriber.next(response);
-            },
-            error: (error) => subscriber.error(error)
-          });
-        }, timerSubscription = timer(REFRESH_INTERVAL, REFRESH_INTERVAL).pipe(
-          filter(() => document.visibilityState === "visible"),
-          switchMap(() => {
-            const currentState = state.get().authState;
-            if (currentState.type !== AuthStateType.LOGGED_IN)
-              throw new Error("User logged out before refresh could complete");
-            return createTokenRefreshStream(currentState.token, clientFactory, apiHost);
-          })
-        ).subscribe({
-          next: (response) => {
-            state.set("setRefreshStampedToken", (prev) => ({
-              authState: prev.authState.type === AuthStateType.LOGGED_IN ? {
-                ...prev.authState,
-                token: response.token,
-                lastTokenRefresh: Date.now()
-              } : prev.authState
-            })), subscriber.next(response);
-          },
-          error: (error) => subscriber.error(error)
-        });
-        return document.addEventListener("visibilitychange", visibilityHandler), () => {
-          document.removeEventListener("visibilitychange", visibilityHandler), timerSubscription.unsubscribe();
-        };
-      }).pipe(
-        takeWhile(() => state.get().authState.type === AuthStateType.LOGGED_IN),
-        map((response) => ({ token: response.token }))
-      ) : from(acquireTokenRefreshLock(performRefresh, storageArea, storageKey)).pipe(
-        filter((hasLock) => hasLock),
-        map(() => {
-          const currentState = state.get().authState;
-          if (currentState.type !== AuthStateType.LOGGED_IN)
-            throw new Error("User logged out before refresh could complete");
-          return { token: currentState.token };
-        })
-      );
-    })
-  ).subscribe({
-    next: (response) => {
-      state.set("setRefreshStampedToken", (prev) => ({
-        authState: prev.authState.type === AuthStateType.LOGGED_IN ? {
-          ...prev.authState,
-          token: response.token,
-          lastTokenRefresh: Date.now()
-        } : prev.authState
-      })), storageArea?.setItem(storageKey, JSON.stringify({ token: response.token }));
-    },
-    error: (error) => {
-      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;
-  let authCode = new URLSearchParams(loc.hash.slice(1)).get(AUTH_CODE_PARAM) || new URLSearchParams(loc.search).get(AUTH_CODE_PARAM);
-  if (!authCode) {
-    const contextParam = new URLSearchParams(loc.search).get("_context");
-    if (contextParam)
-      try {
-        const parsedContext = JSON.parse(contextParam);
-        parsedContext && typeof parsedContext == "object" && typeof parsedContext.sid == "string" && parsedContext.sid && (authCode = parsedContext.sid);
-      } catch {
-      }
-  }
-  return authCode && callbackLocationMatches ? authCode : null;
-}
-function getTokenFromLocation(locationHref) {
-  const loc = new URL(locationHref);
-  return new URLSearchParams(loc.hash.slice(1)).get("token") || null;
-}
-function getTokenFromStorage(storageArea, storageKey) {
-  if (!storageArea) return null;
-  const item = storageArea.getItem(storageKey);
-  if (item === null) return null;
-  try {
-    const parsed = JSON.parse(item);
-    if (typeof parsed != "object" || parsed === null || !("token" in parsed) || typeof parsed.token != "string")
-      throw new Error("Invalid stored auth data structure");
-    return parsed.token;
-  } catch {
-    return storageArea.removeItem(storageKey), null;
-  }
-}
-function getStorageEvents() {
-  return typeof window < "u" && typeof window.addEventListener == "function" ? fromEvent(window, "storage") : EMPTY;
-}
-function getDefaultStorage() {
-  try {
-    return typeof localStorage < "u" && typeof localStorage.getItem == "function" ? localStorage : void 0;
-  } catch {
-    return;
-  }
-}
-function getDefaultLocation() {
-  try {
-    return typeof location > "u" ? DEFAULT_BASE : typeof location.href == "string" ? location.href : DEFAULT_BASE;
-  } catch {
-    return DEFAULT_BASE;
-  }
-}
-function getCleanedUrl(locationUrl) {
-  const loc = new URL(locationUrl), rawHash = loc.hash.startsWith("#") ? loc.hash.slice(1) : loc.hash;
-  if (rawHash && rawHash.includes("=")) {
-    const hashParams = new URLSearchParams(rawHash);
-    hashParams.delete("token"), hashParams.delete("withSid");
-    const nextHash = hashParams.toString();
-    loc.hash = nextHash ? `#${nextHash}` : "";
-  }
-  return loc.searchParams.delete("sid"), loc.searchParams.delete("url"), loc.toString();
-}
-function getClientErrorApiBody(error) {
-  const body = error.response?.body;
-  return body && typeof body == "object" ? body : void 0;
-}
-function getClientErrorApiType(error) {
-  const body = getClientErrorApiBody(error);
-  return body?.error?.type ?? body?.type;
-}
-function getClientErrorApiDescription(error) {
-  const body = getClientErrorApiBody(error);
-  return body?.error?.description ?? body?.description;
-}
-function isProjectUserNotFoundClientError(error) {
-  return getClientErrorApiType(error) === "projectUserNotFoundError";
-}
-function parseDashboardContext(locationHref) {
-  try {
-    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 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
-  };
-}
-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();
-    },
-    tokenRefresherStarted: startedRefresher
-  };
-}
-const subscribeToStorageEventsAndSetToken = ({
-  state
-}) => {
-  const { storageArea, storageKey } = state.get().options;
-  return defer(getStorageEvents).pipe(
-    filter(
-      (e) => e.storageArea === storageArea && e.key === storageKey
-    ),
-    map(() => getTokenFromStorage(storageArea, storageKey)),
-    distinctUntilChanged()
-  ).subscribe((token) => {
-    state.set("updateTokenFromStorageEvent", {
-      authState: token ? { type: AuthStateType.LOGGED_IN, token, currentUser: null } : { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }
-    });
-  });
-};
-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",
-  getInitialState(instance) {
-    const {
-      apiHost,
-      callbackUrl,
-      providers: customProviders,
-      token: providedToken,
-      clientFactory = createClient,
-      initialLocationHref = getDefaultLocation()
-    } = 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");
-    } catch {
-    }
-    const loginUrl = new URL("/login", loginDomain);
-    loginUrl.searchParams.set("origin", getCleanedUrl(initialLocationHref)), loginUrl.searchParams.set("type", "stampedToken"), loginUrl.searchParams.set("withSid", "true");
-    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;
-    }
-    return {
-      authState: result.authState,
-      dashboardContext: result.dashboardContext,
-      options: {
-        apiHost,
-        loginUrl: loginUrl.toString(),
-        callbackUrl,
-        customProviders,
-        providedToken,
-        clientFactory,
-        initialLocationHref,
-        storageKey: result.storageKey,
-        storageArea: result.storageArea,
-        authMethod: result.authMethod
-      }
-    };
-  },
-  initialize(context) {
-    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 initResult.tokenRefresherStarted && (tokenRefresherRunning = !0), initResult.dispose;
-  }
-}, getCurrentUserState = bindActionGlobally(
-  authStore,
-  createStateSourceAction(
-    ({ state: { authState } }) => authState.type === AuthStateType.LOGGED_IN ? authState.currentUser : null
-  )
-), getTokenState = bindActionGlobally(
-  authStore,
-  createStateSourceAction(
-    ({ state: { authState } }) => authState.type === AuthStateType.LOGGED_IN ? authState.token : null
-  )
-), getAuthMethodState = bindActionGlobally(
-  authStore,
-  createStateSourceAction(({ state: { options } }) => options.authMethod)
-), getLoginUrlState = bindActionGlobally(
-  authStore,
-  createStateSourceAction(({ state: { options } }) => options.loginUrl)
-), getAuthState = bindActionGlobally(
-  authStore,
-  createStateSourceAction(({ state: { authState } }) => authState)
-), getDashboardOrganizationId$1 = bindActionGlobally(
-  authStore,
-  createStateSourceAction(({ state: { dashboardContext } }) => dashboardContext?.orgId)
-), getIsInDashboardState = bindActionGlobally(
-  authStore,
-  createStateSourceAction(
-    ({ state: { dashboardContext } }) => (
-      // Check if dashboardContext exists and is not empty
-      !!dashboardContext && Object.keys(dashboardContext).length > 0
-    )
-  )
-), setAuthToken = bindActionGlobally(authStore, ({ state }, token) => {
-  const currentAuthState = state.get().authState;
-  token ? (currentAuthState.type !== AuthStateType.LOGGED_IN || currentAuthState.token !== token) && state.set("setToken", {
-    authState: {
-      type: AuthStateType.LOGGED_IN,
-      token,
-      // Keep existing user or set to null? Setting to null forces refetch.
-      // Keep existing user to avoid unnecessary refetches if user data is still valid.
-      currentUser: currentAuthState.type === AuthStateType.LOGGED_IN ? currentAuthState.currentUser : null
-    }
-  }) : currentAuthState.type !== AuthStateType.LOGGED_OUT && state.set("setToken", {
-    authState: { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }
-  });
-}), DEFAULT_API_VERSION = "2024-11-12", DEFAULT_REQUEST_TAG_PREFIX = "sanity.sdk", 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,
-  "~experimental_resource": null,
-  source: null
-}), DEFAULT_CLIENT_CONFIG = {
-  apiVersion: DEFAULT_API_VERSION,
-  useCdn: !1,
-  ignoreBrowserTokenWarning: !0,
-  allowReconfigure: !1,
-  requestTagPrefix: DEFAULT_REQUEST_TAG_PREFIX
-}, clientStore = {
-  name: "clientStore",
-  getInitialState: (instance) => ({
-    clients: {},
-    token: getTokenState(instance).getCurrent()
-  }),
-  initialize(context) {
-    const 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(pick(options, ...allowedKeys)), getClient = bindActionGlobally(
-  clientStore,
-  ({ state, instance }, options) => {
-    if (!options || typeof options != "object")
-      throw new Error(
-        'getClient() requires a configuration object with at least an "apiVersion" property. Example: getClient(instance, { apiVersion: "2024-11-12" })'
-      );
-    const disallowedKeys = Object.keys(options).filter((key2) => !allowedKeys.includes(key2));
-    if (disallowedKeys.length > 0) {
-      const listFormatter = new Intl.ListFormat("en", { style: "long", type: "conjunction" });
-      throw new Error(
-        `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();
-    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 || resource) && { useProjectHostname: !1 },
-      token: authMethod === "cookie" ? void 0 : tokenFromState ?? void 0,
-      ...options,
-      ...projectId && { projectId },
-      ...dataset && { dataset },
-      ...apiHost && { apiHost },
-      ...resource && { "~experimental_resource": resource }
-    };
-    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);
-    if (clients[key]) return clients[key];
-    const client = createClient(effectiveOptions);
-    return state.set("addClient", (prev) => ({ clients: { ...prev.clients, [key]: client } })), client;
-  }
-), getClientState = bindActionGlobally(
-  clientStore,
-  createStateSourceAction(({ instance }, options) => getClient(instance, options))
-), API_VERSION$6 = "vX";
+const API_VERSION$5 = "vX";
 function agentGenerate(instance, options) {
   return getClientState(instance, {
-    apiVersion: API_VERSION$6,
+    apiVersion: API_VERSION$5,
     projectId: instance.config.projectId,
     dataset: instance.config.dataset
   }).observable.pipe(switchMap((client) => client.observable.agent.action.generate(options)));
 }
 function agentTransform(instance, options) {
   return getClientState(instance, {
-    apiVersion: API_VERSION$6,
+    apiVersion: API_VERSION$5,
     projectId: instance.config.projectId,
     dataset: instance.config.dataset
   }).observable.pipe(switchMap((client) => client.observable.agent.action.transform(options)));
 }
 function agentTranslate(instance, options) {
   return getClientState(instance, {
-    apiVersion: API_VERSION$6,
+    apiVersion: API_VERSION$5,
     projectId: instance.config.projectId,
     dataset: instance.config.dataset
   }).observable.pipe(switchMap((client) => client.observable.agent.action.translate(options)));
 }
 function agentPrompt(instance, options) {
   return getClientState(instance, {
-    apiVersion: API_VERSION$6,
+    apiVersion: API_VERSION$5,
     projectId: instance.config.projectId,
     dataset: instance.config.dataset
   }).observable.pipe(switchMap((client) => from(client.agent.action.prompt(options))));
 }
 function agentPatch(instance, options) {
   return getClientState(instance, {
-    apiVersion: API_VERSION$6,
+    apiVersion: API_VERSION$5,
     projectId: instance.config.projectId,
     dataset: instance.config.dataset
   }).observable.pipe(switchMap((client) => from(client.agent.action.patch(options))));
@@ -1107,7 +139,7 @@ function createFetcherStore({
   fetchThrottleInternal = 1e3,
   stateExpirationDelay = 5e3
 }) {
-  const store = {
+  const store = defineStore({
     name,
     getInitialState: () => ({
       stateByParams: {}
@@ -1116,7 +148,7 @@ function createFetcherStore({
       const subscription = subscribeToSubscriptionsAndFetch(context);
       return () => subscription.unsubscribe();
     }
-  }, subscribeToSubscriptionsAndFetch = ({
+  }), subscribeToSubscriptionsAndFetch = ({
     state
   }) => state.observable.pipe(
     // Map the state to an array of [serialized, entry] pairs.
@@ -1132,13 +164,13 @@ function createFetcherStore({
         startWith([group$.key, void 0]),
         pairwise(),
         // Trigger only when the subscriptions array grows.
-        filter$1(([[, prevEntry], [, currEntry]]) => {
+        filter(([[, prevEntry], [, currEntry]]) => {
           const prevSubs = prevEntry?.subscriptions ?? [];
           return (currEntry?.subscriptions ?? []).length > prevSubs.length;
         }),
-        map$1(([, [, currEntry]]) => currEntry),
+        map(([, [, currEntry]]) => currEntry),
         // Only trigger if we haven't fetched recently.
-        filter$1((entry) => {
+        filter((entry) => {
           const lastFetch = entry?.lastFetchInitiatedAt;
           return lastFetch ? Date.now() - new Date(lastFetch).getTime() >= fetchThrottleInternal : !0;
         }),
@@ -1160,8 +192,8 @@ function createFetcherStore({
               stateByParams: {
                 ...prev.stateByParams,
                 [entry.key]: {
-                  ...omit(entry, "error"),
-                  ...omit(prev.stateByParams[entry.key], "error"),
+                  ...omitProperty(entry, "error"),
+                  ...prev.stateByParams[entry.key] ? omitProperty(prev.stateByParams[entry.key], "error") : {},
                   data
                 }
               }
@@ -1208,12 +240,12 @@ function createFetcherStore({
             }
           }
         })), () => {
-          setTimeout(() => {
+          setCleanupTimeout(() => {
             state.set("removeSubscription", (prev) => {
               const entry = prev.stateByParams[key];
               if (!entry) return prev;
               const newSubs = (entry.subscriptions || []).filter((id) => id !== subscriptionId);
-              return newSubs.length === 0 ? { stateByParams: omit(prev.stateByParams, key) } : {
+              return newSubs.length === 0 ? { stateByParams: omitProperty(prev.stateByParams, key) } : {
                 stateByParams: {
                   ...prev.stateByParams,
                   [key]: {
@@ -1233,7 +265,7 @@ function createFetcherStore({
   );
   return { getState, resolveState };
 }
-const API_VERSION$5 = "v2025-02-19", project = createFetcherStore({
+const API_VERSION$4 = "v2025-02-19", project = createFetcherStore({
   name: "Project",
   getKey: (instance, options) => {
     const projectId = options?.projectId ?? instance.config.projectId;
@@ -1244,7 +276,7 @@ const API_VERSION$5 = "v2025-02-19", project = createFetcherStore({
   fetcher: (instance) => (options = {}) => {
     const projectId = options.projectId ?? instance.config.projectId;
     return getClientState(instance, {
-      apiVersion: API_VERSION$5,
+      apiVersion: API_VERSION$4,
       scope: "global",
       projectId
     }).observable.pipe(
@@ -1263,7 +295,7 @@ const API_VERSION$5 = "v2025-02-19", project = createFetcherStore({
 function observeOrganizationVerificationState(instance, projectIds) {
   const dashboardOrgId$ = getDashboardOrganizationId(instance).observable.pipe(distinctUntilChanged()), projectOrgIdObservables = projectIds.map(
     (id) => getProjectState(instance, { projectId: id }).observable.pipe(
-      map((project2) => ({ projectId: id, orgId: project2?.organizationId ?? null })),
+      map$1((project2) => ({ projectId: id, orgId: project2?.organizationId ?? null })),
       // Ensure we only proceed if the orgId is loaded, distinct prevents unnecessary checks
       distinctUntilChanged((prev, curr) => prev.orgId === curr.orgId)
     )
@@ -1299,7 +331,7 @@ const handleAuthCallback = bindActionGlobally(
     const cleanedUrl = getCleanedUrl(locationHref), tokenFromUrl = getTokenFromLocation(locationHref);
     if (tokenFromUrl)
       return state.set("setTokenFromUrl", {
-        authState: { type: AuthStateType.LOGGED_IN, token: tokenFromUrl, currentUser: null }
+        authState: createLoggedInAuthState(tokenFromUrl, null)
       }), cleanedUrl;
     const authCode = getAuthCode(callbackUrl, locationHref);
     if (!authCode) return !1;
@@ -1320,7 +352,7 @@ const handleAuthCallback = bindActionGlobally(
     });
     try {
       const client = clientFactory({
-        apiVersion: DEFAULT_API_VERSION$1,
+        apiVersion: DEFAULT_API_VERSION,
         requestTagPrefix: REQUEST_TAG_PREFIX,
         useProjectHostname: !1,
         useCdn: !1,
@@ -1331,7 +363,7 @@ const handleAuthCallback = bindActionGlobally(
         query: { sid: authCode },
         tag: "fetch-token"
       });
-      return storageArea?.setItem(storageKey, JSON.stringify({ token })), state.set("setToken", { authState: { type: AuthStateType.LOGGED_IN, token, currentUser: null } }), cleanedUrl;
+      return storageArea?.setItem(storageKey, JSON.stringify({ token })), state.set("setToken", { authState: createLoggedInAuthState(token, null) }), cleanedUrl;
     } catch (error) {
       return state.set("exchangeSessionForTokenError", { authState: { type: AuthStateType.ERROR, error } }), cleanedUrl;
     }
@@ -1348,11 +380,11 @@ const handleAuthCallback = bindActionGlobally(
     }), await clientFactory({
       token,
       requestTagPrefix: REQUEST_TAG_PREFIX,
-      apiVersion: DEFAULT_API_VERSION$1,
+      apiVersion: DEFAULT_API_VERSION,
       ...apiHost && { apiHost },
       useProjectHostname: !1,
       useCdn: !1
-    }).request({ uri: "/auth/logout", method: "POST" }));
+    }).request({ uri: "/auth/logout", method: "POST", tag: "logout" }));
   } finally {
     state.set("logoutSuccess", {
       authState: { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }
@@ -1370,7 +402,7 @@ const handleAuthCallback = bindActionGlobally(
     throw new Error("Controller must be initialized before using or creating channels");
   const channels = state.get().channels, existing = channels.get(options.name);
   if (existing) {
-    if (!isEqual(existing.options, options))
+    if (!isDeepEqual(existing.options, options))
       throw new Error(`Channel "${options.name}" already exists with different options`);
     return state.set("incrementChannelRefCount", {
       channels: new Map(channels).set(options.name, {
@@ -1408,7 +440,7 @@ const handleAuthCallback = bindActionGlobally(
       })
     });
   }
-}, comlinkControllerStore = {
+}, comlinkControllerStore = defineStore({
   name: "connectionStore",
   getInitialState: () => ({
     controller: null,
@@ -1420,7 +452,7 @@ const handleAuthCallback = bindActionGlobally(
       destroyController(instance);
     };
   }
-}, destroyController = bindActionGlobally(
+}), destroyController = bindActionGlobally(
   comlinkControllerStore,
   destroyController$1
 ), getOrCreateChannel = bindActionGlobally(
@@ -1432,7 +464,7 @@ const handleAuthCallback = bindActionGlobally(
 ), releaseChannel = bindActionGlobally(comlinkControllerStore, releaseChannel$1), getOrCreateNode$1 = ({ state }, options) => {
   const nodes = state.get().nodes, existing = nodes.get(options.name);
   if (existing) {
-    if (!isEqual(existing.options, options))
+    if (!isDeepEqual(existing.options, options))
       throw new Error(`Node "${options.name}" already exists with different options`);
     return existing.node.start(), existing.node;
   }
@@ -1461,7 +493,7 @@ const handleAuthCallback = bindActionGlobally(
     existing.statusUnsub && existing.statusUnsub(), existing.node.stop(), nodes.delete(name), state.set("removeNode", { nodes });
     return;
   }
-}, comlinkNodeStore = {
+}, comlinkNodeStore = defineStore({
   name: "nodeStore",
   getInitialState: () => ({
     nodes: /* @__PURE__ */ new Map(),
@@ -1474,7 +506,7 @@ const handleAuthCallback = bindActionGlobally(
       });
     };
   }
-}, releaseNode = bindActionGlobally(comlinkNodeStore, releaseNode$1), getOrCreateNode = bindActionGlobally(comlinkNodeStore, getOrCreateNode$1), NODE_RELEASE_TIME = 5e3, selectNode = (context, nodeInput) => context.state.nodes.get(nodeInput.name), getNodeState = bindActionGlobally(
+}), releaseNode = bindActionGlobally(comlinkNodeStore, releaseNode$1), getOrCreateNode = bindActionGlobally(comlinkNodeStore, getOrCreateNode$1), NODE_RELEASE_TIME = 5e3, selectNode = (context, nodeInput) => context.state.nodes.get(nodeInput.name), getNodeState = bindActionGlobally(
   comlinkNodeStore,
   createStateSourceAction({
     selector: createSelector([selectNode], (nodeEntry) => nodeEntry?.status === "connected" ? {
@@ -1486,7 +518,7 @@ const handleAuthCallback = bindActionGlobally(
       getOrCreateNode(instance, nodeInput);
       let subs = state.get().subscriptions.get(nodeName);
       return subs || (subs = /* @__PURE__ */ new Set(), state.get().subscriptions.set(nodeName, subs)), subs.add(subscriberId), () => {
-        setTimeout(() => {
+        setCleanupTimeout(() => {
           const activeSubs = state.get().subscriptions.get(nodeName);
           activeSubs && (activeSubs.delete(subscriberId), activeSubs.size === 0 && (state.get().subscriptions.delete(nodeName), releaseNode(instance, nodeName)));
         }, NODE_RELEASE_TIME);
@@ -1521,7 +553,7 @@ function configureLogging(config) {
     source: "programmatic"
   });
 }
-const API_VERSION$4 = "v2025-02-19", datasets = createFetcherStore({
+const API_VERSION$3 = "v2025-02-19", datasets = createFetcherStore({
   name: "Datasets",
   getKey: (instance, options) => {
     const projectId = options?.projectId ?? instance.config.projectId;
@@ -1530,27 +562,31 @@ const API_VERSION$4 = "v2025-02-19", datasets = createFetcherStore({
     return projectId;
   },
   fetcher: (instance) => (options) => getClientState(instance, {
-    apiVersion: API_VERSION$4,
+    apiVersion: API_VERSION$3,
     // non-null assertion is fine because we check above
     projectId: options?.projectId ?? instance.config.projectId,
     useProjectHostname: !0
   }).observable.pipe(switchMap((client) => client.observable.datasets.list()))
-}), getDatasetsState = datasets.getState, resolveDatasets = datasets.resolveState, isSanityMutatePatch = (value) => !(typeof value != "object" || !value || !("type" in value) || typeof value.type != "string" || value.type !== "patch" || !("id" in value) || typeof value.id != "string" || !("patches" in value) || !Array.isArray(value.patches));
+}), getDatasetsState = datasets.getState, resolveDatasets = datasets.resolveState;
+function getEffectiveDocumentId(doc) {
+  return doc.liveEdit ? doc.documentId : isReleasePerspective(doc.perspective) ? getVersionId(DocumentId(doc.documentId), doc.perspective.releaseName) : getPublishedId(DocumentId(doc.documentId));
+}
+const isSanityMutatePatch = (value) => !(typeof value != "object" || !value || !("type" in value) || typeof value.type != "string" || value.type !== "patch" || !("id" in value) || typeof value.id != "string" || !("patches" in value) || !Array.isArray(value.patches));
 function createDocument(doc, initialValue) {
-  return {
+  let effectiveDocumentId;
+  return typeof doc.documentId == "string" && (effectiveDocumentId = getEffectiveDocumentId({ ...doc, documentId: doc.documentId })), {
     type: "document.create",
     ...doc,
-    ...doc.documentId && {
-      documentId: doc.liveEdit ? doc.documentId : getPublishedId(doc.documentId)
-    },
+    ...effectiveDocumentId && { documentId: effectiveDocumentId },
     ...initialValue && { initialValue }
   };
 }
 function deleteDocument(doc) {
+  const effectiveDocumentId = getEffectiveDocumentId(doc);
   return {
     type: "document.delete",
     ...doc,
-    documentId: doc.liveEdit ? doc.documentId : getPublishedId(doc.documentId)
+    documentId: effectiveDocumentId
   };
 }
 function convertSanityMutatePatch(sanityPatchMutation) {
@@ -1560,45 +596,48 @@ function convertSanityMutatePatch(sanityPatchMutation) {
   });
 }
 function editDocument(doc, patches) {
-  const documentId = doc.liveEdit ? doc.documentId : getPublishedId(doc.documentId);
+  const effectiveDocumentId = getEffectiveDocumentId(doc);
   if (isSanityMutatePatch(patches)) {
     const converted = convertSanityMutatePatch(patches) ?? [];
     return {
       ...doc,
       type: "document.edit",
-      documentId,
+      documentId: effectiveDocumentId,
       patches: converted
     };
   }
   return {
     ...doc,
     type: "document.edit",
-    documentId,
+    documentId: effectiveDocumentId,
     ...patches && { patches: Array.isArray(patches) ? patches : [patches] }
   };
 }
 function publishDocument(doc) {
+  const effectiveDocumentId = getEffectiveDocumentId(doc);
   return {
     type: "document.publish",
     ...doc,
-    documentId: doc.liveEdit ? doc.documentId : getPublishedId(doc.documentId)
+    documentId: effectiveDocumentId
   };
 }
 function unpublishDocument(doc) {
+  const effectiveDocumentId = getEffectiveDocumentId(doc);
   return {
     type: "document.unpublish",
     ...doc,
-    documentId: doc.liveEdit ? doc.documentId : getPublishedId(doc.documentId)
+    documentId: effectiveDocumentId
   };
 }
 function discardDocument(doc) {
+  const effectiveDocumentId = getEffectiveDocumentId(doc);
   return {
     type: "document.discard",
     ...doc,
-    documentId: doc.liveEdit ? doc.documentId : getPublishedId(doc.documentId)
+    documentId: effectiveDocumentId
   };
 }
-const DOCUMENT_STATE_CLEAR_DELAY = 1e3, INITIAL_OUTGOING_THROTTLE_TIME = 1e3, API_VERSION$3 = "v2025-05-06";
+const DOCUMENT_STATE_CLEAR_DELAY = 1e3, INITIAL_OUTGOING_THROTTLE_TIME = 1e3, API_VERSION$2 = "v2025-05-06";
 function generateArrayKey(length = 12) {
   const numBytes = Math.ceil(length / 2), bytes = crypto.getRandomValues(new Uint8Array(numBytes));
   return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, length);
@@ -1826,7 +865,7 @@ function processMutations({
         throw new Error(
           `Cannot create document with \`_id\` \`${id}\` because another document with the same ID already exists.`
         );
-      const document2 = {
+      const document = {
         // > `_createdAt` and `_updatedAt` may be submitted and will override
         // > the default which is of course the current time. This can be used
         // > to reconstruct a data-set with its timestamp structure intact.
@@ -1839,11 +878,11 @@ function processMutations({
         _rev: transactionId,
         _id: id
       };
-      dataset[id] = document2;
+      dataset[id] = document;
       continue;
     }
     if ("createOrReplace" in mutation) {
-      const id = getId(mutation.createOrReplace._id), prev = dataset[id], document2 = {
+      const id = getId(mutation.createOrReplace._id), prev = dataset[id], document = {
         ...mutation.createOrReplace,
         // otherwise, if the mutation provided, a `_createdAt` time, use it,
         // otherwise default to now
@@ -1870,13 +909,13 @@ function processMutations({
         _rev: transactionId,
         _id: id
       };
-      dataset[id] = document2;
+      dataset[id] = document;
       continue;
     }
     if ("createIfNotExists" in mutation) {
       const id = getId(mutation.createIfNotExists._id);
       if (dataset[id]) continue;
-      const document2 = {
+      const document = {
         // same logic as `create`:
         // prefer the user's `_createdAt` and `_updatedAt`
         _createdAt: now,
@@ -1885,7 +924,7 @@ function processMutations({
         _rev: transactionId,
         _id: id
       };
-      dataset[id] = document2;
+      dataset[id] = document;
       continue;
     }
     if ("delete" in mutation) {
@@ -2002,17 +1041,17 @@ const listen = ({ state }, documentId) => {
   const { sharedListener, fetchDocument } = state.get();
   return sharedListener.events.pipe(
     concatMap((e) => e.type === "welcome" ? fetchDocument(documentId).pipe(
-      map((document2) => ({ type: "sync", document: document2 }))
+      map$1((document) => ({ type: "sync", document }))
     ) : e.type === "mutation" && e.documentId === documentId ? of(e) : EMPTY),
     sortListenerEvents(),
     withLatestFrom(
       state.observable.pipe(
-        map((s) => s.documentStates[documentId]),
-        filter(Boolean),
+        map$1((s) => s.documentStates[documentId]),
+        filter$1(Boolean),
         distinctUntilChanged()
       )
     ),
-    map(([next, documentState]) => {
+    map$1(([next, documentState]) => {
       if (next.type === "sync")
         return {
           type: "sync",
@@ -2021,7 +1060,7 @@ const listen = ({ state }, documentId) => {
           revision: next.document?._rev,
           timestamp: next.document?._updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
         };
-      const [document2] = Object.values(
+      const [document] = Object.values(
         processMutations({
           documents: { [documentId]: documentState.remote },
           mutations: next.mutations,
@@ -2032,7 +1071,7 @@ const listen = ({ state }, documentId) => {
       return {
         type: "mutation",
         documentId,
-        document: document2 ?? null,
+        document: document ?? null,
         revision: transactionId,
         timestamp,
         ...previousRev && { previousRev }
@@ -2128,7 +1167,15 @@ const documentsCache = new MultiKeyWeakMap(), actionsCache = /* @__PURE__ */ new
   ],
   (documentStates, actions) => {
     const documentIds = new Set(
-      actions.map((action) => typeof action.documentId != "string" ? [] : action.liveEdit ? [action.documentId] : [getPublishedId(action.documentId), getDraftId(action.documentId)]).flat()
+      actions.map((action) => {
+        if (typeof action.documentId != "string") return [];
+        if (action.liveEdit) return [action.documentId];
+        const ids = [
+          getPublishedId(DocumentId(action.documentId)),
+          getDraftId(DocumentId(action.documentId))
+        ];
+        return isReleasePerspective(action.perspective) && ids.push(getVersionId(DocumentId(action.documentId), action.perspective.releaseName)), ids;
+      }).flat()
     ), documents = {};
     for (const documentId of documentIds) {
       const local = documentStates[documentId]?.local;
@@ -2155,8 +1202,8 @@ const documentsCache = new MultiKeyWeakMap(), actionsCache = /* @__PURE__ */ new
     return nestedCache.get(actionsKey) || (nestedCache.set(actionsKey, normalizedActions), normalizedActions);
   }
 );
-function checkGrant$1(grantExpr, document2) {
-  const value = evaluateSync(grantExpr, { params: { document: document2 } });
+function checkGrant$1(grantExpr, document) {
+  const value = evaluateSync(grantExpr, { params: { document } });
   return value.type === "boolean" && value.data;
 }
 const enNarrowConjunction = new Intl.ListFormat("en", { style: "narrow", type: "conjunction" });
@@ -2199,11 +1246,16 @@ const _calculatePermissions = createSelector(
     }
     for (const action of actions)
       if (action.type === "document.edit" && !action.patches?.length) {
-        const docId = action.documentId, doc = action.liveEdit ? documents[docId] : documents[getDraftId(docId)] ?? documents[getPublishedId(docId)];
-        doc ? checkGrant$1(grants.update, doc) || reasons.push({
+        const docId = action.documentId;
+        let doc;
+        action.liveEdit ? doc = documents[docId] : isReleasePerspective(action.perspective) ? doc = documents[getVersionId(DocumentId(docId), action.perspective.releaseName)] : doc = documents[getDraftId(DocumentId(docId))] ?? documents[getPublishedId(DocumentId(docId))], doc ? checkGrant$1(grants.update, doc) || reasons.push({
           type: "access",
           message: `You are not allowed to edit the document with ID "${docId}".`,
           documentId: docId
+        }) : isReleasePerspective(action.perspective) ? reasons.push({
+          type: "precondition",
+          message: `The version document with ID "${docId}" could not be found. Please create it or add it to the release first.`,
+          documentId: docId
         }) : reasons.push({
           type: "precondition",
           message: `The document with ID "${docId}" could not be found. Please check that it exists before editing.`,
@@ -2220,8 +1272,8 @@ const _calculatePermissions = createSelector(
     };
   }
 );
-function checkGrant(grantExpr, document2) {
-  const value = evaluateSync(grantExpr, { params: { document: document2 } });
+function checkGrant(grantExpr, document) {
+  const value = evaluateSync(grantExpr, { params: { document } });
   return value.type === "boolean" && value.data;
 }
 class ActionError extends Error {
@@ -2254,7 +1306,11 @@ function processActions({
               transactionId,
               message: "This document already exists."
             });
-          const newDocBase2 = { _type: action.documentType, _id: documentId }, newDocWorking2 = { _type: action.documentType, _id: documentId }, mutations2 = [{ create: newDocWorking2 }];
+          const newDocBase2 = { _type: action.documentType, _id: documentId, ...action.initialValue }, mutations2 = [{ create: {
+            _type: action.documentType,
+            _id: documentId,
+            ...action.initialValue
+          } }];
           if (base = processMutations({
             documents: base,
             transactionId,
@@ -2271,29 +1327,27 @@ function processActions({
               transactionId,
               message: `You do not have permission to create document "${documentId}".`
             });
-          outgoingMutations.push(...mutations2), outgoingActions.push({
-            actionType: "sanity.action.document.create",
-            publishedId: documentId,
-            attributes: newDocWorking2
-          });
+          outgoingMutations.push(...mutations2);
           continue;
         }
-        const draftId = getDraftId(documentId), publishedId = getPublishedId(documentId);
-        if (working[draftId])
+        const versionId = isReleasePerspective(action.perspective) ? getVersionId(DocumentId(documentId), action.perspective.releaseName) : void 0, draftId = getDraftId(DocumentId(documentId)), publishedId = getPublishedId(DocumentId(documentId));
+        if (versionId ? working[versionId] : working[draftId]) {
+          const errorDocType = versionId ? "release version" : "draft";
           throw new ActionError({
             documentId,
             transactionId,
-            message: "A draft version of this document already exists. Please use or discard the existing draft before creating a new one."
+            message: `A ${errorDocType} of this document already exists. Please use or discard the existing ${errorDocType} before creating a new one.`
           });
+        }
         const newDocBase = {
-          ...base[publishedId],
+          ...base[draftId] ?? base[publishedId],
           _type: action.documentType,
-          _id: draftId,
+          _id: versionId ?? draftId,
           ...action.initialValue
         }, newDocWorking = {
-          ...working[publishedId],
+          ...working[draftId] ?? working[publishedId],
           _type: action.documentType,
-          _id: draftId,
+          _id: versionId ?? draftId,
           ...action.initialValue
         }, mutations = [{ create: newDocWorking }];
         if (base = processMutations({
@@ -2306,7 +1360,13 @@ function processActions({
           transactionId,
           mutations,
           timestamp
-        }), !checkGrant(grants.create, working[draftId]))
+        }), versionId && !checkGrant(grants.create, working[versionId]))
+          throw new PermissionActionError({
+            documentId,
+            transactionId,
+            message: `You do not have permission to create a release version for document "${documentId}".`
+          });
+        if (!versionId && !checkGrant(grants.create, working[draftId]))
           throw new PermissionActionError({
             documentId,
             transactionId,
@@ -2321,6 +1381,12 @@ function processActions({
       }
       case "document.delete": {
         const documentId = action.documentId;
+        if (isReleasePerspective(action.perspective))
+          throw new ActionError({
+            documentId,
+            transactionId,
+            message: 'Cannot delete a version document. You may want to use the "unpublish" or "discard" actions instead.'
+          });
         if (action.liveEdit) {
           if (!working[documentId])
             throw new ActionError({
@@ -2335,13 +1401,10 @@ function processActions({
               message: "You do not have permission to delete this document."
             });
           const mutations2 = [{ delete: { id: documentId } }];
-          base = processMutations({ documents: base, transactionId, mutations: mutations2, timestamp }), working = processMutations({ documents: working, transactionId, mutations: mutations2, timestamp }), outgoingMutations.push(...mutations2), outgoingActions.push({
-            actionType: "sanity.action.document.delete",
-            publishedId: documentId
-          });
+          base = processMutations({ documents: base, transactionId, mutations: mutations2, timestamp }), working = processMutations({ documents: working, transactionId, mutations: mutations2, timestamp }), outgoingMutations.push(...mutations2);
           continue;
         }
-        const draftId = getDraftId(documentId), publishedId = getPublishedId(documentId);
+        const draftId = getDraftId(DocumentId(documentId)), publishedId = getPublishedId(DocumentId(documentId));
         if (!working[publishedId])
           throw new ActionError({
             documentId,
@@ -2371,14 +1434,14 @@ function processActions({
             transactionId,
             message: `Cannot discard changes for liveEdit document "${documentId}". LiveEdit documents do not support drafts.`
           });
-        const draftId = getDraftId(documentId), mutations = [{ delete: { id: draftId } }];
-        if (!working[draftId])
+        const versionId = isReleasePerspective(action.perspective) ? getVersionId(DocumentId(documentId), action.perspective.releaseName) : getDraftId(DocumentId(documentId)), mutations = [{ delete: { id: versionId } }];
+        if (!working[versionId])
           throw new ActionError({
             documentId,
             transactionId,
-            message: `There is no draft available to discard for document "${documentId}".`
+            message: `There is no draft or version available to discard for document "${documentId}".`
           });
-        if (!checkGrant(grants.update, working[draftId]))
+        if (!checkGrant(grants.update, working[versionId]))
           throw new PermissionActionError({
             documentId,
             transactionId,
@@ -2386,7 +1449,7 @@ function processActions({
           });
         base = processMutations({ documents: base, transactionId, mutations, timestamp }), working = processMutations({ documents: working, transactionId, mutations, timestamp }), outgoingMutations.push(...mutations), outgoingActions.push({
           actionType: "sanity.action.document.version.discard",
-          versionId: draftId
+          versionId
         });
         continue;
       }
@@ -2421,38 +1484,37 @@ function processActions({
             transactionId,
             mutations: workingMutations2,
             timestamp
-          }), outgoingMutations.push(...workingMutations2), outgoingActions.push(
-            ...patches2.map(
-              (patch) => ({
-                actionType: "sanity.action.document.edit",
-                // Server requires draftId to have drafts. prefix for validation, even for liveEdit
-                draftId: getDraftId(documentId),
-                publishedId: documentId,
-                patch
-              })
-            )
-          );
+          }), outgoingMutations.push(...workingMutations2);
           continue;
         }
-        const draftId = getDraftId(documentId), publishedId = getPublishedId(documentId), userPatches = action.patches?.map((patch) => ({ patch: { id: draftId, ...patch } }));
+        const versionId = isReleasePerspective(action.perspective) ? getVersionId(DocumentId(documentId), action.perspective.releaseName) : void 0, draftId = getDraftId(DocumentId(documentId)), publishedId = getPublishedId(DocumentId(documentId)), patchDocumentId = isReleasePerspective(action.perspective) ? versionId : draftId, userPatches = action.patches?.map((patch) => ({
+          patch: { id: patchDocumentId, ...patch }
+        }));
         if (!userPatches?.length) continue;
-        if (!working[draftId] && !working[publishedId] || !base[draftId] && !base[publishedId])
+        if (isReleasePerspective(action.perspective)) {
+          if (!working[versionId] && !base[versionId])
+            throw new ActionError({
+              documentId,
+              transactionId,
+              message: "This document does not exist in the release. Please create it or add it to the release first."
+            });
+        } else if (!working[draftId] && !working[publishedId] || !base[draftId] && !base[publishedId])
           throw new ActionError({
             documentId,
             transactionId,
             message: "Cannot edit document because it does not exist in draft or published form."
           });
         const baseMutations = [];
-        !base[draftId] && base[publishedId] && baseMutations.push({ create: { ...base[publishedId], _id: draftId } });
-        const baseBefore = base[draftId] ?? base[publishedId];
+        !isReleasePerspective(action.perspective) && !base[draftId] && base[publishedId] && baseMutations.push({ create: { ...base[publishedId], _id: draftId } });
+        const baseBefore = base[patchDocumentId] ?? base[publishedId];
         userPatches && baseMutations.push(...userPatches), base = processMutations({
           documents: base,
           transactionId,
           mutations: baseMutations,
           timestamp
         });
-        const baseAfter = base[draftId], patches = diffValue(baseBefore, baseAfter), workingMutations = [];
-        if (!working[draftId] && working[publishedId]) {
+        const baseAfter = base[patchDocumentId], patches = diffValue(baseBefore, baseAfter), workingMutations = [];
+        if (!isReleasePerspective(action.perspective) && !working[draftId] && working[publishedId]) {
           const newDraftFromPublished = { ...working[publishedId], _id: draftId };
           if (!checkGrant(grants.create, newDraftFromPublished))
             throw new PermissionActionError({
@@ -2462,46 +1524,44 @@ function processActions({
             });
           workingMutations.push({ create: newDraftFromPublished });
         }
-        const workingBefore = working[draftId] ?? working[publishedId];
+        const workingBefore = working[patchDocumentId] ?? working[publishedId];
         if (!checkGrant(grants.update, workingBefore))
           throw new PermissionActionError({
             documentId,
             transactionId,
             message: `You do not have permission to edit document "${documentId}".`
           });
-        workingMutations.push(...patches.map((patch) => ({ patch: { id: draftId, ...patch } }))), working = processMutations({
+        workingMutations.push(...patches.map((patch) => ({ patch: { id: patchDocumentId, ...patch } }))), working = processMutations({
           documents: working,
           transactionId,
           mutations: workingMutations,
           timestamp
         }), outgoingMutations.push(...workingMutations), outgoingActions.push(
-          ...patches.map(
-            (patch) => ({
-              actionType: "sanity.action.document.edit",
-              draftId,
-              publishedId,
-              patch
-            })
-          )
+          ...patches.map((patch) => ({
+            actionType: "sanity.action.document.edit",
+            draftId: patchDocumentId,
+            publishedId,
+            patch
+          }))
         );
         continue;
       }
       case "document.publish": {
         const documentId = getId(action.documentId);
-        if (action.liveEdit)
+        if (action.liveEdit || isReleasePerspective(action.perspective))
           throw new ActionError({
             documentId,
             transactionId,
-            message: `Cannot publish liveEdit document "${documentId}". LiveEdit documents do not support drafts or publishing.`
+            message: "Cannot publish this document. Publishing is not supported for liveEdit or version (release) documents."
           });
-        const draftId = getDraftId(documentId), publishedId = getPublishedId(documentId), workingDraft = working[draftId], baseDraft = base[draftId];
+        const draftId = getDraftId(DocumentId(documentId)), publishedId = getPublishedId(DocumentId(documentId)), workingDraft = working[draftId], baseDraft = base[draftId];
         if (!workingDraft || !baseDraft)
           throw new ActionError({
             documentId,
             transactionId,
             message: `Cannot publish because no draft version was found for document "${documentId}".`
           });
-        if (!isEqual(workingDraft, baseDraft))
+        if (!isDeepEqual(workingDraft, baseDraft))
           throw new ActionError({
             documentId,
             transactionId,
@@ -2538,13 +1598,13 @@ function processActions({
       }
       case "document.unpublish": {
         const documentId = getId(action.documentId);
-        if (action.liveEdit)
+        if (action.liveEdit || isReleasePerspective(action.perspective))
           throw new ActionError({
             documentId,
             transactionId,
-            message: `Cannot unpublish liveEdit document "${documentId}". LiveEdit documents do not support drafts or publishing.`
+            message: "Cannot unpublish this document. Unpublishing is not supported for liveEdit or version (release) documents."
           });
-        const draftId = getDraftId(documentId), publishedId = getPublishedId(documentId);
+        const draftId = getDraftId(DocumentId(documentId)), publishedId = getPublishedId(DocumentId(documentId));
         if (!working[publishedId] && !base[publishedId])
           throw new ActionError({
             documentId,
@@ -2618,7 +1678,7 @@ const EMPTY_REVISIONS = {};
 function queueTransaction(prev, transaction) {
   const { transactionId, actions } = transaction;
   return {
-    ...getDocumentIdsFromActions(actions).reduce(
+    ...getDocumentIdsFromHandleLikes(actions).reduce(
       (acc, id) => addSubscriptionIdToDocument(acc, id, transactionId),
       prev
     ),
@@ -2628,7 +1688,7 @@ function queueTransaction(prev, transaction) {
 function removeQueuedTransaction(prev, transactionId) {
   const transaction = prev.queued.find((t) => t.transactionId === transactionId);
   return transaction ? {
-    ...getDocumentIdsFromActions(transaction.actions).reduce(
+    ...getDocumentIdsFromHandleLikes(transaction.actions).reduce(
       (acc, id) => removeSubscriptionIdFromDocument(acc, id, transactionId),
       prev
     ),
@@ -2638,7 +1698,7 @@ function removeQueuedTransaction(prev, transactionId) {
 function applyFirstQueuedTransaction(prev) {
   const queued = prev.queued.at(0);
   if (!queued || !prev.grants) return prev;
-  const ids = getDocumentIdsFromActions(queued.actions);
+  const ids = getDocumentIdsFromHandleLikes(queued.actions);
   if (ids.some((id) => prev.documentStates[id]?.local === void 0)) return prev;
   const working = ids.reduce((acc, id) => (acc[id] = prev.documentStates[id]?.local, acc), {}), timestamp = (/* @__PURE__ */ new Date()).toISOString(), result = processActions({
     ...queued,
@@ -2690,7 +1750,7 @@ function batchAppliedTransactions([curr, ...rest]) {
   if (!rest.length) return editAction;
   const next = batchAppliedTransactions(rest);
   if (next)
-    return next.disableBatching ? editAction : {
+    return next.disableBatching || !!action.liveEdit != !!next.actions[0]?.liveEdit ? editAction : {
       disableBatching: !1,
       // Use the transactionId from the later (next) transaction.
       transactionId: next.transactionId,
@@ -2748,7 +1808,7 @@ function cleanupOutgoingTransaction(prev) {
   const { outgoing } = prev;
   if (!outgoing) return prev;
   let next = prev;
-  const ids = getDocumentIdsFromActions(outgoing.actions);
+  const ids = getDocumentIdsFromHandleLikes(outgoing.actions);
   for (const transactionId of outgoing.batchedTransactionIds)
     for (const documentId of ids)
       next = removeSubscriptionIdFromDocument(next, documentId, transactionId);
@@ -2780,20 +1840,20 @@ function revertOutgoingTransaction(prev) {
         const next = {
           ...documentState,
           local: documentId in working ? working[documentId] : local,
-          unverifiedRevisions: prev.outgoing && prev.outgoing.transactionId in unverifiedRevisions ? omit(unverifiedRevisions, prev.outgoing.transactionId) : unverifiedRevisions
+          unverifiedRevisions: prev.outgoing && prev.outgoing.transactionId in unverifiedRevisions ? omitProperty(unverifiedRevisions, prev.outgoing.transactionId) : unverifiedRevisions
         };
         return [documentId, next];
       })
     )
   };
 }
-function applyRemoteDocument(prev, { document: document2, documentId, previousRev, revision, timestamp, type }, events) {
+function applyRemoteDocument(prev, { document, documentId, previousRev, revision, timestamp, type }, events) {
   if (!prev.grants) return prev;
   const prevDocState = prev.documentStates[documentId];
   if (!prevDocState) return prev;
   const prevUnverifiedRevisions = prevDocState.unverifiedRevisions, revisionToVerify = revision ? prevUnverifiedRevisions?.[revision] : void 0;
   let unverifiedRevisions = prevUnverifiedRevisions ?? EMPTY_REVISIONS;
-  if (revision && revisionToVerify && (unverifiedRevisions = omit(prevUnverifiedRevisions, revision)), type === "sync" && (unverifiedRevisions = Object.fromEntries(
+  if (revision && revisionToVerify && (unverifiedRevisions = omitProperty(prevUnverifiedRevisions, revision)), type === "sync" && (unverifiedRevisions = Object.fromEntries(
     Object.entries(unverifiedRevisions).filter(([, unverifiedRevision]) => unverifiedRevision ? new Date(timestamp).getTime() <= new Date(unverifiedRevision.timestamp).getTime() : !1)
   )), revisionToVerify && revisionToVerify.previousRev === previousRev)
     return {
@@ -2802,13 +1862,13 @@ function applyRemoteDocument(prev, { document: document2, documentId, previousRe
         ...prev.documentStates,
         [documentId]: {
           ...prevDocState,
-          remote: document2,
+          remote: document,
           remoteRev: revision,
           unverifiedRevisions
         }
       }
     };
-  let working = { ...prev.applied.at(0)?.previous, [documentId]: document2 };
+  let working = { ...prev.applied.at(0)?.previous, [documentId]: document };
   const nextApplied = [];
   for (const curr of prev.applied)
     try {
@@ -2834,7 +1894,7 @@ function applyRemoteDocument(prev, { document: document2, documentId, previousRe
       ...prev.documentStates,
       [documentId]: {
         ...prevDocState,
-        remote: document2,
+        remote: document,
         remoteRev: revision,
         local: working[documentId],
         unverifiedRevisions
@@ -2864,17 +1924,10 @@ function removeSubscriptionIdFromDocument(prev, documentId, subscriptionId) {
       ...prev.documentStates,
       [documentId]: { ...prevDocState, subscriptions }
     }
-  } : { ...prev, documentStates: omit(prev.documentStates, documentId) } : prev;
+  } : { ...prev, documentStates: omitProperty(prev.documentStates, documentId) } : prev;
 }
-function manageSubscriberIds({ state }, documentId, options) {
-  const expandDraftPublished = options?.expandDraftPublished ?? !0, documentIds = Array.from(
-    new Set(
-      expandDraftPublished ? (Array.isArray(documentId) ? documentId : [documentId]).flatMap((id) => [
-        getPublishedId$1(id),
-        getDraftId(id)
-      ]) : Array.isArray(documentId) ? documentId : [documentId]
-    )
-  ), subscriptionId = insecureRandomId();
+function manageSubscriberIds({ state }, handles) {
+  const documentIds = getDocumentIdsFromHandleLikes(handles), subscriptionId = insecureRandomId();
   return state.set(
     "addSubscribers",
     (prev) => documentIds.reduce(
@@ -2882,7 +1935,7 @@ function manageSubscriberIds({ state }, documentId, options) {
       prev
     )
   ), () => {
-    setTimeout(() => {
+    setCleanupTimeout(() => {
       state.set(
         "removeSubscribers",
         (prev) => documentIds.reduce(
@@ -2893,12 +1946,13 @@ function manageSubscriberIds({ state }, documentId, options) {
     }, DOCUMENT_STATE_CLEAR_DELAY);
   };
 }
-function getDocumentIdsFromActions(actions) {
-  return Array.from(
-    new Set(
-      actions.map((i) => i.documentId).filter((i) => typeof i == "string").flatMap((documentId) => [getPublishedId$1(documentId), getDraftId(documentId)])
-    )
-  );
+function getDocumentIdsFromHandleLikes(handles) {
+  return handles.flatMap((handle) => {
+    const idsForDocument = [];
+    return handle.documentId ? handle.liveEdit ? [handle.documentId] : (isReleasePerspective(handle.perspective) && idsForDocument.push(
+      getVersionId(DocumentId(handle.documentId), handle.perspective.releaseName)
+    ), idsForDocument.push(getPublishedId(DocumentId(handle.documentId))), idsForDocument.push(getDraftId(DocumentId(handle.documentId))), idsForDocument) : [];
+  });
 }
 function getDocumentEvents(outgoing) {
   const documentIdsByAction = Object.entries(
@@ -2923,10 +1977,12 @@ function getDocumentEvents(outgoing) {
     )
   );
 }
-const API_VERSION$2 = "v2025-05-06";
-function createSharedListener(instance) {
+const API_VERSION$1 = "v2025-05-06";
+function createSharedListener(instance, resource) {
   const dispose$ = new Subject(), events$ = getClientState(instance, {
-    apiVersion: API_VERSION$2
+    apiVersion: API_VERSION$1,
+    // TODO: remove in v3 when we're ready for everything to be queried via resource
+    resource: resource && !isDatasetResource(resource) ? resource : void 0
   }).observable.pipe(
     switchMap(
       (client) => (
@@ -2960,11 +2016,15 @@ function createSharedListener(instance) {
     dispose: () => dispose$.next()
   };
 }
-function createFetchDocument(instance) {
+function createFetchDocument(instance, resource) {
   return function(documentId) {
-    return getClientState(instance, { apiVersion: API_VERSION$2 }).observable.pipe(
+    return getClientState(instance, {
+      apiVersion: API_VERSION$1,
+      // TODO: remove in v3 when we're ready for everything to be queried via resource
+      resource: resource && !isDatasetResource(resource) ? resource : void 0
+    }).observable.pipe(
       switchMap((client) => createDocumentLoaderFromClient(client)(documentId)),
-      map((result) => {
+      map$1((result) => {
         if (!result.accessible) {
           if (result.reason === "existence") return null;
           throw new Error(`Document with ID \`${documentId}\` is inaccessible due to permissions.`);
@@ -2975,15 +2035,15 @@ function createFetchDocument(instance) {
     );
   };
 }
-const documentStore = {
+const documentStore = defineStore({
   name: "Document",
-  getInitialState: (instance) => ({
+  getInitialState: (instance, { resource }) => ({
     documentStates: {},
     // these can be emptied on refetch
     queued: [],
     applied: [],
-    sharedListener: createSharedListener(instance),
-    fetchDocument: createFetchDocument(instance),
+    sharedListener: createSharedListener(instance, resource),
+    fetchDocument: createFetchDocument(instance, resource),
     events: new Subject()
   }),
   initialize(context) {
@@ -2997,83 +2057,92 @@ const documentStore = {
       sharedListener.dispose(), subscriptions.forEach((subscription) => subscription.unsubscribe());
     };
   }
-};
+});
 function getDocumentState(...args) {
   return _getDocumentState(...args);
 }
-const _getDocumentState = bindActionByDataset(
+const _getDocumentState = bindActionByResource(
   documentStore,
   createStateSourceAction({
     selector: ({ state: { error, documentStates } }, options) => {
-      const { documentId, path, liveEdit } = options;
+      const { documentId: docId, path, liveEdit, perspective } = options, documentId = DocumentId(docId);
       if (error) throw error;
-      if (liveEdit) {
-        const document22 = documentStates[documentId]?.local;
-        if (document22 === void 0) return;
-        if (!path) return document22;
-        const result2 = jsonMatch(document22, path).next();
-        if (result2.done) return;
-        const { value: value2 } = result2.value;
-        return value2;
+      let document;
+      if (liveEdit)
+        document = documentStates[documentId]?.local;
+      else {
+        let version;
+        if (isReleasePerspective(perspective)) {
+          const versionId = getVersionId(documentId, perspective.releaseName);
+          if (version = documentStates[versionId]?.local, version === void 0) return;
+        }
+        const draft = documentStates[getDraftId(documentId)]?.local, published = documentStates[getPublishedId(documentId)]?.local;
+        if (draft === void 0 || published === void 0) return;
+        document = version ?? draft ?? published;
       }
-      const draftId = getDraftId(documentId), publishedId = getPublishedId$1(documentId), draft = documentStates[draftId]?.local, published = documentStates[publishedId]?.local;
-      if (draft === void 0 || published === void 0) return;
-      const document2 = draft ?? published;
-      if (!path) return document2;
-      const result = jsonMatch(document2, path).next();
+      if (!path) return document;
+      const result = jsonMatch(document, path).next();
       if (result.done) return;
       const { value } = result.value;
       return value;
     },
-    onSubscribe: (context, options) => manageSubscriberIds(context, options.documentId, { expandDraftPublished: !options.liveEdit })
+    onSubscribe: (context, options) => manageSubscriberIds(context, [options])
   })
 );
 function resolveDocument(...args) {
   return _resolveDocument(...args);
 }
-const _resolveDocument = bindActionByDataset(
+const _resolveDocument = bindActionByResource(
   documentStore,
   ({ instance }, docHandle) => firstValueFrom(
     getDocumentState(instance, {
       ...docHandle,
       path: void 0
-    }).observable.pipe(filter((i) => i !== void 0))
+    }).observable.pipe(filter$1((i) => i !== void 0))
   )
-), getDocumentSyncStatus = bindActionByDataset(
+), getDocumentSyncStatus = bindActionByResource(
   documentStore,
   createStateSourceAction({
     selector: ({ state: { error, documentStates: documents, outgoing, applied, queued } }, doc) => {
-      const documentId = typeof doc == "string" ? doc : doc.documentId;
+      const documentId = DocumentId(typeof doc == "string" ? doc : doc.documentId);
       if (error) throw error;
-      if (doc.liveEdit)
-        return documents[documentId] === void 0 ? void 0 : !queued.length && !applied.length && !outgoing;
-      const draftId = getDraftId(documentId), publishedId = getPublishedId$1(documentId), draft = documents[draftId], published = documents[publishedId];
-      if (!(draft === void 0 || published === void 0))
-        return !queued.length && !applied.length && !outgoing;
+      if (doc.liveEdit) {
+        if (documents[documentId] === void 0) return;
+      } else {
+        const version = isReleasePerspective(doc.perspective) ? documents[getVersionId(documentId, doc.perspective.releaseName)] : void 0;
+        if (isReleasePerspective(doc.perspective) && version === void 0) return;
+        const draft = documents[getDraftId(documentId)], published = documents[getPublishedId(documentId)];
+        if (draft === void 0 || published === void 0) return;
+      }
+      return !queued.length && !applied.length && !outgoing;
     },
-    onSubscribe: (context, doc) => manageSubscriberIds(context, doc.documentId)
+    onSubscribe: (context, doc) => manageSubscriberIds(context, [doc])
   })
-), getPermissionsState = bindActionByDataset(
+), getPermissionsState = bindActionByResource(
   documentStore,
   createStateSourceAction({
     selector: calculatePermissions,
-    onSubscribe: (context, { actions }) => manageSubscriberIds(context, getDocumentIdsFromActions(actions))
+    onSubscribe: (context, { actions }) => {
+      manageSubscriberIds(context, actions);
+    }
   })
-), resolvePermissions = bindActionByDataset(
+), resolvePermissions = bindActionByResource(
   documentStore,
   ({ instance }, options) => firstValueFrom(
-    getPermissionsState(instance, options).observable.pipe(filter((i) => i !== void 0))
+    getPermissionsState(instance, options).observable.pipe(filter$1((i) => i !== void 0))
   )
-), subscribeDocumentEvents = bindActionByDataset(
+), subscribeDocumentEvents = bindActionByResource(
   documentStore,
-  ({ state }, eventHandler) => {
-    const { events } = state.get(), subscription = events.subscribe(eventHandler);
+  ({ state }, options) => {
+    const { events } = state.get(), subscription = events.subscribe(options.eventHandler);
     return () => subscription.unsubscribe();
   }
-), subscribeToQueuedAndApplyNextTransaction = ({ state }) => {
+), subscribeToQueuedAndApplyNextTransaction = ({
+  state
+}) => {
   const { events } = state.get();
   return state.observable.pipe(
-    map(applyFirstQueuedTransaction),
+    map$1(applyFirstQueuedTransaction),
     distinctUntilChanged(),
     tap$1((next) => state.set("applyFirstQueuedTransaction", next)),
     catchError$1((error, caught) => {
@@ -3093,7 +2162,8 @@ const _resolveDocument = bindActionByDataset(
   ).subscribe({ error: (error) => state.set("setError", { error }) });
 }, subscribeToAppliedAndSubmitNextTransaction = ({
   state,
-  instance
+  instance,
+  key: { resource }
 }) => {
   const { events } = state.get();
   return state.observable.pipe(
@@ -3108,19 +2178,41 @@ const _resolveDocument = bindActionByDataset(
       ),
       { leading: !1, trailing: !0 }
     ),
-    map(transitionAppliedTransactionsToOutgoing),
+    map$1(transitionAppliedTransactionsToOutgoing),
     distinctUntilChanged((a, b) => a.outgoing?.transactionId === b.outgoing?.transactionId),
     tap$1((next) => state.set("transitionAppliedTransactionsToOutgoing", next)),
-    map((s) => s.outgoing),
+    map$1((s) => s.outgoing),
     distinctUntilChanged(),
-    withLatestFrom(getClientState(instance, { apiVersion: API_VERSION$3 }).observable),
-    concatMap(([outgoing, client]) => outgoing ? client.observable.action(outgoing.outgoingActions, {
-      transactionId: outgoing.transactionId,
-      skipCrossDatasetReferenceValidation: !0
-    }).pipe(
-      catchError$1((error) => (state.set("revertOutgoingTransaction", revertOutgoingTransaction), events.next({ type: "reverted", message: error.message, outgoing, error }), EMPTY)),
-      map((result) => ({ result, outgoing }))
-    ) : EMPTY),
+    withLatestFrom(
+      getClientState(instance, {
+        apiVersion: API_VERSION$2,
+        // TODO: remove in v3 when we're ready for everything to be queried via resource
+        resource: resource && !isDatasetResource(resource) ? resource : void 0
+      }).observable
+    ),
+    concatMap(([outgoing, client]) => {
+      if (!outgoing) return EMPTY;
+      const revertOnError = catchError$1((error) => {
+        state.set("revertOutgoingTransaction", revertOutgoingTransaction);
+        const message = error instanceof Error ? error.message : "Request failed";
+        return events.next({ type: "reverted", message, outgoing, error }), EMPTY;
+      }), toResult = map$1((result) => ({
+        result,
+        outgoing
+      }));
+      return outgoing.actions.some((action) => action.liveEdit) ? client.observable.mutate(outgoing.outgoingMutations, {
+        transactionId: outgoing.transactionId,
+        visibility: "async",
+        returnDocuments: !1,
+        returnFirst: !1,
+        tag: "document.mutate",
+        skipCrossDatasetReferenceValidation: !0
+      }).pipe(revertOnError, toResult) : client.observable.action(outgoing.outgoingActions, {
+        transactionId: outgoing.transactionId,
+        skipCrossDatasetReferenceValidation: !0,
+        tag: "document.action"
+      }).pipe(revertOnError, toResult);
+    }),
     tap$1(({ outgoing, result }) => {
       state.set("cleanupOutgoingTransaction", cleanupOutgoingTransaction);
       for (const e of getDocumentEvents(outgoing)) events.next(e);
@@ -3130,8 +2222,8 @@ const _resolveDocument = bindActionByDataset(
 }, subscribeToSubscriptionsAndListenToDocuments = (context) => {
   const { state } = context, { events } = state.get();
   return state.observable.pipe(
-    filter((s) => !!s.grants),
-    map((s) => Object.keys(s.documentStates)),
+    filter$1((s) => !!s.grants),
+    map$1((s) => Object.keys(s.documentStates)),
     distinctUntilChanged((curr, next) => {
       if (curr.length !== next.length) return !1;
       const currSet = new Set(curr);
@@ -3144,7 +2236,7 @@ const _resolveDocument = bindActionByDataset(
         ...added.map((id) => ({ id, add: !0 })),
         ...removed.map((id) => ({ id, add: !1 }))
       ].sort((a, b) => {
-        const aIsDraft = a.id === getDraftId(a.id), bIsDraft = b.id === getDraftId(b.id);
+        const aIsDraft = a.id === getDraftId(DocumentId(a.id)), bIsDraft = b.id === getDraftId(DocumentId(b.id));
         return aIsDraft && bIsDraft ? a.id.localeCompare(b.id, "en-US") : aIsDraft ? -1 : bIsDraft ? 1 : a.id.localeCompare(b.id, "en-US");
       });
       return of(...changes);
@@ -3169,45 +2261,58 @@ const _resolveDocument = bindActionByDataset(
 }, subscribeToClientAndFetchDatasetAcl = ({
   instance,
   state,
-  key: { projectId, dataset }
-}) => getClientState(instance, { apiVersion: API_VERSION$3 }).observable.pipe(
-  switchMap(
-    (client) => client.observable.request({
-      uri: `/projects/${projectId}/datasets/${dataset}/acl`,
-      tag: "acl.get",
-      withCredentials: !0
-    })
-  ),
-  tap$1((datasetAcl) => state.set("setGrants", { grants: createGrantsLookup(datasetAcl) }))
-).subscribe({
-  error: (error) => state.set("setError", { error })
-});
+  key: { resource }
+}) => {
+  const clientOptions = { apiVersion: API_VERSION$2 };
+  resource && !isDatasetResource(resource) && (clientOptions.resource = resource);
+  let uri;
+  if (resource && isDatasetResource(resource))
+    uri = `/projects/${resource.projectId}/datasets/${resource.dataset}/acl`;
+  else if (resource && isMediaLibraryResource(resource))
+    uri = `/media-libraries/${resource.mediaLibraryId}/acl`;
+  else if (resource && isCanvasResource(resource))
+    uri = `/canvases/${resource.canvasId}/acl`;
+  else
+    throw new Error(`Received invalid resource: ${JSON.stringify(resource)}`);
+  return getClientState(instance, clientOptions).observable.pipe(
+    switchMap(
+      (client) => client.observable.request({
+        uri,
+        tag: "acl.get",
+        withCredentials: !0
+      })
+    ),
+    tap$1((datasetAcl) => state.set("setGrants", { grants: createGrantsLookup(datasetAcl) }))
+  ).subscribe({
+    error: (error) => state.set("setError", { error })
+  });
+};
 function applyDocumentActions(...args) {
   return boundApplyDocumentActions(...args);
 }
-const boundApplyDocumentActions = bindActionByDataset(documentStore, _applyDocumentActions);
+const boundApplyDocumentActions = bindActionByResource(documentStore, _applyDocumentActions);
 async function _applyDocumentActions({ state }, { actions, transactionId = crypto.randomUUID(), disableBatching }) {
   const { events } = state.get(), transaction = {
     transactionId,
     actions,
     ...disableBatching && { disableBatching }
   }, fatalError$ = state.observable.pipe(
-    map((s) => s.error),
+    map$1((s) => s.error),
     first$1(Boolean),
-    map((error) => ({ type: "error", error }))
+    map$1((error) => ({ type: "error", error }))
   ), transactionError$ = events.pipe(
-    filter((e) => e.type === "error"),
+    filter$1((e) => e.type === "error"),
     first$1((e) => e.transactionId === transactionId)
   ), appliedTransaction$ = state.observable.pipe(
-    map((s) => s.applied),
+    map$1((s) => s.applied),
     distinctUntilChanged(),
-    map((applied) => applied.find((t) => t.transactionId === transactionId)),
+    map$1((applied) => applied.find((t) => t.transactionId === transactionId)),
     first$1(Boolean)
   ), successfulTransaction$ = events.pipe(
-    filter((e) => e.type === "accepted"),
+    filter$1((e) => e.type === "accepted"),
     first$1((e) => e.outgoing.batchedTransactionIds.includes(transactionId))
   ), rejectedTransaction$ = events.pipe(
-    filter((e) => e.type === "reverted"),
+    filter$1((e) => e.type === "reverted"),
     first$1((e) => e.outgoing.batchedTransactionIds.includes(transactionId))
   ), appliedTransactionOrError = firstValueFrom(
     race([fatalError$, transactionError$, appliedTransaction$])
@@ -3262,7 +2367,7 @@ const favorites = createFetcherStore({
       }
     };
     return nodeStateSource.observable.pipe(
-      filter((nodeState) => !!nodeState),
+      filter$1((nodeState) => !!nodeState),
       // Only proceed when connected
       shareReplay(1),
       switchMap((nodeState) => {
@@ -3274,55 +2379,21 @@ const favorites = createFetcherStore({
             payload
           )
         ).pipe(
-          map((response) => ({ isFavorited: response.isFavorited })),
+          map$1((response) => ({ isFavorited: response.isFavorited })),
           catchError$1((err) => (console.error("Favorites service connection error", err), of({ isFavorited: !1 })))
         );
       })
     );
   }
-}), getFavoritesState = favorites.getState, resolveFavoritesState = favorites.resolveState, API_VERSION$1 = "vX", PROJECT_API_VERSION = "2025-07-18", USERS_STATE_CLEAR_DELAY = 5e3, DEFAULT_USERS_BATCH_SIZE = 100, getUsersKey = (instance, {
-  resourceType,
-  organizationId,
-  batchSize = DEFAULT_USERS_BATCH_SIZE,
-  projectId = instance.config.projectId,
-  userId
-} = {}) => JSON.stringify({
-  resourceType,
-  organizationId,
-  batchSize,
-  projectId,
-  userId
-}), parseUsersKey = (key) => JSON.parse(key), addSubscription = (subscriptionId, key) => (prev) => {
-  const group = prev.users[key], subscriptions = [...group?.subscriptions ?? [], subscriptionId];
-  return { ...prev, users: { ...prev.users, [key]: { ...group, subscriptions } } };
-}, removeSubscription = (subscriptionId, key) => (prev) => {
-  const group = prev.users[key];
-  if (!group) return prev;
-  const subscriptions = group.subscriptions.filter((id) => id !== subscriptionId);
-  return subscriptions.length ? { ...prev, users: { ...prev.users, [key]: { ...group, subscriptions } } } : { ...prev, users: omit(prev.users, key) };
-}, setUsersData = (key, { data, nextCursor, totalCount }) => (prev) => {
-  const group = prev.users[key];
-  if (!group) return prev;
-  const users = [...group.users ?? [], ...data];
-  return { ...prev, users: { ...prev.users, [key]: { ...group, users, totalCount, nextCursor } } };
-}, updateLastLoadMoreRequest = (timestamp, key) => (prev) => {
-  const group = prev.users[key];
-  return group ? { ...prev, users: { ...prev.users, [key]: { ...group, lastLoadMoreRequest: timestamp } } } : prev;
-}, setUsersError = (key, error) => (prev) => {
-  const group = prev.users[key];
-  return group ? { ...prev, users: { ...prev.users, [key]: { ...group, error } } } : prev;
-}, cancelRequest = (key) => (prev) => {
-  const group = prev.users[key];
-  return !group || group.subscriptions.length ? prev : { ...prev, users: omit(prev.users, key) };
-}, initializeRequest = (key) => (prev) => prev.users[key] ? prev : { ...prev, users: { ...prev.users, [key]: { subscriptions: [] } } }, usersStore = {
+}), getFavoritesState = favorites.getState, resolveFavoritesState = favorites.resolveState, usersStore = defineStore({
   name: "UsersStore",
   getInitialState: () => ({ users: {} }),
   initialize: (context) => {
     const subscription = listenForLoadMoreAndFetch(context);
     return () => subscription.unsubscribe();
   }
-}, errorHandler$1 = (state) => (error) => state.set("setError", { error }), listenForLoadMoreAndFetch = ({ state, instance }) => state.observable.pipe(
-  map((s) => new Set(Object.keys(s.users))),
+}), errorHandler = (state) => (error) => state.set("setError", { error }), listenForLoadMoreAndFetch = ({ state, instance }) => state.observable.pipe(
+  map$1((s) => new Set(Object.keys(s.users))),
   distinctUntilChanged((curr, next) => curr.size !== next.size ? !1 : Array.from(next).every((i) => curr.has(i))),
   startWith$1(/* @__PURE__ */ new Set()),
   pairwise$1(),
@@ -3349,9 +2420,10 @@ const favorites = createFetcherStore({
               useProjectHostname: !0
             }).observable.request({
               method: "GET",
-              uri: `/users/${userId}`
+              uri: `/users/${userId}`,
+              tag: "users.get"
             }).pipe(
-              map((user) => ({
+              map$1((user) => ({
                 data: [{
                   sanityUserId: user.sanityUserId,
                   profile: {
@@ -3379,13 +2451,14 @@ const favorites = createFetcherStore({
             );
           const scope = userId.startsWith("g") ? "global" : void 0, client = getClient(instance, {
             scope,
-            apiVersion: API_VERSION$1
+            apiVersion: API_VERSION$6
           }), resourceType2 = options.resourceType || "project", resourceId = resourceType2 === "organization" ? options.organizationId : options.projectId;
           return resourceId ? client.observable.request({
             method: "GET",
-            uri: `access/${resourceType2}/${resourceId}/users/${userId}`
+            uri: `access/${resourceType2}/${resourceId}/users/${userId}`,
+            tag: "users.get"
           }).pipe(
-            map((response) => "sanityUserId" in response ? {
+            map$1((response) => "sanityUserId" in response ? {
               data: [response],
               totalCount: 1,
               nextCursor: null
@@ -3395,17 +2468,17 @@ const favorites = createFetcherStore({
           ) : throwError(() => new Error("An organizationId or a projectId is required"));
         }
         const projectId = options.projectId, resourceType = options.resourceType ?? (options.organizationId ? "organization" : projectId ? "project" : "organization"), organizationId$ = options.organizationId ? of(options.organizationId) : getDashboardOrganizationId$1(instance).observable.pipe(
-          filter((i) => typeof i == "string")
-        ), resource$ = resourceType === "project" ? projectId ? of({ type: "project", id: projectId }) : throwError(() => new Error("Project ID required for this API.")) : organizationId$.pipe(map((id) => ({ type: "organization", id }))), client$ = getClientState(instance, {
+          filter$1((i) => typeof i == "string")
+        ), resource$ = resourceType === "project" ? projectId ? of({ type: "project", id: projectId }) : throwError(() => new Error("Project ID required for this API.")) : organizationId$.pipe(map$1((id) => ({ type: "organization", id }))), client$ = getClientState(instance, {
           scope: "global",
-          apiVersion: API_VERSION$1
+          apiVersion: API_VERSION$6
         }).observable, loadMore$ = state.observable.pipe(
-          map((s) => s.users[group$.key]?.lastLoadMoreRequest),
+          map$1((s) => s.users[group$.key]?.lastLoadMoreRequest),
           distinctUntilChanged()
         ), cursor$ = state.observable.pipe(
-          map((s) => s.users[group$.key]?.nextCursor),
+          map$1((s) => s.users[group$.key]?.nextCursor),
           distinctUntilChanged(),
-          filter((cursor) => cursor !== null)
+          filter$1((cursor) => cursor !== null)
         );
         return combineLatest([resource$, client$, loadMore$]).pipe(
           withLatestFrom(cursor$),
@@ -3413,6 +2486,7 @@ const favorites = createFetcherStore({
             ([[resource, client], cursor]) => client.observable.request({
               method: "GET",
               uri: `access/${resource.type}/${resource.id}/users`,
+              tag: "users.list",
               query: cursor ? { nextCursor: cursor, limit: batchSize.toString() } : { limit: batchSize.toString() }
             })
           ),
@@ -3422,7 +2496,7 @@ const favorites = createFetcherStore({
       })
     )
   )
-).subscribe({ error: errorHandler$1(state) }), getUsersState = bindActionGlobally(
+).subscribe({ error: errorHandler(state) }), getUsersState = bindActionGlobally(
   usersStore,
   createStateSourceAction({
     selector: createSelector(
@@ -3441,7 +2515,7 @@ const favorites = createFetcherStore({
     onSubscribe: ({ instance, state }, options) => {
       const subscriptionId = insecureRandomId(), key = getUsersKey(instance, options);
       return state.set("addSubscription", addSubscription(subscriptionId, key)), () => {
-        setTimeout(
+        setCleanupTimeout(
           () => state.set("removeSubscription", removeSubscription(subscriptionId, key)),
           USERS_STATE_CLEAR_DELAY
         );
@@ -3465,7 +2539,7 @@ const favorites = createFetcherStore({
     ) : NEVER;
     state.set("initializeRequest", initializeRequest(key));
     const resolved$ = state.observable.pipe(
-      map(getCurrent),
+      map$1(getCurrent),
       first$1((i) => i !== void 0)
     );
     return firstValueFrom(race([resolved$, aborted$]));
@@ -3480,7 +2554,7 @@ const favorites = createFetcherStore({
       throw new Error("No more users available to load for this resource.");
     const promise = firstValueFrom(
       users.observable.pipe(
-        filter((i) => i !== void 0),
+        filter$1((i) => i !== void 0),
         skip(1)
       )
     ), timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -3489,7 +2563,7 @@ const favorites = createFetcherStore({
 ), getUserState = bindActionGlobally(
   usersStore,
   ({ instance }, { userId, ...options }) => getUsersState(instance, { userId, ...options }).observable.pipe(
-    map((res) => res?.data[0]),
+    map$1((res) => res?.data[0]),
     distinctUntilChanged((a, b) => a?.profile.updatedAt === b?.profile.updatedAt)
   )
 ), resolveUser = bindActionGlobally(
@@ -3500,7 +2574,20 @@ const favorites = createFetcherStore({
   }))?.data[0]
 );
 function getBifurClient(client, token$) {
-  const bifurVersionedClient = client.withConfig({ apiVersion: "2022-06-30" }), { dataset, url: baseUrl, requestTagPrefix = "sanity.studio" } = bifurVersionedClient.config(), urlWithTag = `${`${baseUrl.replace(/\/+$/, "")}/socket/${dataset}`.replace(/^http/, "ws")}?tag=${requestTagPrefix}`;
+  const bifurVersionedClient = client.withConfig({ apiVersion: "2022-06-30" }), {
+    resource,
+    dataset,
+    url: baseUrl,
+    requestTagPrefix = "sanity.sdk.presence"
+  } = bifurVersionedClient.config();
+  let resourcePath;
+  if (resource?.type === "canvas")
+    resourcePath = `canvases/${resource.id}`;
+  else if (dataset)
+    resourcePath = dataset;
+  else
+    throw new Error("Unable to determine presence URL: no canvas resource or dataset configured");
+  const urlWithTag = `${`${baseUrl}/socket/${resourcePath}`.replace(/^http/, "ws")}?tag=${requestTagPrefix}`;
   return fromUrl(urlWithTag, { token$ });
 }
 const handleIncomingMessage = (event) => {
@@ -3532,7 +2619,7 @@ const handleIncomingMessage = (event) => {
       throw new Error(`Got unknown presence event: ${JSON.stringify(event)}`);
   }
 }, createBifurTransport = (options) => {
-  const { client, token$, sessionId } = options, bifur = getBifurClient(client, token$), incomingEvents$ = bifur.listen("presence").pipe(map$1(handleIncomingMessage)), dispatchMessage = (message) => {
+  const { client, token$, sessionId } = options, bifur = getBifurClient(client, token$), incomingEvents$ = bifur.listen("presence").pipe(map(handleIncomingMessage)), dispatchMessage = (message) => {
     switch (message.type) {
       case "rollCall":
         return bifur.request("presence_rollcall", { session: sessionId });
@@ -3547,27 +2634,34 @@ const handleIncomingMessage = (event) => {
     }
   };
   return typeof window < "u" && fromEvent(window, "beforeunload").pipe(switchMap$1(() => dispatchMessage({ type: "disconnect" }))).subscribe(), [incomingEvents$.pipe(share$1()), dispatchMessage];
-}, getInitialState = () => ({
+}, PRESENCE_API_VERSION = "2026-03-30", getInitialState = () => ({
   locations: /* @__PURE__ */ new Map(),
   users: {}
-}), presenceStore = {
+}), presenceStore = defineStore({
   name: "presence",
   getInitialState,
   initialize: (context) => {
     const {
       instance,
       state,
-      key: { projectId, dataset }
-    } = context, sessionId = crypto.randomUUID(), client = getClient(instance, {
-      apiVersion: "2022-06-30",
-      projectId,
-      dataset
+      key: { resource }
+    } = context;
+    if (isMediaLibraryResource(resource))
+      throw new Error("Presence is not supported for media library resources.");
+    const sessionId = crypto.randomUUID(), client = isDatasetResource(resource) ? getClient(instance, {
+      apiVersion: PRESENCE_API_VERSION,
+      projectId: resource.projectId,
+      dataset: resource.dataset,
+      useProjectHostname: !0
+    }) : getClient(instance, {
+      apiVersion: PRESENCE_API_VERSION,
+      resource
     }), token$ = getTokenState(instance).observable.pipe(distinctUntilChanged()), [incomingEvents$, dispatch] = createBifurTransport({
       client,
       token$,
       sessionId
     }), subscription = new Subscription();
-    return subscription.add(
+    if (subscription.add(
       incomingEvents$.subscribe((event) => {
         "sessionId" in event && event.sessionId === sessionId || (event.type === "state" ? state.set("presence/state", (prevState) => {
           const newLocations = new Map(prevState.locations);
@@ -3583,11 +2677,22 @@ const handleIncomingMessage = (event) => {
           return newLocations.delete(event.sessionId), { ...prevState, locations: newLocations };
         }));
       })
-    ), dispatch({ type: "rollCall" }).subscribe(), () => {
+    ), dispatch({ type: "rollCall" }).subscribe(), isCanvasResource(resource)) {
+      const globalClient = getClient(instance, { apiVersion: PRESENCE_API_VERSION });
+      subscription.add(
+        globalClient.observable.request({
+          uri: `/canvases/${resource.canvasId}`,
+          tag: "canvases.get"
+        }).pipe(catchError$1(() => EMPTY)).subscribe(({ organizationId }) => {
+          state.set("presence/organizationId", (prev) => ({ ...prev, organizationId }));
+        })
+      );
+    }
+    return () => {
       dispatch({ type: "disconnect" }).subscribe(), subscription.unsubscribe();
     };
   }
-}, selectLocations = (state) => state.locations, selectUsers = (state) => state.users, selectPresence = createSelector(
+}), selectLocations = (state) => state.locations, selectUsers = (state) => state.users, selectPresence = createSelector(
   selectLocations,
   selectUsers,
   (locations, users) => Array.from(locations.entries()).map(([sessionId, { userId, locations: locs }]) => ({
@@ -3600,31 +2705,34 @@ const handleIncomingMessage = (event) => {
     sessionId,
     locations: locs
   }))
-), getPresence = bindActionByDataset(
+), _getPresence = bindActionByResource(
   presenceStore,
   createStateSourceAction({
-    selector: (context, _) => selectPresence(context.state),
-    onSubscribe: (context, _) => {
-      const subscription = context.state.observable.pipe(
-        map(
+    selector: (context) => selectPresence(context.state),
+    onSubscribe: (context) => {
+      const resource = context.key.resource, userIds$ = context.state.observable.pipe(
+        map$1(
           (state) => Array.from(state.locations.values()).map((l) => l.userId).filter((id) => !!id)
         ),
         distinctUntilChanged((a, b) => a.length === b.length && a.every((v, i) => v === b[i]))
-      ).pipe(
-        switchMap((userIds) => {
+      ), organizationId$ = isCanvasResource(resource) ? context.state.observable.pipe(
+        map$1((s) => s.organizationId),
+        filter$1((id) => id !== void 0),
+        first$1()
+      ) : of(void 0), subscription = combineLatest([userIds$, organizationId$]).pipe(
+        switchMap(([userIds, organizationId]) => {
           if (userIds.length === 0)
             return of([]);
           const userObservables = userIds.map(
             (userId) => getUserState(context.instance, {
               userId,
-              resourceType: "project",
-              projectId: context.key.projectId
-            }).pipe(filter((v) => !!v))
+              ...isDatasetResource(resource) ? { resourceType: "project", projectId: resource.projectId } : { resourceType: "organization", organizationId }
+            }).pipe(filter$1((v) => !!v))
           );
           return combineLatest(userObservables);
         })
       ).subscribe((users) => {
-        users && context.state.set("presence/users", (prevState) => ({
+        context.state.set("presence/users", (prevState) => ({
           ...prevState,
           users: {
             ...prevState.users,
@@ -3636,489 +2744,16 @@ const handleIncomingMessage = (event) => {
     }
   })
 );
-function sortReleases(releases = []) {
-  return [...releases].sort((a, b) => {
-    if (a.metadata.releaseType === "undecided" && b.metadata.releaseType !== "undecided")
-      return -1;
-    if (a.metadata.releaseType !== "undecided" && b.metadata.releaseType === "undecided")
-      return 1;
-    if (a.metadata.releaseType === "undecided" && b.metadata.releaseType === "undecided")
-      return new Date(b._createdAt).getTime() - new Date(a._createdAt).getTime();
-    if (a.metadata.releaseType === "scheduled" && b.metadata.releaseType === "scheduled") {
-      const aPublishAt = a.publishAt || a.metadata.intendedPublishAt;
-      if (!aPublishAt)
-        return 1;
-      const bPublishAt = b.publishAt || b.metadata.intendedPublishAt;
-      return bPublishAt ? new Date(bPublishAt).getTime() - new Date(aPublishAt).getTime() : -1;
-    }
-    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;
-  });
+function getPresence(instance, params) {
+  return _getPresence(instance, params ?? {});
 }
-const ARCHIVED_RELEASE_STATES = ["archived", "published"], STABLE_EMPTY_RELEASES = [], releasesStore = {
-  name: "Releases",
-  getInitialState: () => ({
-    activeReleases: void 0
-  }),
-  initialize: (context) => {
-    const subscription = subscribeToReleases(context);
-    return () => subscription.unsubscribe();
-  }
-}, getActiveReleasesState = bindActionByDataset(
-  releasesStore,
-  createStateSourceAction({
-    selector: ({ state }, _) => state.activeReleases
-  })
-), RELEASES_QUERY = "releases::all()", subscribeToReleases = ({
-  instance,
-  state,
-  key: { projectId, dataset }
-}) => {
-  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;
-    const releaseIds = activeReleases.map((release) => release._id).join(",");
-    let nestedCache = optionsCache.get(releaseIds);
-    nestedCache || (nestedCache = /* @__PURE__ */ new Map(), optionsCache.set(releaseIds, nestedCache));
-    const optionsKey = JSON.stringify(options);
-    let cachedOptions = nestedCache.get(optionsKey);
-    return cachedOptions || (cachedOptions = options, nestedCache.set(optionsKey, cachedOptions)), cachedOptions;
-  }
-), _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,
-  _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) => {
-  const prevQuery = prev.queries[key];
-  return prevQuery ? {
-    ...prev,
-    queries: { ...prev.queries, [key]: { ...prevQuery, result: result ?? null, syncTags } }
-  } : prev;
-}, setLastLiveEventId = (key, lastLiveEventId) => (prev) => {
-  const prevQuery = prev.queries[key];
-  return prevQuery ? { ...prev, queries: { ...prev.queries, [key]: { ...prevQuery, lastLiveEventId } } } : prev;
-}, addSubscriber = (key, subscriptionId) => (prev) => {
-  const prevQuery = prev.queries[key], subscribers = [...prevQuery?.subscribers ?? [], subscriptionId];
-  return { ...prev, queries: { ...prev.queries, [key]: { ...prevQuery, subscribers } } };
-}, removeSubscriber = (key, subscriptionId) => (prev) => {
-  const prevQuery = prev.queries[key];
-  if (!prevQuery) return prev;
-  const subscribers = prevQuery.subscribers.filter((id) => id !== subscriptionId);
-  return subscribers.length ? { ...prev, queries: { ...prev.queries, [key]: { ...prevQuery, subscribers } } } : { ...prev, queries: omit(prev.queries, key) };
-}, cancelQuery = (key) => (prev) => {
-  const prevQuery = prev.queries[key];
-  return !prevQuery || prevQuery.subscribers.length ? prev : { ...prev, queries: omit(prev.queries, key) };
-}, initializeQuery = (key) => (prev) => prev.queries[key] ? prev : { ...prev, queries: { ...prev.queries, [key]: { subscribers: [] } } }, EMPTY_ARRAY = [], getQueryKey = (options) => JSON.stringify(options), parseQueryKey = (key) => JSON.parse(key);
-function normalizeOptionsWithPerspective(instance, options) {
-  if (options.perspective !== void 0) return options;
-  const instancePerspective = instance.config.perspective;
-  return {
-    ...options,
-    perspective: instancePerspective !== void 0 ? instancePerspective : QUERY_STORE_DEFAULT_PERSPECTIVE
-  };
-}
-const queryStore = {
-  name: "QueryStore",
-  getInitialState: () => ({ queries: {} }),
-  initialize(context) {
-    const subscriptions = [
-      listenForNewSubscribersAndFetch(context),
-      listenToLiveClientAndSetLastLiveEventIds(context)
-    ];
-    return () => {
-      for (const subscription of subscriptions)
-        subscription.unsubscribe();
-    };
-  }
-}, errorHandler = (state) => (error) => state.set("setError", { error }), listenForNewSubscribersAndFetch = ({ state, instance }) => state.observable.pipe(
-  map((s) => new Set(Object.keys(s.queries))),
-  distinctUntilChanged((curr, next) => curr.size !== next.size ? !1 : Array.from(next).every((i) => curr.has(i))),
-  startWith$1(/* @__PURE__ */ new Set()),
-  pairwise$1(),
-  mergeMap$1(([curr, next]) => {
-    const added = Array.from(next).filter((i) => !curr.has(i)), removed = Array.from(curr).filter((i) => !next.has(i));
-    return [
-      ...added.map((key) => ({ key, added: !0 })),
-      ...removed.map((key) => ({ key, added: !1 }))
-    ];
-  }),
-  groupBy$1((i) => i.key),
-  mergeMap$1(
-    (group$) => group$.pipe(
-      switchMap((e) => {
-        if (!e.added) return EMPTY;
-        const lastLiveEventId$ = state.observable.pipe(
-          map((s) => s.queries[group$.key]?.lastLiveEventId),
-          distinctUntilChanged()
-        ), {
-          query,
-          params,
-          projectId,
-          dataset,
-          tag,
-          source,
-          perspective: perspectiveFromOptions,
-          ...restOptions
-        } = parseQueryKey(group$.key), perspective$ = isReleasePerspective(perspectiveFromOptions) ? getPerspectiveState(instance, {
-          perspective: perspectiveFromOptions
-        }).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: lastLiveEventId$,
-          client: client$,
-          perspective: perspective$
-        }).pipe(
-          switchMap(
-            ({ lastLiveEventId, client, perspective }) => client.observable.fetch(query, params, {
-              ...restOptions,
-              perspective,
-              filterResponse: !1,
-              returnQuery: !1,
-              lastLiveEventId,
-              tag
-            })
-          )
-        );
-      }),
-      catchError$1((error) => (state.set("setQueryError", setQueryError(group$.key, error)), EMPTY)),
-      tap$1(({ result, syncTags }) => {
-        state.set("setQueryData", setQueryData(group$.key, result, syncTags));
-      })
-    )
-  )
-).subscribe({ error: errorHandler(state) }), listenToLiveClientAndSetLastLiveEventIds = ({
-  state,
-  instance,
-  key: { source }
-}) => {
-  const liveMessages$ = getClientState(instance, {
-    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(
-        () => client.live.events({ includeDrafts: !!client.config().token, tag: "query-store" })
-      ).pipe(
-        catchError$1((error) => {
-          if (error instanceof CorsOriginError)
-            return state.set("setError", { error }), EMPTY;
-          throw error;
-        })
-      )
-    ),
-    share(),
-    filter((e) => e.type === "message")
-  );
-  return state.observable.pipe(
-    mergeMap$1((s) => Object.entries(s.queries)),
-    groupBy$1(([key]) => key),
-    mergeMap$1((group$) => {
-      const syncTags$ = group$.pipe(
-        map(([, queryState]) => queryState),
-        map((i) => i?.syncTags ?? EMPTY_ARRAY),
-        distinctUntilChanged()
-      );
-      return combineLatest([liveMessages$, syncTags$]).pipe(
-        filter(([message, syncTags]) => message.tags.some((tag) => syncTags.includes(tag))),
-        tap$1(([message]) => {
-          state.set("setLastLiveEventId", setLastLiveEventId(group$.key, message.id));
-        })
-      );
-    })
-  ).subscribe({ error: errorHandler(state) });
-};
-function getQueryState(...args) {
-  return _getQueryState(...args);
-}
-const _getQueryState = bindActionBySource(
-  queryStore,
-  createStateSourceAction({
-    selector: ({ state, instance }, options) => {
-      if (state.error) throw state.error;
-      const key = getQueryKey(normalizeOptionsWithPerspective(instance, options)), queryState = state.queries[key];
-      if (queryState?.error) throw queryState.error;
-      return queryState?.result;
-    },
-    onSubscribe: ({ state, instance }, options) => {
-      const subscriptionId = insecureRandomId(), key = getQueryKey(normalizeOptionsWithPerspective(instance, options));
-      return state.set("addSubscriber", addSubscriber(key, subscriptionId)), () => {
-        setTimeout(
-          () => state.set("removeSubscriber", removeSubscriber(key, subscriptionId)),
-          QUERY_STATE_CLEAR_DELAY
-        );
-      };
-    }
-  })
-);
-function resolveQuery(...args) {
-  return _resolveQuery(...args);
-}
-const _resolveQuery = bindActionBySource(
-  queryStore,
-  ({ state, instance }, { signal, ...options }) => {
-    const normalized = normalizeOptionsWithPerspective(instance, options), { getCurrent } = getQueryState(instance, normalized), key = getQueryKey(normalized), aborted$ = signal ? new Observable((observer) => {
-      const cleanup = () => {
-        signal.removeEventListener("abort", listener);
-      }, listener = () => {
-        observer.error(new DOMException("The operation was aborted.", "AbortError")), observer.complete(), cleanup();
-      };
-      return signal.addEventListener("abort", listener), cleanup;
-    }).pipe(
-      catchError$1((error) => {
-        throw error instanceof Error && error.name === "AbortError" && state.set("cancelQuery", cancelQuery(key)), error;
-      })
-    ) : NEVER;
-    state.set("initializeQuery", initializeQuery(key));
-    const resolved$ = state.observable.pipe(
-      map(getCurrent),
-      first$1((i) => i !== void 0)
-    );
-    return firstValueFrom(race([resolved$, aborted$]));
-  }
-);
 function hashString(str) {
   let hash = 0;
   for (let i = 0; i < str.length; i++)
     hash = (hash * 31 + str.charCodeAt(i)) % 2147483647;
   return Math.abs(hash).toString(16).padStart(8, "0");
 }
-const TITLE_CANDIDATES = ["title", "name", "label", "heading", "header", "caption"], SUBTITLE_CANDIDATES = ["description", "subtitle", ...TITLE_CANDIDATES], PREVIEW_PROJECTION = `{
-  // Get all potential title fields
-  "titleCandidates": {
-    ${TITLE_CANDIDATES.map((field) => `"${field}": ${field}`).join(`,
-      `)}
-  },
-  // Get all potential subtitle fields
-  "subtitleCandidates": {
-    ${SUBTITLE_CANDIDATES.map((field) => `"${field}": ${field}`).join(`,
-      `)}
-  },
-  "media": coalesce(
-    select(
-      defined(asset) => {"type": "image-asset", "_ref": asset._ref},
-      defined(image.asset) => {"type": "image-asset", "_ref": image.asset._ref},
-      defined(mainImage.asset) => {"type": "image-asset", "_ref": mainImage.asset._ref},
-      null
-    )
-  ),
-  _type,
-  _id,
-  _updatedAt
-}`, PREVIEW_TAG = "preview", PREVIEW_PERSPECTIVE = "raw", STABLE_EMPTY_PREVIEW = { data: null, isPending: !1 }, STABLE_ERROR_PREVIEW = {
-  data: {
-    title: "Preview Error",
-    ...!!getEnv("DEV") && { subtitle: "Check the console for more details" }
-  },
-  isPending: !1
-};
-function assetIdToUrl(assetId, projectId, dataset) {
-  const pattern = /^image-(?<assetName>[A-Za-z0-9]+)-(?<dimensions>\d+x\d+)-(?<format>[a-z]+)$/, match = assetId.match(pattern);
-  if (!match?.groups)
-    throw new Error(
-      `Invalid asset ID \`${assetId}\`. Expected: image-{assetName}-{width}x{height}-{format}`
-    );
-  const { assetName, dimensions, format } = match.groups;
-  return `https://cdn.sanity.io/images/${projectId}/${dataset}/${assetName}-${dimensions}.${format}`;
-}
-function hasImageRef(value) {
-  return isObject(value) && "_ref" in value && typeof value._ref == "string";
-}
-function normalizeMedia(media, projectId, dataset) {
-  return !media || !hasImageRef(media) ? null : {
-    type: "image-asset",
-    _ref: media._ref,
-    url: assetIdToUrl(media._ref, projectId, dataset)
-  };
-}
-function findFirstDefined(fieldsToSearch, candidates, exclude) {
-  if (candidates)
-    for (const field of fieldsToSearch) {
-      const value = candidates[field];
-      if (typeof value == "string" && value.trim() !== "" && value !== exclude)
-        return value;
-    }
-}
-function processPreviewQuery({
-  projectId,
-  dataset,
-  ids,
-  results
-}) {
-  const resultMap = results.reduce((acc, next) => (acc[next._id] = next, acc), {});
-  return Object.fromEntries(
-    Array.from(ids).map((id) => {
-      const publishedId = getPublishedId(id), draftId = getDraftId(id), draftResult = resultMap[draftId], publishedResult = resultMap[publishedId];
-      if (!draftResult && !publishedResult) return [id, STABLE_EMPTY_PREVIEW];
-      try {
-        const result = draftResult || publishedResult;
-        if (!result) return [id, STABLE_EMPTY_PREVIEW];
-        const title = findFirstDefined(TITLE_CANDIDATES, result.titleCandidates), subtitle = findFirstDefined(SUBTITLE_CANDIDATES, result.subtitleCandidates, title), preview = {
-          title: String(title || `${result._type}: ${result._id}`),
-          subtitle: subtitle || void 0,
-          media: normalizeMedia(result.media, projectId, dataset)
-        }, _status = {
-          ...draftResult?._updatedAt && { lastEditedDraftAt: draftResult._updatedAt },
-          ...publishedResult?._updatedAt && { lastEditedPublishedAt: publishedResult._updatedAt }
-        };
-        return [id, { data: { ...preview, _status }, isPending: !1 }];
-      } catch (e) {
-        return console.warn(e), [id, STABLE_ERROR_PREVIEW];
-      }
-    })
-  );
-}
-function createPreviewQuery(documentIds) {
-  const allIds = Array.from(documentIds).flatMap((id) => [getPublishedId(id), getDraftId(id)]), queryHash = hashString(PREVIEW_PROJECTION);
-  return {
-    query: `*[_id in $__ids_${queryHash}]${PREVIEW_PROJECTION}`,
-    params: {
-      [`__ids_${queryHash}`]: allIds
-    }
-  };
-}
-const BATCH_DEBOUNCE_TIME$1 = 50, isSetEqual$1 = (a, b) => a.size === b.size && Array.from(a).every((i) => b.has(i)), subscribeToStateAndFetchBatches$1 = ({
-  state,
-  instance,
-  key: { projectId, dataset }
-}) => state.observable.pipe(
-  map(({ subscriptions }) => new Set(Object.keys(subscriptions))),
-  distinctUntilChanged(isSetEqual$1),
-  debounceTime(BATCH_DEBOUNCE_TIME$1),
-  startWith$1(/* @__PURE__ */ new Set()),
-  pairwise$1(),
-  tap$1(([prevIds, currIds]) => {
-    const newIds = [...currIds].filter((element) => !prevIds.has(element));
-    state.set("updatingPending", (prev) => {
-      const pendingValues = newIds.reduce((acc, id) => {
-        const prevValue = prev.values[id], value = prevValue?.data ? prevValue.data : null;
-        return acc[id] = { data: value, isPending: !0 }, acc;
-      }, {});
-      return { values: { ...prev.values, ...pendingValues } };
-    });
-  }),
-  map(([, ids]) => ids),
-  distinctUntilChanged(isSetEqual$1)
-).pipe(
-  switchMap((ids) => {
-    if (!ids.size) return EMPTY;
-    const { query, params } = createPreviewQuery(ids), controller = new AbortController();
-    return new Observable((observer) => {
-      const { getCurrent, observable } = getQueryState(instance, {
-        query,
-        params,
-        tag: PREVIEW_TAG,
-        perspective: PREVIEW_PERSPECTIVE,
-        projectId,
-        dataset
-      }), subscription = defer(() => getCurrent() === void 0 ? from(
-        resolveQuery(instance, {
-          query,
-          params,
-          tag: PREVIEW_TAG,
-          perspective: PREVIEW_PERSPECTIVE,
-          signal: controller.signal,
-          projectId,
-          dataset
-        })
-      ).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 })));
-  }),
-  map(({ ids, data }) => ({
-    values: processPreviewQuery({
-      projectId,
-      dataset,
-      ids,
-      results: data
-    })
-  }))
-).subscribe({
-  next: ({ values }) => {
-    state.set("updateResult", (prev) => ({ values: { ...prev.values, ...values } }));
-  }
-}), previewStore = {
-  name: "Preview",
-  getInitialState() {
-    return {
-      subscriptions: {},
-      values: {}
-    };
-  },
-  initialize: (context) => {
-    const subscription = subscribeToStateAndFetchBatches$1(context);
-    return () => subscription.unsubscribe;
-  }
-};
-function getPreviewState(...args) {
-  return _getPreviewState(...args);
-}
-const _getPreviewState = bindActionByDataset(
-  previewStore,
-  createStateSourceAction({
-    selector: ({ state }, docHandle) => state.values[docHandle.documentId] ?? STABLE_EMPTY_PREVIEW,
-    onSubscribe: ({ state }, docHandle) => {
-      const subscriptionId = insecureRandomId(), documentId = getPublishedId(docHandle.documentId);
-      return state.set("addSubscription", (prev) => ({
-        subscriptions: {
-          ...prev.subscriptions,
-          [documentId]: {
-            ...prev.subscriptions[documentId],
-            [subscriptionId]: !0
-          }
-        }
-      })), () => {
-        state.set("removeSubscription", (prev) => {
-          const documentSubscriptions = omit(prev.subscriptions[documentId], subscriptionId), hasSubscribers = !!Object.keys(documentSubscriptions).length, prevValue = prev.values[documentId], previewValue = prevValue?.data ? prevValue.data : null;
-          return {
-            subscriptions: hasSubscribers ? { ...prev.subscriptions, [documentId]: documentSubscriptions } : omit(prev.subscriptions, documentId),
-            values: hasSubscribers ? prev.values : { ...prev.values, [documentId]: { data: previewValue, isPending: !1 } }
-          };
-        });
-      };
-    }
-  })
-), resolvePreview = bindActionByDataset(
-  previewStore,
-  ({ instance }, docHandle) => firstValueFrom(getPreviewState(instance, docHandle).observable.pipe(filter((i) => !!i.data)))
-), PROJECTION_TAG = "projection", PROJECTION_STATE_CLEAR_DELAY = 1e3, STABLE_EMPTY_PROJECTION = {
+const PROJECTION_TAG = "projection", PROJECTION_STATE_CLEAR_DELAY = 1e3, STABLE_EMPTY_PROJECTION = {
   data: null,
   isPending: !1
 };
@@ -4155,7 +2790,7 @@ function processProjectionQuery({
 }) {
   const groupedResults = {};
   for (const result of results) {
-    const originalId = getPublishedId(result._id), hash = result.__projectionHash;
+    const originalId = getPublishedId(DocumentId(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 = {};
@@ -4181,7 +2816,7 @@ function processProjectionQuery({
 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);
+    const publishedId = getPublishedId(DocumentId(id)), draftId = getDraftId(publishedId);
     ids.push(draftId, publishedId), releaseName && ids.push(getVersionId(publishedId, releaseName));
   }
   return ids;
@@ -4189,7 +2824,7 @@ function buildStatusQueryIds(documentIds, perspective) {
 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] ?? {};
+    const id = DocumentId(result._id), updatedAt = result._updatedAt, publishedId = getPublishedId(id), statusData = documentStatuses[publishedId] ?? {};
     isDraftId(id) ? statusData.lastEditedDraftAt = updatedAt : isVersionId(id) ? statusData.lastEditedVersionAt = updatedAt : isPublishedId(id) && (statusData.lastEditedPublishedAt = updatedAt), documentStatuses[publishedId] = statusData;
   }
   return documentStatuses;
@@ -4197,13 +2832,13 @@ function processStatusQueryResults(results) {
 const BATCH_DEBOUNCE_TIME = 50, isSetEqual = (a, b) => a.size === b.size && Array.from(a).every((i) => b.has(i)), subscribeToStateAndFetchBatches = ({
   state,
   instance,
-  key: { source, perspective }
+  key: { resource, perspective }
 }) => {
   const documentProjections$ = state.observable.pipe(
-    map((s) => s.documentProjections),
-    distinctUntilChanged(isEqual)
+    map$1((s) => s.documentProjections),
+    distinctUntilChanged(isDeepEqual)
   ), activeDocumentIds$ = state.observable.pipe(
-    map(({ subscriptions }) => new Set(Object.keys(subscriptions))),
+    map$1(({ subscriptions }) => new Set(Object.keys(subscriptions).map((id) => DocumentId(id)))),
     distinctUntilChanged(isSetEqual)
   ), pendingUpdateSubscription = activeDocumentIds$.pipe(
     debounceTime(BATCH_DEBOUNCE_TIME),
@@ -4231,7 +2866,7 @@ const BATCH_DEBOUNCE_TIME = 50, isSetEqual = (a, b) => a.size === b.size && Arra
     })
   ).subscribe(), queryExecutionSubscription = combineLatest([activeDocumentIds$, documentProjections$]).pipe(
     debounceTime(BATCH_DEBOUNCE_TIME),
-    distinctUntilChanged(isEqual)
+    distinctUntilChanged(isDeepEqual)
   ).pipe(
     switchMap(([ids, documentProjections]) => {
       if (!ids.size) return EMPTY;
@@ -4242,7 +2877,7 @@ const BATCH_DEBOUNCE_TIME = 50, isSetEqual = (a, b) => a.size === b.size && Arra
           tag: PROJECTION_TAG,
           perspective,
           // temporary guard here until we're ready for everything to be queried via global API
-          ...source && !isDatasetSource(source) ? { source } : {}
+          ...resource && !isDatasetResource(resource) ? { resource } : {}
         }), subscription = defer(() => getCurrent() === void 0 ? from(
           resolveQuery(instance, {
             query,
@@ -4251,9 +2886,9 @@ const BATCH_DEBOUNCE_TIME = 50, isSetEqual = (a, b) => a.size === b.size && Arra
             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 } : {}
+            ...resource && !isDatasetResource(resource) ? { resource } : {}
           })
-        ).pipe(switchMap(() => observable)) : observable).pipe(filter((result) => result !== void 0)).subscribe(observer);
+        ).pipe(switchMap(() => observable)) : observable).pipe(filter$1((result) => result !== void 0)).subscribe(observer);
         return () => {
           controller.signal.aborted || controller.abort(), subscription.unsubscribe();
         };
@@ -4264,7 +2899,7 @@ const BATCH_DEBOUNCE_TIME = 50, isSetEqual = (a, b) => a.size === b.size && Arra
           tag: PROJECTION_TAG,
           perspective: "raw",
           // temporary guard here until we're ready for everything to be queried via global API
-          ...source && !isDatasetSource(source) ? { source } : {}
+          ...resource && !isDatasetResource(resource) ? { resource } : {}
         }), subscription = defer(() => getCurrent() === void 0 ? from(
           resolveQuery(instance, {
             query: statusQuery,
@@ -4273,25 +2908,25 @@ const BATCH_DEBOUNCE_TIME = 50, isSetEqual = (a, b) => a.size === b.size && Arra
             signal: controller.signal,
             perspective: "raw",
             // temporary guard here until we're ready for everything to be queried via global API
-            ...source && !isDatasetSource(source) ? { source } : {}
+            ...resource && !isDatasetResource(resource) ? { resource } : {}
           })
-        ).pipe(switchMap(() => observable)) : observable).pipe(filter((result) => result !== void 0)).subscribe(observer);
+        ).pipe(switchMap(() => observable)) : observable).pipe(filter$1((result) => result !== void 0)).subscribe(observer);
         return () => {
           subscription.unsubscribe();
         };
       });
       return combineLatest([projectionQuery$, statusQuery$]).pipe(
-        filter(
+        filter$1(
           (pair) => pair[0] !== void 0 && pair[1] !== void 0
         ),
-        map(([projection, status]) => ({
+        map$1(([projection, status]) => ({
           data: projection,
           ids,
           statusResults: status
         }))
       );
     }),
-    map(({ ids, data, statusResults }) => {
+    map$1(({ ids, data, statusResults }) => {
       const documentStatuses = processStatusQueryResults(statusResults);
       state.set("updateStatuses", (prev) => ({
         documentStatuses: {
@@ -4325,7 +2960,7 @@ const BATCH_DEBOUNCE_TIME = 50, isSetEqual = (a, b) => a.size === b.size && Arra
   return new Subscription(() => {
     pendingUpdateSubscription.unsubscribe(), queryExecutionSubscription.unsubscribe();
   });
-}, projectionStore = {
+}, projectionStore = defineStore({
   name: "Projection",
   getInitialState() {
     return {
@@ -4339,19 +2974,19 @@ const BATCH_DEBOUNCE_TIME = 50, isSetEqual = (a, b) => a.size === b.size && Arra
     const batchSubscription = subscribeToStateAndFetchBatches(context);
     return () => batchSubscription.unsubscribe();
   }
-};
+});
 function getProjectionState(...args) {
   return _getProjectionState(...args);
 }
-const _getProjectionState = bindActionBySourceAndPerspective(
+const _getProjectionState = bindActionByResourceAndPerspective(
   projectionStore,
   createStateSourceAction({
     selector: ({ state }, options) => {
-      const documentId = getPublishedId$2(DocumentId(options.documentId)), projectionHash = hashString(options.projection);
+      const documentId = getPublishedId(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$2(DocumentId(docHandle.documentId)), validProjection = validateProjection(projection), projectionHash = hashString(validProjection);
+      const { projection, ...docHandle } = options, subscriptionId = insecureRandomId(), documentId = getPublishedId(DocumentId(docHandle.documentId)), validProjection = validateProjection(projection), projectionHash = hashString(validProjection);
       return state.set("addSubscription", (prev) => ({
         documentProjections: {
           ...prev.documentProjections,
@@ -4371,9 +3006,9 @@ const _getProjectionState = bindActionBySourceAndPerspective(
           }
         }
       })), () => {
-        setTimeout(() => {
+        setCleanupTimeout(() => {
           state.set("removeSubscription", (prev) => {
-            const documentSubscriptionsForHash = omit(
+            const documentSubscriptionsForHash = omitProperty(
               prev.subscriptions[documentId]?.[projectionHash],
               subscriptionId
             ), hasSubscribersForProjection = !!Object.keys(documentSubscriptionsForHash).length, nextSubscriptions = { ...prev.subscriptions }, nextDocumentProjections = { ...prev.documentProjections }, nextValues = { ...prev.values };
@@ -4400,17 +3035,46 @@ const _getProjectionState = bindActionBySourceAndPerspective(
     }
   })
 );
+function getPreviewState(instance, options) {
+  const projectionState = getProjectionState(instance, {
+    ...options,
+    projection: PREVIEW_PROJECTION
+  }), transformResult = (current) => !current || current.data === null ? { data: null, isPending: current?.isPending ?? !1 } : {
+    data: transformProjectionToPreview(instance, current.data, options.resource),
+    isPending: current.isPending
+  };
+  return {
+    getCurrent: () => transformResult(projectionState.getCurrent()),
+    subscribe: (callback) => projectionState.subscribe(callback),
+    observable: projectionState.observable.pipe(map$1(transformResult))
+  };
+}
 function resolveProjection(...args) {
   return _resolveProjection(...args);
 }
-const _resolveProjection = bindActionBySourceAndPerspective(
+const _resolveProjection = bindActionByResourceAndPerspective(
   projectionStore,
   ({ instance }, options) => firstValueFrom(
     getProjectionState(instance, options).observable.pipe(
-      filter((state) => !!state?.data)
+      filter$1((state) => !!state?.data)
     )
   )
-), API_VERSION = "v2025-02-19", projects = createFetcherStore({
+);
+async function resolvePreview(instance, options) {
+  const projectionResult = await resolveProjection(instance, {
+    ...options,
+    projection: PREVIEW_PROJECTION
+  });
+  return projectionResult.data ? {
+    data: transformProjectionToPreview(
+      instance,
+      projectionResult.data,
+      options.resource
+    ),
+    isPending: projectionResult.isPending
+  } : { data: null, isPending: projectionResult.isPending };
+}
+const API_VERSION = "v2025-02-19", projects = createFetcherStore({
   name: "Projects",
   getKey: (_instance, options) => {
     const orgKey = options?.organizationId ? `:org:${options.organizationId}` : "", membersKey = options?.includeMembers === !1 ? ":no-members" : "";
@@ -4430,29 +3094,7 @@ const _resolveProjection = bindActionBySourceAndPerspective(
       });
     })
   )
-}), getProjectsState = projects.getState, resolveProjects = projects.resolveState, TOKEN_REGEX = /(?:[^\s"]+|"[^"]*")+/g;
-function isNegationToken(token) {
-  return typeof token < "u" && token.trim().startsWith("-");
-}
-function isPrefixToken(token) {
-  return typeof token < "u" && token.trim().endsWith("*");
-}
-function isExactMatchToken(token) {
-  return !!token && token.length >= 2 && token.startsWith('"') && token.endsWith('"');
-}
-function createGroqSearchFilter(query) {
-  const trimmedQuery = query.trim();
-  if (!trimmedQuery)
-    return "";
-  const tokens = trimmedQuery.match(TOKEN_REGEX) ?? [], reversedIndex = [...tokens].reverse().findIndex(
-    (token) => !isNegationToken(token) && !isExactMatchToken(token)
-  ), finalIncrementalTokenIndex = reversedIndex === -1 ? -1 : tokens.length - 1 - reversedIndex, finalIncrementalToken = tokens[finalIncrementalTokenIndex], processedTokens = [...tokens];
-  return finalIncrementalToken !== void 0 && !isPrefixToken(finalIncrementalToken) && processedTokens.splice(
-    finalIncrementalTokenIndex,
-    1,
-    `${finalIncrementalToken}*`
-  ), `[@] match text::query("${processedTokens.join(" ").replace(/"/g, '\\"')}")`;
-}
+}), getProjectsState = projects.getState, resolveProjects = projects.resolveState;
 function defineIntent(intent) {
   if (!intent.id)
     throw new Error("Intent must have an id");
@@ -4511,11 +3153,16 @@ function getCorsErrorProjectId(error) {
   const projMatch = (error.message || "").match(/manage\/project\/([^/?#]+)/);
   return projMatch ? projMatch[1] : null;
 }
-var version = "2.8.0";
-const CORE_SDK_VERSION = getEnv("PKG_VERSION") || `${version}-development`;
+function isImportError(error) {
+  if (!(error instanceof Error)) return !1;
+  if (error.name === "ChunkLoadError") return !0;
+  const message = error.message || "";
+  return /Loading chunk [\w-]+ failed/i.test(message) || /Failed to fetch dynamically imported module/i.test(message) || /error loading dynamically imported module/i.test(message) || /Import(?:ing)? a module script failed/i.test(message) || /Unable to preload CSS/i.test(message);
+}
 export {
   AuthStateType,
   CORE_SDK_VERSION,
+  PREVIEW_PROJECTION,
   agentGenerate,
   agentPatch,
   agentPrompt,
@@ -4571,8 +3218,12 @@ export {
   getUsersKey,
   getUsersState,
   handleAuthCallback,
+  isCanvasResource,
   isCanvasSource,
+  isDatasetResource,
   isDatasetSource,
+  isImportError,
+  isMediaLibraryResource,
   isMediaLibrarySource,
   isProjectUserNotFoundClientError,
   isStudioConfig,
@@ -4601,6 +3252,7 @@ export {
   slicePath2 as slicePath,
   stringifyPath2 as stringifyPath,
   subscribeDocumentEvents,
+  transformProjectionToPreview,
   unpublishDocument
 };
 //# sourceMappingURL=index.js.map