@sanity/sdk 3.0.0-rc.1 → 3.0.0-rc.2

package/dist/_chunks-es/createGroqSearchFilter.js

@@ -1,1864 +0,0 @@
-import { createClient, CorsOriginError, DisconnectError, ConnectionFailedError } from "@sanity/client";
-import { createImageUrlBuilder } from "@sanity/image-url";
-import "groq";
-import { Observable, map, distinctUntilChanged, shareReplay, skip, defer, finalize, filter, exhaustMap, timer, switchMap, takeWhile, catchError, EMPTY, fromEvent, retry, BehaviorSubject, combineLatest, startWith, tap, pairwise, mergeMap, groupBy, of, share, NEVER, first, firstValueFrom, race, Subscription } from "rxjs";
-import "@sanity/types";
-import { devtools } from "zustand/middleware";
-import { createStore } from "zustand/vanilla";
-import { createSelector } from "reselect";
-function isDatasetResource(resource) {
-  return "projectId" in resource && "dataset" in resource;
-}
-function isMediaLibraryResource(resource) {
-  return "mediaLibraryId" in resource;
-}
-function isCanvasResource(resource) {
-  return "canvasId" in resource;
-}
-function isDatasetSource(source) {
-  return isDatasetResource(source);
-}
-function isMediaLibrarySource(source) {
-  return isMediaLibraryResource(source);
-}
-function isCanvasSource(source) {
-  return isCanvasResource(source);
-}
-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 isReleasePerspective = (perspective) => typeof perspective == "object" && perspective !== null && "releaseName" in perspective;
-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(config) {
-  globalConfig = {
-    ...globalConfig,
-    ...config,
-    handler: config.handler ?? globalConfig.handler
-  };
-}
-function isLoggingEnabled() {
-  return typeof process < "u" && process.env?.NODE_ENV === "production" ? globalConfig.enableInProduction : !0;
-}
-function isNamespaceEnabled(namespace) {
-  return isLoggingEnabled() ? globalConfig.namespaces.includes("*") ? !0 : globalConfig.namespaces.includes(namespace) : !1;
-}
-function isLevelEnabled(level) {
-  return isLoggingEnabled() ? LOG_LEVEL_PRIORITY[level] <= LOG_LEVEL_PRIORITY[globalConfig.level] : !1;
-}
-function formatMessage(namespace, level, message, context) {
-  const parts = [];
-  if (globalConfig.timestamps) {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    parts.push(`[${timestamp}]`);
-  }
-  parts.push(`[${level.toUpperCase()}]`), parts.push(`[${namespace}]`);
-  const instanceContext = context?.instanceContext;
-  return instanceContext && (instanceContext.projectId && parts.push(`[project:${instanceContext.projectId}]`), instanceContext.dataset && parts.push(`[dataset:${instanceContext.dataset}]`), instanceContext.instanceId && parts.push(`[instance:${instanceContext.instanceId.slice(0, 8)}]`)), parts.push(message), [parts.join(" "), context];
-}
-function sanitizeContext(context) {
-  if (!context || Object.keys(context).length === 0) return;
-  const sanitized = { ...context }, sensitiveKeys = ["token", "password", "secret", "apiKey", "authorization"];
-  for (const key of Object.keys(sanitized))
-    sensitiveKeys.some((sensitive) => key.toLowerCase().includes(sensitive)) && (sanitized[key] = "[REDACTED]");
-  return sanitized;
-}
-function createLogger(namespace, baseContext) {
-  const logAtLevel = (level, message, context) => {
-    if (!isNamespaceEnabled(namespace) || !isLevelEnabled(level) || context?.internal && !globalConfig.internal) return;
-    const mergedContext = { ...baseContext, ...context }, sanitized = sanitizeContext(mergedContext), [formatted, finalContext] = formatMessage(namespace, level, message, sanitized);
-    globalConfig.handler[level](formatted, finalContext);
-  };
-  return {
-    namespace,
-    error: (message, context) => logAtLevel("error", message, context),
-    warn: (message, context) => logAtLevel("warn", message, context),
-    info: (message, context) => logAtLevel("info", message, context),
-    debug: (message, context) => logAtLevel("debug", message, context),
-    trace: (message, context) => logAtLevel("trace", message, { ...context, internal: !0 }),
-    isLevelEnabled: (level) => isNamespaceEnabled(namespace) && isLevelEnabled(level),
-    child: (childContext) => createLogger(namespace, { ...baseContext, ...childContext }),
-    getInstanceContext: () => baseContext?.instanceContext
-  };
-}
-function isObject(value) {
-  return typeof value == "object" && value !== null;
-}
-const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key), isPlainObject = (value) => {
-  if (!isObject(value)) return !1;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-};
-function omitProperty(value, key) {
-  if (!value) return {};
-  const { [key]: _omitted, ...rest } = value;
-  return rest;
-}
-function pickProperties(value, keys) {
-  const result = {};
-  for (const key of keys)
-    hasOwn(value, key) && (result[key] = value[key]);
-  return result;
-}
-const areSetsEqual = (left, right) => {
-  if (left.size !== right.size) return !1;
-  const unmatched = [...right];
-  outer: for (const leftValue of left) {
-    for (let index = 0; index < unmatched.length; index++)
-      if (isDeepEqual(leftValue, unmatched[index])) {
-        unmatched.splice(index, 1);
-        continue outer;
-      }
-    return !1;
-  }
-  return unmatched.length === 0;
-}, areMapsEqual = (left, right) => {
-  if (left.size !== right.size) return !1;
-  const unmatched = [...right.entries()];
-  outer: for (const [leftKey, leftValue] of left) {
-    for (let index = 0; index < unmatched.length; index++) {
-      const [rightKey, rightValue] = unmatched[index];
-      if (isDeepEqual(leftKey, rightKey) && isDeepEqual(leftValue, rightValue)) {
-        unmatched.splice(index, 1);
-        continue outer;
-      }
-    }
-    return !1;
-  }
-  return unmatched.length === 0;
-};
-function isDeepEqual(left, right) {
-  if (Object.is(left, right)) return !0;
-  if (!isObject(left) || !isObject(right)) return !1;
-  if (left instanceof Date && right instanceof Date)
-    return left.getTime() === right.getTime();
-  if (left instanceof RegExp && right instanceof RegExp)
-    return left.source === right.source && left.flags === right.flags;
-  if (left instanceof Set && right instanceof Set)
-    return areSetsEqual(left, right);
-  if (left instanceof Map && right instanceof Map)
-    return areMapsEqual(left, right);
-  if (Array.isArray(left) || Array.isArray(right))
-    return !Array.isArray(left) || !Array.isArray(right) || left.length !== right.length ? !1 : left.every((value, index) => isDeepEqual(value, right[index]));
-  if (!isPlainObject(left) || !isPlainObject(right)) return !1;
-  const leftKeys = Object.keys(left), rightKeys = Object.keys(right);
-  if (leftKeys.length !== rightKeys.length) return !1;
-  for (const key of leftKeys)
-    if (!hasOwn(right, key) || !isDeepEqual(left[key], right[key]))
-      return !1;
-  return !0;
-}
-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 defineStore(storeDefinition) {
-  return storeDefinition;
-}
-function createStoreInstance(instance, key, { name, getInitialState, initialize }) {
-  const state = createStoreState(getInitialState(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 createResourceKey = (instance, resource) => {
-  let name, resourceForKey;
-  if (resource) {
-    if (resourceForKey = resource, isDatasetResource(resource))
-      name = `${resource.projectId}.${resource.dataset}`;
-    else if (isMediaLibraryResource(resource))
-      name = `media-library:${resource.mediaLibraryId}`;
-    else if (isCanvasResource(resource))
-      name = `canvas:${resource.canvasId}`;
-    else
-      throw new Error(`Received invalid resource: ${JSON.stringify(resource)}`);
-    return { name, resource: resourceForKey };
-  }
-  const { projectId, dataset } = instance.config;
-  if (!projectId || !dataset)
-    throw new Error("This API requires a project ID and dataset configured.");
-  return { name: `${projectId}.${dataset}`, resource: { projectId, dataset } };
-}, bindActionByResource = createActionBinder((instance, { resource }) => createResourceKey(instance, resource)), bindActionByResourceAndPerspective = createActionBinder((instance, options) => {
-  const { resource, 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 = createResourceKey(instance, resource);
-  return {
-    name: `${sourceKey.name}:${perspectiveKey}`,
-    resource: sourceKey.resource,
-    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, isEqual = options && "isEqual" in options ? options.isEqual ?? Object.is : Object.is, selectorContextCache = /* @__PURE__ */ new WeakMap();
-  function stateSourceAction(context, ...params) {
-    const { state, instance } = context, getCurrent = (currentState) => {
-      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);
-    };
-    let values = state.observable.pipe(map(getCurrent), distinctUntilChanged(isEqual));
-    subscribeHandler && (values = withSubscribeHook(values, () => subscribeHandler(context, ...params)));
-    const sharedValues = values.pipe(shareReplay({ bufferSize: 1, refCount: !0 }));
-    return {
-      getCurrent: () => getCurrent(state.get()),
-      subscribe: (onStoreChanged) => {
-        const subscription = sharedValues.pipe(skip(1)).subscribe({
-          next: () => onStoreChanged?.(),
-          // Propagate selector errors to both subscription types
-          error: () => onStoreChanged?.()
-        });
-        return () => {
-          subscription.unsubscribe();
-        };
-      },
-      observable: sharedValues
-    };
-  }
-  return stateSourceAction;
-}
-function withSubscribeHook(obs, fn) {
-  return defer(() => {
-    const cleanup = fn();
-    return cleanup ? obs.pipe(finalize(() => cleanup())) : obs;
-  });
-}
-function getStagingApiHost() {
-  if (typeof __SANITY_STAGING__ < "u" && __SANITY_STAGING__ === !0)
-    return "https://api.sanity.work";
-}
-const loggers = /* @__PURE__ */ new WeakMap();
-function getAuthLogger(instance) {
-  let logger = loggers.get(instance);
-  return logger || (logger = createLogger("auth", {
-    instanceContext: {
-      instanceId: instance.instanceId,
-      projectId: instance.config.projectId,
-      dataset: instance.config.dataset
-    }
-  }), loggers.set(instance, logger)), logger;
-}
-const REFRESH_INTERVAL = 720 * 60 * 1e3;
-function createTokenRefreshStream(token, clientFactory, apiHost) {
-  return new Observable((subscriber) => {
-    const subscription = clientFactory({
-      apiVersion: DEFAULT_API_VERSION$1,
-      requestTagPrefix: REQUEST_TAG_PREFIX,
-      useProjectHostname: !1,
-      useCdn: !1,
-      token,
-      ignoreBrowserTokenWarning: !0,
-      ...apiHost && { apiHost }
-    }).observable.request({
-      uri: "auth/refresh-token",
-      method: "POST",
-      tag: "refresh-token",
-      body: {
-        token
-      }
-    }).subscribe(subscriber);
-    return () => subscription.unsubscribe();
-  });
-}
-function shouldRefreshToken(lastRefresh) {
-  return lastRefresh ? Date.now() - lastRefresh >= REFRESH_INTERVAL : !0;
-}
-const refreshStampedToken = ({
-  state,
-  instance
-}) => {
-  const logger = getAuthLogger(instance), { clientFactory, apiHost, storageArea, storageKey } = state.get().options;
-  return state.observable.pipe(
-    map((storeState) => storeState.authState),
-    filter(
-      (authState) => authState.type === AuthStateType.LOGGED_IN
-    ),
-    distinctUntilChanged((prev, curr) => prev.token === curr.token),
-    filter((authState) => authState.token.includes("-st")),
-    // Ensure we only try to refresh stamped tokens
-    exhaustMap(
-      () => 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 }))
-      )
-    )
-  ).subscribe({
-    next: (response) => {
-      logger.debug("Token refresh completed, updating state"), 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) => {
-      logger.error("Token refresh failed", { error }), state.set("setRefreshStampedTokenError", { authState: { type: AuthStateType.ERROR, error } });
-    }
-  });
-}, subscribeToStateAndFetchCurrentUser = ({ state, instance }, fetchOptions) => {
-  const logger = getAuthLogger(instance), { 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",
-        tag: "users.get-current"
-      }).pipe(
-        /**
-         * Catch inside switchMap so the outer subscription survives.
-         * Without this, a 401 terminates the subscription permanently
-         * and subsequent token refreshes via comlink never re-fetch /users/me.
-         * @see SDK-1409
-         */
-        catchError((error) => (logger.error("Failed to fetch current user", { error }), state.set("setError", { authState: { type: AuthStateType.ERROR, error } }), EMPTY))
-      )
-    )
-  ).subscribe({
-    next: (currentUser) => {
-      logger.info("Current user fetched successfully", {
-        hasEmail: !!currentUser.email
-      }), logger.debug("Current user details", { userId: currentUser.id }), state.set("setCurrentUser", (prev) => ({
-        authState: prev.authState.type === AuthStateType.LOGGED_IN ? { ...prev.authState, currentUser } : prev.authState
-      }));
-    }
-  });
-};
-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: createLoggedInAuthState(providedToken, 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 ? createLoggedInAuthState(token, 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: createLoggedInAuthState(providedToken, 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: createLoggedInAuthState(token, 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: REQUEST_TAG_PREFIX,
-      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: createLoggedInAuthState(providedToken, null),
-    storageKey: studioStorageKey,
-    storageArea,
-    authMethod,
-    dashboardContext: {}
-  } : token ? {
-    authState: createLoggedInAuthState(token, 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 = [], studioAuthenticated = context.instance.config.studio?.authenticated === !0;
-  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: createLoggedInAuthState(token, null)
-      })) : studioAuthenticated ? state.set("studioTokenSourceCookieAuth", (prev) => ({
-        options: { ...prev.options, authMethod: "cookie" },
-        authState: prev.authState.type === AuthStateType.LOGGED_IN ? prev.authState : createLoggedInAuthState("", 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 : createLoggedInAuthState("", 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 logger = getAuthLogger(instance);
-    logger.debug("Initializing auth store", {
-      hasProvidedToken: !!instance.config.auth?.token,
-      hasCustomProviders: !!(instance.config.auth?.providers && instance.config.auth.providers.length > 0),
-      studioMode: instance.config.studioMode?.enabled ?? !1
-    });
-    const {
-      apiHost: configApiHost,
-      callbackUrl,
-      providers: customProviders,
-      token: providedToken,
-      clientFactory = createClient,
-      initialLocationHref = getDefaultLocation()
-    } = instance.config.auth ?? {}, apiHost = configApiHost ?? getStagingApiHost(), 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 logger.debug("Auth state initialized", {
-      authStateType: result.authState.type,
-      mode,
-      authMethod: result.authMethod
-    }), {
-      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 logger = getAuthLogger(context.instance), initialLocationHref = context.state.get().options?.initialLocationHref ?? getDefaultLocation(), mode = resolveAuthMode(context.instance.config, initialLocationHref);
-    logger.debug("Setting up auth subscriptions", { mode });
-    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), () => {
-      logger.debug("Cleaning up auth subscriptions"), 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 = 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, instance }, token) => {
-    const logger = getAuthLogger(instance), currentAuthState = state.get().authState;
-    if (token) {
-      if (currentAuthState.type !== AuthStateType.LOGGED_IN || currentAuthState.token !== token) {
-        logger.info("Setting auth token");
-        const currentUser = currentAuthState.type === AuthStateType.LOGGED_IN ? currentAuthState.currentUser : null, preservedLastTokenRefresh = currentAuthState.type === AuthStateType.LOGGED_IN ? currentAuthState.lastTokenRefresh : void 0;
-        state.set("setToken", {
-          authState: createLoggedInAuthState(token, currentUser, preservedLastTokenRefresh)
-        });
-      }
-    } else
-      currentAuthState.type !== AuthStateType.LOGGED_OUT && (logger.info("Clearing auth token"), state.set("setToken", {
-        authState: { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }
-      }));
-  }
-);
-var authStore$1 = /* @__PURE__ */ Object.freeze({
-  __proto__: null,
-  authStore,
-  getAuthMethodState,
-  getAuthState,
-  getCurrentUserState,
-  getDashboardOrganizationId,
-  getIsInDashboardState,
-  getLoginUrlState,
-  getTokenState,
-  setAuthToken
-});
-function createLoggedInAuthState(token, currentUser, existingLastTokenRefresh) {
-  const isStampedToken = token.includes("-st"), lastTokenRefresh = existingLastTokenRefresh ?? (isStampedToken ? Date.now() : void 0);
-  return {
-    type: AuthStateType.LOGGED_IN,
-    token,
-    currentUser,
-    ...lastTokenRefresh !== void 0 && { lastTokenRefresh }
-  };
-}
-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";
-}
-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
-}`, 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,
-  resource: 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(pickProperties(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 projectId = options.projectId ?? instance.config.projectId, dataset = options.dataset ?? instance.config.dataset, resource;
-    options.resource && (isMediaLibraryResource(options.resource) ? resource = { type: "media-library", id: options.resource.mediaLibraryId } : isCanvasResource(options.resource) ? resource = { type: "canvas", id: options.resource.canvasId } : isDatasetResource(options.resource) && (projectId = options.resource.projectId, dataset = options.resource.dataset));
-    const apiHost = options.apiHost ?? instance.config.auth?.apiHost ?? getStagingApiHost(), effectiveOptions = {
-      ...DEFAULT_CLIENT_CONFIG,
-      ...(options.scope === "global" || !projectId || resource) && { useProjectHostname: !1 },
-      token: authMethod === "cookie" ? void 0 : tokenFromState ?? void 0,
-      ...options,
-      ...projectId && { projectId },
-      ...dataset && { dataset },
-      ...resource ? { resource } : { resource: void 0 },
-      ...apiHost && { apiHost }
-    };
-    resource && (delete effectiveOptions.projectId, delete effectiveOptions.dataset), effectiveOptions.token === null || 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))
-);
-var clientStore$1 = /* @__PURE__ */ Object.freeze({
-  __proto__: null,
-  getClient,
-  getClientState
-});
-const API_VERSION$1 = "v2025-05-06";
-function hasImageRef(value) {
-  return isObject(value) && "_ref" in value && typeof value._ref == "string";
-}
-function normalizeMedia(media, client) {
-  if (!media || !hasImageRef(media)) return null;
-  const url = createImageUrlBuilder(client).image({ _ref: media._ref }).url();
-  return {
-    type: "image-asset",
-    _ref: media._ref,
-    url
-  };
-}
-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 transformProjectionToPreview(instance, projectionResult, resource) {
-  const title = findFirstDefined(TITLE_CANDIDATES, projectionResult.titleCandidates), subtitle = findFirstDefined(SUBTITLE_CANDIDATES, projectionResult.subtitleCandidates, title), client = getClient(instance, {
-    apiVersion: API_VERSION$1,
-    resource
-  });
-  return {
-    title: String(title || `${projectionResult._type}: ${projectionResult._id}`),
-    subtitle: subtitle || void 0,
-    media: normalizeMedia(projectionResult.media, client),
-    ...projectionResult._status && { _status: projectionResult._status }
-  };
-}
-const LIVE_EVENTS_API_VERSION = "v2025-05-06", LIVE_EVENTS_RETRY_DELAY = 1e3;
-function observeLiveEvents(instance, { resource, onCorsError }) {
-  return getClientState(instance, {
-    apiVersion: LIVE_EVENTS_API_VERSION,
-    resource
-  }).observable.pipe(
-    switchMap(
-      (client) => defer(
-        () => client.live.events({ includeDrafts: !!client.config().token, tag: "live-events" })
-      ).pipe(
-        catchError((error) => {
-          if (error instanceof CorsOriginError)
-            return onCorsError(error), EMPTY;
-          if (error instanceof DisconnectError)
-            return EMPTY;
-          if (error instanceof ConnectionFailedError && typeof error.status == "number" && error.status >= 400 && error.status < 500)
-            return EMPTY;
-          throw error;
-        }),
-        // Server-initiated live errors (e.g. ChannelError, MessageError) are
-        // retried, not surfaced. Dropped connections are already reconnected
-        // inside @sanity/client.
-        retry({ delay: LIVE_EVENTS_RETRY_DELAY })
-      )
-    ),
-    filter((e) => e.type === "message")
-  );
-}
-const RELEASES_QUERY = "releases::all()", RELEASES_API_VERSION = "v2025-05-06";
-function observeReleases(instance, { resource, onCorsError }) {
-  return getClientState(instance, {
-    apiVersion: RELEASES_API_VERSION,
-    resource
-  }).observable.pipe(
-    switchMap((client) => {
-      const syncTags$ = new BehaviorSubject(void 0);
-      return combineLatest([
-        observeLiveEvents(instance, { resource, onCorsError }).pipe(startWith(void 0)),
-        syncTags$
-      ]).pipe(
-        filter(
-          ([message, syncTags]) => message === void 0 || message.tags.some((tag) => syncTags?.includes(tag))
-        ),
-        map(([message]) => message?.id),
-        distinctUntilChanged()
-      ).pipe(
-        switchMap(
-          (lastLiveEventId) => client.observable.fetch(
-            RELEASES_QUERY,
-            {},
-            {
-              perspective: "raw",
-              filterResponse: !1,
-              returnQuery: !1,
-              lastLiveEventId,
-              tag: "releases"
-            }
-          )
-        ),
-        tap((response) => {
-          syncTags$.next(response.syncTags);
-        }),
-        map((response) => response.result)
-      );
-    }),
-    // Emit synchronously on subscribe (mirroring StateSource semantics, which
-    // the releases store previously consumed) so the store can immediately
-    // record an empty list: consumers distinguish "no releases yet" from
-    // "never loaded", and the React hooks don't suspend on first load.
-    startWith(void 0)
-  );
-}
-function sortReleases(releases = []) {
-  return [...releases].sort((a, b) => {
-    const aType = a.metadata?.releaseType, bType = b.metadata?.releaseType;
-    if (aType === "undecided" && bType !== "undecided")
-      return -1;
-    if (aType !== "undecided" && bType === "undecided")
-      return 1;
-    if (aType === "undecided" && bType === "undecided")
-      return new Date(b._createdAt).getTime() - new Date(a._createdAt).getTime();
-    if (aType === "scheduled" && bType === "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 aType === "asap" && bType !== "asap" ? 1 : aType !== "asap" && bType === "asap" ? -1 : aType === "asap" && bType === "asap" ? new Date(b._createdAt).getTime() - new Date(a._createdAt).getTime() : 0;
-  });
-}
-const ARCHIVED_RELEASE_STATES = ["archived", "published"], STABLE_EMPTY_RELEASES = [], releasesStore = {
-  name: "Releases",
-  getInitialState: () => ({
-    activeReleases: void 0,
-    allReleases: void 0
-  }),
-  initialize: (context) => {
-    const subscription = subscribeToReleases(context);
-    return () => subscription.unsubscribe();
-  }
-}, _getActiveReleasesState = bindActionByResource(
-  releasesStore,
-  createStateSourceAction({
-    selector: ({ state }) => {
-      if (state.error) throw state.error;
-      return state.activeReleases;
-    }
-  })
-), getActiveReleasesState = (instance, options) => (
-  // bindActionByResource keyFn destructures { resource } from the first param, so pass {} when no options
-  _getActiveReleasesState(instance, options ?? {})
-), _getAllReleasesState = bindActionByResource(
-  releasesStore,
-  createStateSourceAction({
-    selector: ({ state }) => {
-      if (state.error) throw state.error;
-      return state.allReleases;
-    }
-  })
-), getAllReleasesState = (instance, options) => _getAllReleasesState(instance, options ?? {}), subscribeToReleases = ({
-  instance,
-  state,
-  key: { resource }
-}) => observeReleases(instance, {
-  resource,
-  // Surface CORS errors as store state instead of erroring the stream so
-  // they can be handled by the Cors Error component
-  onCorsError: (error) => state.set("setError", { error })
-}).pipe(
-  map((releases) => {
-    const sorted = sortReleases(releases ?? STABLE_EMPTY_RELEASES).reverse();
-    state.set("setReleases", {
-      allReleases: sorted,
-      activeReleases: sorted.filter(
-        (release) => !ARCHIVED_RELEASE_STATES.includes(release.state)
-      )
-    });
-  })
-).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();
-    }
-  )
-}), _boundGetPerspectiveState = bindActionByResource(
-  releasesStore,
-  _getPerspectiveStateSelector
-), getPerspectiveState = (instance, ...rest) => (
-  // bindActionByResource keyFn destructures { resource } from the first param, so pass {} when no options
-  _boundGetPerspectiveState(instance, ...rest.length ? rest : [{}])
-);
-function unref(timer2) {
-  const t = timer2;
-  typeof t == "object" && t !== null && "unref" in t && typeof t.unref == "function" && t.unref();
-}
-function setCleanupTimeout(fn, delay) {
-  const timer2 = setTimeout(fn, delay);
-  return unref(timer2), timer2;
-}
-function setCleanupInterval(fn, delay) {
-  const timer2 = setInterval(fn, delay);
-  return unref(timer2), timer2;
-}
-const 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: omitProperty(prev.queries, key) };
-}, 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(/* @__PURE__ */ new Set()),
-  pairwise(),
-  mergeMap(([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((i) => i.key),
-  mergeMap(
-    (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,
-          resource,
-          perspective: perspectiveFromOptions,
-          ...restOptions
-        } = parseQueryKey(group$.key), perspective$ = isReleasePerspective(perspectiveFromOptions) ? getPerspectiveState(instance, {
-          perspective: perspectiveFromOptions,
-          resource
-        }).observable.pipe(filter(Boolean)) : of(perspectiveFromOptions ?? QUERY_STORE_DEFAULT_PERSPECTIVE), client$ = getClientState(instance, {
-          apiVersion: QUERY_STORE_API_VERSION,
-          projectId,
-          dataset,
-          resource
-        }).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
-            })
-          ),
-          tap(({ result, syncTags }) => {
-            state.set("setQueryData", setQueryData(group$.key, result, syncTags));
-          }),
-          // Catch inside the per-event stream: erroring the group pipe would
-          // complete the group's subscription, and since `groupBy` above never
-          // removes its group subjects, re-adding the key would emit into a
-          // subject with no subscribers — the key could never be fetched again.
-          catchError((error) => (state.set("setQueryError", setQueryError(group$.key, error)), EMPTY))
-        );
-      })
-    )
-  )
-).subscribe({ error: errorHandler(state) }), listenToLiveClientAndSetLastLiveEventIds = ({
-  state,
-  instance,
-  key: { resource }
-}) => {
-  const liveMessages$ = observeLiveEvents(instance, {
-    resource,
-    // Surface CORS errors as store state (handled by the Cors Error
-    // component) instead of erroring the stream: a stream error here would
-    // reach the outer subscription's errorHandler, set the store-wide
-    // `state.error`, and permanently brick every query selector.
-    onCorsError: (error) => state.set("setError", { error })
-  }).pipe(share());
-  return state.observable.pipe(
-    mergeMap((s) => Object.entries(s.queries)),
-    groupBy(([key]) => key),
-    mergeMap((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(([message]) => {
-          state.set("setLastLiveEventId", setLastLiveEventId(group$.key, message.id));
-        })
-      );
-    })
-  ).subscribe({ error: errorHandler(state) });
-};
-function getQueryState(...args) {
-  return _getQueryState(...args);
-}
-const _getQueryState = bindActionByResource(
-  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)), () => {
-        setCleanupTimeout(
-          () => state.set("removeSubscriber", removeSubscriber(key, subscriptionId)),
-          QUERY_STATE_CLEAR_DELAY
-        );
-      };
-    }
-  })
-);
-function resolveQuery(...args) {
-  return _resolveQuery(...args);
-}
-const _resolveQuery = bindActionByResource(
-  queryStore,
-  ({ state, instance }, { signal, ...options }) => {
-    const normalized = normalizeOptionsWithPerspective(instance, options), { getCurrent } = getQueryState(instance, normalized), key = getQueryKey(normalized), subscriptionId = insecureRandomId();
-    state.set("addSubscriber", addSubscriber(key, subscriptionId));
-    const 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((error) => {
-        throw error instanceof Error && error.name === "AbortError" && state.set("removeSubscriber", removeSubscriber(key, subscriptionId)), error;
-      })
-    ) : NEVER, resolved$ = state.observable.pipe(
-      map(getCurrent),
-      first((i) => i !== void 0)
-    ), promise = firstValueFrom(race([resolved$, aborted$])), releaseSubscriber = () => {
-      setCleanupTimeout(() => {
-        state.set("removeSubscriber", removeSubscriber(key, subscriptionId));
-      }, QUERY_STATE_CLEAR_DELAY);
-    };
-    return promise.then(releaseSubscriber, releaseSubscriber), promise;
-  }
-), DEFAULT_STALE_TIME = 3e4, DEFAULT_GC_TIME = 3e5, definitions = /* @__PURE__ */ new Map(), inflight = /* @__PURE__ */ new Map(), gcTimers = /* @__PURE__ */ new Map(), intervalTimers = /* @__PURE__ */ new Map(), snapshotCache = /* @__PURE__ */ new WeakMap(), PENDING_SNAPSHOT = {
-  status: "pending",
-  data: void 0,
-  error: void 0,
-  isFetching: !1,
-  dataUpdatedAt: void 0
-}, entryKey = (fetcherName, rawKey) => `${fetcherName}:${rawKey}`, computeTags = (def, data, params) => typeof def.tags == "function" ? def.tags(data, ...params) : def.tags ?? [], isUpdaterFn = (updater) => typeof updater == "function", applyUpdater = (updater, current) => isUpdaterFn(updater) ? updater(current) : updater, needsFetch = (entry, def) => entry.isFetching ? !1 : entry.status !== "success" ? !0 : entry.forcedStale || Date.now() - (entry.dataUpdatedAt ?? 0) >= (def.staleTime ?? DEFAULT_STALE_TIME), asTyped = (entry) => entry, toSnapshot = (entry) => {
-  if (!entry) return PENDING_SNAPSHOT;
-  const cached = snapshotCache.get(entry);
-  if (cached) return cached;
-  let snapshot;
-  return entry.status === "success" ? snapshot = {
-    status: "success",
-    data: entry.data,
-    error: entry.error,
-    isFetching: entry.isFetching,
-    dataUpdatedAt: entry.dataUpdatedAt
-  } : entry.status === "error" ? snapshot = {
-    status: "error",
-    data: void 0,
-    error: entry.error,
-    isFetching: entry.isFetching,
-    dataUpdatedAt: void 0
-  } : snapshot = {
-    status: "pending",
-    data: void 0,
-    error: void 0,
-    isFetching: entry.isFetching,
-    dataUpdatedAt: void 0
-  }, snapshotCache.set(entry, snapshot), snapshot;
-}, cacheStore = {
-  name: "FetcherCache",
-  getInitialState: () => ({ entries: {} }),
-  initialize: () => () => {
-    for (const timer2 of gcTimers.values()) clearTimeout(timer2);
-    for (const timer2 of intervalTimers.values()) clearInterval(timer2);
-    for (const fetch of inflight.values()) fetch.sub.unsubscribe();
-    gcTimers.clear(), intervalTimers.clear(), inflight.clear();
-  }
-}, updateEntry = (state, key, actionName, updater) => {
-  state.set(actionName, (prev) => {
-    const next = updater(prev.entries[key]);
-    if (next === prev.entries[key]) return prev;
-    const entries = { ...prev.entries };
-    return next === void 0 ? delete entries[key] : entries[key] = next, { entries };
-  });
-}, baseEntry = (def, key, instance, params) => {
-  const seeded = def.initialData?.(instance, ...params);
-  return seeded ? {
-    fetcherName: def.name,
-    key,
-    params,
-    instance,
-    status: "success",
-    data: seeded.data,
-    error: void 0,
-    dataUpdatedAt: seeded.dataUpdatedAt,
-    isFetching: !1,
-    version: 0,
-    forcedStale: !1,
-    tags: computeTags(def, seeded.data, params),
-    subscriptions: 0
-  } : {
-    fetcherName: def.name,
-    key,
-    params,
-    instance,
-    status: "pending",
-    data: void 0,
-    error: void 0,
-    dataUpdatedAt: void 0,
-    isFetching: !1,
-    version: 0,
-    forcedStale: !1,
-    tags: [],
-    subscriptions: 0
-  };
-}, startFetch = (state, def, instance, params, force) => {
-  const key = entryKey(def.name, def.getKey(instance, ...params)), existing = inflight.get(key);
-  if (existing && !force) return existing.promise;
-  existing && (existing.sub.unsubscribe(), inflight.delete(key)), updateEntry(state, key, "fetchStart", (prev) => ({
-    ...prev ?? baseEntry(def, key, instance, params),
-    isFetching: !0
-  }));
-  const startVersion = state.get().entries[key]?.version ?? 0;
-  let resolve, reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res, reject = rej;
-  });
-  existing && promise.then(existing.resolve, existing.reject);
-  const sub = new Subscription();
-  return inflight.set(key, { sub, promise, resolve, reject, startVersion }), sub.add(
-    def.fetch(instance)(...params).subscribe({
-      next: (data) => {
-        const current = state.get().entries[key];
-        if (current && current.version !== startVersion) {
-          inflight.delete(key), current.isFetching && updateEntry(
-            state,
-            key,
-            "fetchDiscard",
-            (prev) => prev && { ...prev, isFetching: !1 }
-          ), resolve(current.data), sub.unsubscribe();
-          return;
-        }
-        updateEntry(state, key, "fetchSuccess", (prev) => ({
-          ...prev ?? baseEntry(def, key, instance, params),
-          status: "success",
-          data,
-          error: void 0,
-          dataUpdatedAt: Date.now(),
-          isFetching: !1,
-          forcedStale: !1,
-          tags: computeTags(def, data, params)
-        })), resolve(data);
-      },
-      error: (error) => {
-        updateEntry(state, key, "fetchError", (prev) => prev && (prev.status === "success" ? { ...prev, error, isFetching: !1 } : { ...prev, status: "error", error, isFetching: !1 })), inflight.delete(key), reject(error);
-      },
-      complete: () => {
-        inflight.delete(key), state.get().entries[key]?.isFetching && updateEntry(state, key, "fetchSettle", (prev) => prev && { ...prev, isFetching: !1 });
-      }
-    })
-  ), promise;
-}, detach = (promise) => {
-  promise.catch(() => {
-  });
-}, markStale = (state, key) => updateEntry(state, key, "markStale", (prev) => prev && { ...prev, forcedStale: !0 }), startInterval = (state, def, instance, params, key) => {
-  if (!def.refetchInterval || intervalTimers.has(key)) return;
-  const timer2 = setCleanupInterval(() => {
-    if (typeof document < "u" && document.hidden) return;
-    const entry = state.get().entries[key];
-    entry && entry.subscriptions > 0 && detach(startFetch(state, def, instance, params, !0));
-  }, def.refetchInterval);
-  intervalTimers.set(key, timer2);
-}, scheduleGc = (state, def, key) => {
-  if (gcTimers.has(key)) return;
-  const entry = state.get().entries[key];
-  if (!entry || entry.subscriptions > 0) return;
-  const timer2 = setCleanupTimeout(() => {
-    gcTimers.delete(key);
-    const fetch = inflight.get(key);
-    fetch && (fetch.sub.unsubscribe(), inflight.delete(key)), updateEntry(state, key, "gc", () => {
-    });
-  }, def.gcTime ?? DEFAULT_GC_TIME);
-  gcTimers.set(key, timer2);
-}, invalidateByTags = bindActionGlobally(
-  cacheStore,
-  ({ state }, targets) => {
-    const refetches = [];
-    for (const [key, entry] of Object.entries(state.get().entries)) {
-      if (!entry.tags.some(
-        (tag) => targets.some(
-          (target) => tag.type === target.type && (target.id === void 0 || tag.id === target.id)
-        )
-      ) || (markStale(state, key), entry.subscriptions <= 0)) continue;
-      const def = definitions.get(entry.fetcherName);
-      def && refetches.push(
-        startFetch(state, def, entry.instance, entry.params, !0).catch(() => {
-        })
-      );
-    }
-    return Promise.all(refetches).then(() => {
-    });
-  }
-);
-function defineFetcher(definition) {
-  const def = definition;
-  definitions.set(definition.name, def);
-  const getState = bindActionGlobally(
-    cacheStore,
-    createStateSourceAction({
-      selector: ({ state, instance }, ...params) => {
-        const key = entryKey(def.name, def.getKey(instance, ...params)), entry = state.entries[key];
-        return toSnapshot(entry && asTyped(entry));
-      },
-      onSubscribe: ({ state, instance }, ...params) => {
-        const key = entryKey(def.name, def.getKey(instance, ...params)), pendingGc = gcTimers.get(key);
-        return pendingGc && (clearTimeout(pendingGc), gcTimers.delete(key)), updateEntry(state, key, "subscribe", (prev) => ({
-          ...prev ?? baseEntry(def, key, instance, params),
-          instance,
-          subscriptions: (prev?.subscriptions ?? 0) + 1
-        })), startInterval(state, def, instance, params, key), queueMicrotask(() => {
-          const entry = state.get().entries[key];
-          entry && entry.subscriptions > 0 && needsFetch(entry, def) && detach(startFetch(state, def, instance, params, !1));
-        }), () => {
-          updateEntry(
-            state,
-            key,
-            "unsubscribe",
-            (prev) => prev && { ...prev, subscriptions: Math.max(0, prev.subscriptions - 1) }
-          );
-          const entry = state.get().entries[key];
-          if (!entry || entry.subscriptions > 0) return;
-          const interval = intervalTimers.get(key);
-          interval && (clearInterval(interval), intervalTimers.delete(key)), scheduleGc(state, def, key);
-        };
-      }
-    })
-  ), resolveState = (instance, ...params) => firstValueFrom(
-    getState(instance, ...params).observable.pipe(
-      filter(
-        (snapshot) => snapshot.status !== "pending"
-      ),
-      map((snapshot) => {
-        if (snapshot.status === "error") throw snapshot.error;
-        return snapshot.data;
-      })
-    )
-  ), invalidate = bindActionGlobally(
-    cacheStore,
-    ({ state, instance }, ...params) => {
-      const key = entryKey(def.name, def.getKey(instance, ...params));
-      markStale(state, key);
-      const entry = state.get().entries[key];
-      entry && entry.subscriptions > 0 && detach(startFetch(state, def, instance, params, !0));
-    }
-  ), invalidateAll = bindActionGlobally(cacheStore, ({ state }) => {
-    const prefix = `${def.name}:`;
-    for (const [key, entry] of Object.entries(state.get().entries))
-      key.startsWith(prefix) && (markStale(state, key), entry.subscriptions > 0 && detach(startFetch(state, def, entry.instance, entry.params, !0)));
-  }), refetch = bindActionGlobally(
-    cacheStore,
-    ({ state, instance }, ...params) => {
-      const key = entryKey(def.name, def.getKey(instance, ...params)), promise = startFetch(state, def, instance, params, !0);
-      return scheduleGc(state, def, key), promise;
-    }
-  ), setData = bindActionGlobally(
-    cacheStore,
-    ({ state, instance }, params, updater) => {
-      const key = entryKey(def.name, def.getKey(instance, ...params));
-      let previous;
-      return updateEntry(state, key, "setData", (prev) => {
-        previous = prev;
-        const from = asTyped(prev ?? baseEntry(def, key, instance, params)), nextData = applyUpdater(updater, from.data);
-        return {
-          ...from,
-          status: "success",
-          data: nextData,
-          dataUpdatedAt: from.dataUpdatedAt ?? Date.now(),
-          version: from.version + 1,
-          tags: computeTags(def, nextData, params)
-        };
-      }), scheduleGc(state, def, key), { undo: () => updateEntry(state, key, "undoSetData", () => previous) };
-    }
-  );
-  return { getState, resolveState, invalidate, invalidateAll, refetch, setData };
-}
-function defineMutation(definition) {
-  return (instance, input) => {
-    const undos = [], write = (fetcher, params, updater) => {
-      undos.push(fetcher.setData(instance, params, updater).undo);
-    };
-    return definition.onMutate?.(write, input), firstValueFrom(definition.mutationFn(instance)(input)).then(
-      (result) => {
-        definition.onSuccess?.(write, result, input);
-        const targets = typeof definition.invalidates == "function" ? definition.invalidates(result, input) : definition.invalidates ?? [], invalidated = targets.length ? invalidateByTags(instance, targets) : Promise.resolve();
-        return { data: result, invalidated };
-      },
-      (error) => {
-        for (let i = undos.length - 1; i >= 0; i--) undos[i]();
-        throw error;
-      }
-    );
-  };
-}
-var version = "3.0.0-rc.1";
-const CORE_SDK_VERSION = getEnv("PKG_VERSION") || `${version}-development`, API_VERSION = "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: omitProperty(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: omitProperty(prev.users, key) };
-}, initializeRequest = (key) => (prev) => prev.users[key] ? prev : { ...prev, users: { ...prev.users, [key]: { subscriptions: [] } } }, 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, '\\"')}")`;
-}
-export {
-  API_VERSION,
-  AuthStateType,
-  CORE_SDK_VERSION,
-  DEFAULT_API_VERSION$1 as DEFAULT_API_VERSION,
-  PREVIEW_PROJECTION,
-  PROJECT_API_VERSION,
-  REQUEST_TAG_PREFIX,
-  USERS_STATE_CLEAR_DELAY,
-  addSubscription,
-  authStore,
-  authStore$1,
-  bindActionByResource,
-  bindActionByResourceAndPerspective,
-  bindActionGlobally,
-  cancelRequest,
-  clientStore$1 as clientStore,
-  configureLogging,
-  createGroqSearchFilter,
-  createLoggedInAuthState,
-  createLogger,
-  createStateSourceAction,
-  defineFetcher,
-  defineMutation,
-  defineStore,
-  getActiveReleasesState,
-  getAllReleasesState,
-  getAuthCode,
-  getAuthLogger,
-  getAuthState,
-  getCleanedUrl,
-  getClient,
-  getClientErrorApiBody,
-  getClientErrorApiDescription,
-  getClientErrorApiType,
-  getClientState,
-  getCurrentUserState,
-  getDashboardOrganizationId,
-  getDefaultLocation,
-  getIsInDashboardState,
-  getLoginUrlState,
-  getPerspectiveState,
-  getQueryKey,
-  getQueryState,
-  getTokenFromLocation,
-  getTokenState,
-  getUsersKey,
-  initializeRequest,
-  insecureRandomId,
-  isCanvasResource,
-  isCanvasSource,
-  isDatasetResource,
-  isDatasetSource,
-  isDeepEqual,
-  isMediaLibraryResource,
-  isMediaLibrarySource,
-  isProjectUserNotFoundClientError,
-  isReleasePerspective,
-  isStudioConfig,
-  omitProperty,
-  parseQueryKey,
-  parseUsersKey,
-  pickProperties,
-  removeSubscription,
-  resolveQuery,
-  setAuthToken,
-  setCleanupTimeout,
-  setUsersData,
-  setUsersError,
-  transformProjectionToPreview,
-  updateLastLoadMoreRequest
-};
-//# sourceMappingURL=createGroqSearchFilter.js.map