@sanity/sdk 2.8.0 → 2.10.0

package/dist/_chunks-es/createGroqSearchFilter.js

@@ -0,0 +1,1537 @@
+import { createClient, CorsOriginError } from "@sanity/client";
+import { Observable, map, distinctUntilChanged, shareReplay, skip, defer, finalize, filter, exhaustMap, timer, switchMap, takeWhile, from, firstValueFrom, EMPTY, fromEvent, catchError, NEVER, first, race, startWith, pairwise, mergeMap, groupBy, of, combineLatest, tap, share } from "rxjs";
+import { createSelector } from "reselect";
+import { createImageUrlBuilder } from "@sanity/image-url";
+import { devtools } from "zustand/middleware";
+import { createStore } from "zustand/vanilla";
+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 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 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: 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();
+  });
+}
+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 delay = getNextRefreshDelay(storageArea, storageKey);
+        delay > 0 && await new Promise((resolve) => setTimeout(resolve, delay));
+        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",
+        tag: "users.get-current"
+      })
+    )
+  ).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 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";
+}
+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 {
+      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 {
+      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 = 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;
+  if (token) {
+    if (currentAuthState.type !== AuthStateType.LOGGED_IN || currentAuthState.token !== 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 && 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
+});
+const 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 resource;
+    options.resource && (isDatasetResource(options.resource) ? resource = {
+      type: "dataset",
+      id: `${options.resource.projectId}.${options.resource.dataset}`
+    } : isMediaLibraryResource(options.resource) ? resource = { type: "media-library", id: options.resource.mediaLibraryId } : isCanvasResource(options.resource) && (resource = { type: "canvas", id: options.resource.canvasId }));
+    const projectId = options.projectId ?? instance.config.projectId, dataset = options.dataset ?? instance.config.dataset, 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 && ((options.projectId || options.dataset) && console.warn(
+      "Both resource and explicit projectId/dataset are provided. The resource 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))
+);
+var clientStore$1 = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  getClient,
+  getClientState
+});
+function setCleanupTimeout(fn, delay) {
+  const timer2 = setTimeout(fn, delay), t = timer2;
+  return typeof t == "object" && t !== null && "unref" in t && typeof t.unref == "function" && t.unref(), timer2;
+}
+const 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: 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: [] } } };
+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;
+  });
+}
+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 = bindActionByResource(
+  releasesStore,
+  createStateSourceAction({
+    selector: ({ state }, _) => state.activeReleases
+  })
+), getActiveReleasesState = (instance, options) => (
+  // bindActionByResource keyFn destructures { resource } from the first param, so pass {} when no options
+  _getActiveReleasesState(instance, options ?? {})
+), RELEASES_QUERY = "releases::all()", subscribeToReleases = ({
+  instance,
+  state,
+  key: { resource }
+}) => {
+  const { observable: releases$ } = getQueryState(instance, {
+    query: RELEASES_QUERY,
+    perspective: "raw",
+    resource: resource && !isDatasetResource(resource) ? resource : void 0,
+    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 = (instance, ...rest) => (_boundGetPerspectiveState || (_boundGetPerspectiveState = bindActionByResource(
+  releasesStore,
+  _getPerspectiveStateSelector
+)), _boundGetPerspectiveState(instance, ...rest.length ? rest : [{}])), 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) };
+}, cancelQuery = (key) => (prev) => {
+  const prevQuery = prev.queries[key];
+  return !prevQuery || prevQuery.subscribers.length ? prev : { ...prev, queries: omitProperty(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(/* @__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
+        }).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
+            })
+          )
+        );
+      }),
+      catchError((error) => (state.set("setQueryError", setQueryError(group$.key, error)), EMPTY)),
+      tap(({ result, syncTags }) => {
+        state.set("setQueryData", setQueryData(group$.key, result, syncTags));
+      })
+    )
+  )
+).subscribe({ error: errorHandler(state) }), listenToLiveClientAndSetLastLiveEventIds = ({
+  state,
+  instance,
+  key: { resource }
+}) => {
+  const liveMessages$ = getClientState(instance, {
+    apiVersion: QUERY_STORE_API_VERSION,
+    // temporary guard here until we're ready for everything to be queried via global api
+    ...resource && !isDatasetResource(resource) ? { resource } : {}
+  }).observable.pipe(
+    switchMap(
+      (client) => defer(
+        () => client.live.events({ includeDrafts: !!client.config().token, tag: "query-store" })
+      ).pipe(
+        catchError((error) => {
+          if (error instanceof CorsOriginError)
+            return state.set("setError", { error }), EMPTY;
+          throw error;
+        })
+      )
+    ),
+    share(),
+    filter((e) => e.type === "message")
+  );
+  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), 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("cancelQuery", cancelQuery(key)), error;
+      })
+    ) : NEVER;
+    state.set("initializeQuery", initializeQuery(key));
+    const resolved$ = state.observable.pipe(
+      map(getCurrent),
+      first((i) => i !== void 0)
+    );
+    return firstValueFrom(race([resolved$, aborted$]));
+  }
+), 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
+}`, API_VERSION = "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,
+    // TODO: remove in v3 when we're ready for everything to be queried via resource
+    resource: resource && !isDatasetResource(resource) ? resource : void 0
+  });
+  return {
+    title: String(title || `${projectionResult._type}: ${projectionResult._id}`),
+    subtitle: subtitle || void 0,
+    media: normalizeMedia(projectionResult.media, client),
+    ...projectionResult._status && { _status: projectionResult._status }
+  };
+}
+const 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$1 as API_VERSION,
+  AuthStateType,
+  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,
+  defineStore,
+  getActiveReleasesState,
+  getAuthCode,
+  getAuthState,
+  getCleanedUrl,
+  getClient,
+  getClientErrorApiBody,
+  getClientErrorApiDescription,
+  getClientErrorApiType,
+  getClientState,
+  getCurrentUserState,
+  getDashboardOrganizationId,
+  getDefaultLocation,
+  getEnv,
+  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