@sanity/sdk 0.0.0-chore-react-18-compat.1 → 0.0.0-chore-react-18-compat.3

package/dist/index.js

@@ -1,17 +1,63 @@
 import { createClient } from "@sanity/client";
-import { Observable, share, map, distinctUntilChanged, skip, filter, switchMap, interval, takeWhile, fromEvent, EMPTY, defer, firstValueFrom, from, asapScheduler, concatMap, of, withLatestFrom, concat, timer, throwError, first as first$1, partition, merge, shareReplay, Subject, tap as tap$1, catchError as catchError$1, startWith as startWith$1, pairwise as pairwise$1, groupBy as groupBy$1, mergeMap as mergeMap$1, throttle, race, combineLatest, debounceTime, NEVER } from "rxjs";
+import { Observable, share, map, distinctUntilChanged, skip, filter, switchMap, timer, from, takeWhile, firstValueFrom, fromEvent, EMPTY, defer, asapScheduler, concatMap, of, withLatestFrom, concat, throwError, first as first$1, Subject, takeUntil, partition, merge, shareReplay, tap as tap$1, catchError as catchError$1, startWith as startWith$1, pairwise as pairwise$1, groupBy as groupBy$1, mergeMap as mergeMap$1, throttle, race, NEVER, combineLatest, debounceTime, Subscription } from "rxjs";
 import { devtools } from "zustand/middleware";
-import { createStore as createStore$1 } from "zustand/vanilla";
-import { createSelector } from "reselect";
-import { isEqual, omit, isObject, noop } from "lodash-es";
+import { createStore } from "zustand/vanilla";
+import { pick, isEqual, omit, isObject } from "lodash-es";
 import { createController, createNode } from "@sanity/comlink";
 import { first, switchMap as switchMap$1, groupBy, mergeMap, startWith, pairwise, filter as filter$1, map as map$1, delay, tap, catchError, scan } from "rxjs/operators";
 import { SanityEncoder } from "@sanity/mutate";
 import { getPublishedId as getPublishedId$1 } from "@sanity/client/csm";
+import { createSelector } from "reselect";
 import { applyPatches, parsePatch, makePatches, stringifyPatches } from "@sanity/diff-match-patch";
 import { isKeySegment, isKeyedObject } from "@sanity/types";
 import { createDocumentLoaderFromClient } from "@sanity/mutate/_unstable_store";
 var AuthStateType = /* @__PURE__ */ ((AuthStateType2) => (AuthStateType2.LOGGED_IN = "logged-in", AuthStateType2.LOGGING_IN = "logging-in", AuthStateType2.ERROR = "error", AuthStateType2.LOGGED_OUT = "logged-out", AuthStateType2))(AuthStateType || {});
+function getPublishedId(id) {
+  const draftsPrefix = "drafts.";
+  return id.startsWith(draftsPrefix) ? id.slice(draftsPrefix.length) : id;
+}
+function getDraftId(id) {
+  const draftsPrefix = "drafts.";
+  return id.startsWith(draftsPrefix) ? id : `${draftsPrefix}${id}`;
+}
+function insecureRandomId() {
+  return Array.from({ length: 16 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
+}
+function createSanityInstance(config = {}) {
+  const instanceId = crypto.randomUUID(), disposeListeners = /* @__PURE__ */ new Map(), disposed = { current: !1 }, instance = {
+    instanceId,
+    config,
+    isDisposed: () => disposed.current,
+    dispose: () => {
+      disposed.current || (disposed.current = !0, disposeListeners.forEach((listener) => listener()), disposeListeners.clear());
+    },
+    onDispose: (cb) => {
+      const listenerId = insecureRandomId();
+      return disposeListeners.set(listenerId, cb), () => {
+        disposeListeners.delete(listenerId);
+      };
+    },
+    getParent: () => {
+    },
+    createChild: (next) => Object.assign(
+      createSanityInstance({
+        ...config,
+        ...next,
+        ...config.auth === next.auth ? config.auth : config.auth && next.auth && { auth: { ...config.auth, ...next.auth } }
+      }),
+      { getParent: () => instance }
+    ),
+    match: (targetConfig) => {
+      if (Object.entries(pick(targetConfig, "auth", "projectId", "dataset")).every(
+        ([key, value]) => config[key] === value
+      ))
+        return instance;
+      const parent = instance.getParent();
+      if (parent) return parent.match(targetConfig);
+    }
+  };
+  return instance;
+}
 function getEnv(key) {
   if (typeof import.meta < "u" && import.meta.env)
     return import.meta.env[key];
@@ -20,68 +66,78 @@ function getEnv(key) {
   if (typeof window < "u" && window.ENV)
     return window.ENV?.[key];
 }
-const resourceCache = /* @__PURE__ */ new WeakMap();
-function createResourceState(initialState, devToolsOptions) {
-  const store = createStore$1()(devtools(() => initialState, devToolsOptions));
+function createStoreState(initialState, devToolsOptions) {
+  const store = createStore()(devtools(() => initialState, devToolsOptions));
   return {
     get: store.getState,
     set: (actionKey, updatedState) => {
-      store.getState() !== updatedState && store.setState(updatedState, !1, actionKey);
+      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());
-      return emit(), store.subscribe(emit);
+      emit();
+      const unsubscribe = store.subscribe(emit);
+      return () => unsubscribe();
     })
   };
 }
-function initializeResource(instance, resource) {
-  const fullName = resource.name === "Auth" ? "Auth-global" : `${resource.name}-${instance.identity.resourceId}`, initialState = resource.getInitialState(instance), state = createResourceState(initialState, {
-    name: fullName,
-    enabled: !!getEnv("DEV")
-  }), dispose = resource.initialize?.call({ instance, state }, instance) ?? (() => {
-  });
-  return { state, dispose };
-}
-function getOrCreateResource(instance, resource) {
-  const fullName = resource.name === "Auth" ? "Auth-global" : `${resource.name}-${instance.identity.resourceId}`;
-  resourceCache.has(instance.identity) || resourceCache.set(instance.identity, /* @__PURE__ */ new Map());
-  const initializedResources = resourceCache.get(instance.identity), cached = initializedResources.get(fullName);
-  if (cached) return cached;
-  const result = initializeResource(instance, resource);
-  return initializedResources.set(fullName, result), result;
-}
-function disposeResources(identity) {
-  const resources = resourceCache.get(identity);
-  if (resources)
-    for (const resource of resources.values())
-      resource.dispose();
-}
-function createAction(resource, actionDefinition) {
-  return (dependencies, ...args) => {
-    const instance = "state" in dependencies ? dependencies.instance : dependencies, { state } = "state" in dependencies ? dependencies : getOrCreateResource(dependencies, resource), actionContext = { instance, state };
-    return actionDefinition(actionContext).bind(actionContext)(...args);
+function createStoreInstance(instance, { name, getInitialState, initialize }) {
+  const state = createStoreState(getInitialState(instance), {
+    enabled: !!getEnv("DEV"),
+    name: `${name}-${instance.config.projectId}.${instance.config.dataset}`
+  }), dispose = initialize?.({ state, instance }), disposed = { current: !1 };
+  return {
+    state,
+    dispose: () => {
+      disposed.current || (disposed.current = !0, dispose?.());
+    },
+    isDisposed: () => disposed.current
   };
 }
-function createInternalAction(actionDefinition) {
-  return (actionContext, ...args) => actionDefinition(actionContext).bind(actionContext)(...args);
+function createActionBinder(keyFn) {
+  const instanceRegistry = /* @__PURE__ */ new Map(), storeRegistry = /* @__PURE__ */ new Map();
+  return function(storeDefinition, action) {
+    return function(instance, ...params) {
+      const keySuffix = keyFn(instance.config), compositeKey = storeDefinition.name + (keySuffix ? `:${keySuffix}` : "");
+      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, storeDefinition), storeRegistry.set(compositeKey, storeInstance)), action({ instance, state: storeInstance.state }, ...params);
+    };
+  };
 }
-function createStateSourceAction(resource, options) {
-  const selector = typeof options == "function" ? options : options.selector, subscribeHandler = options && "onSubscribe" in options ? options.onSubscribe : void 0, isEqual2 = options && "isEqual" in options ? options.isEqual ?? Object.is : Object.is;
-  return createAction(resource, ({ state }) => function(...args) {
-    const getCurrent = () => selector(state.get(), ...args), subscribe = (onStoreChanged) => {
-      const cleanup = subscribeHandler?.(this, ...args), subscription = state.observable.pipe(
+const bindActionByDataset = createActionBinder(({ projectId, dataset }) => {
+  if (!projectId || !dataset)
+    throw new Error("This API requires a project ID and dataset configured.");
+  return `${projectId}.${dataset}`;
+}), bindActionGlobally = createActionBinder(() => "global");
+function createStateSourceAction(options) {
+  const selector = typeof options == "function" ? options : options.selector, subscribeHandler = options && "onSubscribe" in options ? options.onSubscribe : void 0, isEqual2 = options && "isEqual" in options ? options.isEqual ?? Object.is : Object.is, selectorContextCache = /* @__PURE__ */ new WeakMap();
+  function stateSourceAction(context, ...params) {
+    const { state, instance } = context, getCurrent = () => {
+      const currentState = state.get();
+      if (typeof currentState != "object" || currentState === null)
+        throw new Error(
+          `Expected store state to be an object but got "${typeof currentState}" instead`
+        );
+      let instanceCache = selectorContextCache.get(currentState);
+      instanceCache || (instanceCache = /* @__PURE__ */ new WeakMap(), selectorContextCache.set(currentState, instanceCache));
+      let selectorContext = instanceCache.get(instance);
+      return selectorContext || (selectorContext = { state: currentState, instance }, instanceCache.set(instance, selectorContext)), selector(selectorContext, ...params);
+    }, subscribe = (onStoreChanged) => {
+      const cleanup = subscribeHandler?.(context, ...params), subscription = state.observable.pipe(
+        // Derive value from current state
         map(getCurrent),
+        // Filter unchanged values using custom equality check
         distinctUntilChanged(isEqual2),
-        // skip the first emission because we only want to emit when the
-        // value changes. `distinctUntilChanged` will always emit the first
-        // the first value so we skip this emission
+        // Skip initial emission since we only want changes
         skip(1)
       ).subscribe({
         next: () => onStoreChanged?.(),
-        // the convention is to have the selector throw the error so we
-        // invoke onStoreChanged on error as well. this will cause the
-        // observable code path below to emit an error because the selector
-        // will throw and that will be used to emit an .error on the observer
+        // Propagate selector errors to both subscription types
         error: () => onStoreChanged?.()
       });
       return () => {
@@ -102,96 +158,144 @@ function createStateSourceAction(resource, options) {
       subscribe,
       observable
     };
-  });
+  }
+  return stateSourceAction;
 }
-const DEFAULT_BASE = "http://localhost", AUTH_CODE_PARAM = "sid", DEFAULT_API_VERSION$1 = "2021-06-07", REQUEST_TAG_PREFIX = "sanity.sdk.auth", refreshStampedToken = createInternalAction(
-  ({ state }) => {
-    const { clientFactory, apiHost, storageArea, storageKey } = state.get().options, refreshToken$ = state.observable.pipe(
-      map(({ authState }) => authState),
-      filter(
-        (authState) => authState.type === AuthStateType.LOGGED_IN
-      ),
-      distinctUntilChanged(),
-      filter((authState) => authState.token.includes("-st")),
-      // Ensure we only try to refresh stamped tokens
-      switchMap(
-        (authState) => interval(10 * 60 * 1e3).pipe(
-          takeWhile(() => state.get().authState.type === AuthStateType.LOGGED_IN),
-          map(() => authState.token),
-          distinctUntilChanged(),
-          map(
-            (token) => clientFactory({
-              apiVersion: DEFAULT_API_VERSION$1,
-              requestTagPrefix: "sdk.token-refresh",
-              useProjectHostname: !1,
-              token,
-              ignoreBrowserTokenWarning: !0,
-              ...apiHost && { apiHost }
-            })
-          ),
-          switchMap(
-            (client) => client.observable.request({
-              uri: "auth/refresh-token",
-              method: "POST",
-              body: {
-                token: authState.token
-              }
-            })
-          )
-        )
-      )
-    );
-    return function() {
-      return refreshToken$.subscribe({
-        next: (response) => {
-          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 }));
-        },
-        error: (error) => {
-          state.set("setRefreshStampedTokenError", { authState: { type: AuthStateType.ERROR, error } });
-        }
-      });
-    };
+const DEFAULT_BASE = "http://localhost", AUTH_CODE_PARAM = "sid", DEFAULT_API_VERSION$1 = "2021-06-07", REQUEST_TAG_PREFIX = "sanity.sdk.auth", REFRESH_INTERVAL = 12 * 60 * 60 * 1e3, LOCK_NAME = "sanity-token-refresh-lock";
+function getLastRefreshTime(storageArea, storageKey) {
+  try {
+    const data = storageArea?.getItem(`${storageKey}_last_refresh`);
+    return data ? parseInt(data, 10) : 0;
+  } catch {
+    return 0;
   }
-), subscribeToStateAndFetchCurrentUser = createInternalAction(
-  ({ state }) => {
-    const { clientFactory, apiHost } = state.get().options, currentUser$ = state.observable.pipe(
-      map(({ authState }) => authState),
-      filter(
-        (authState) => authState.type === AuthStateType.LOGGED_IN && !authState.currentUser
-      ),
-      map((authState) => authState.token),
-      distinctUntilChanged()
-    ).pipe(
-      map(
-        (token) => clientFactory({
-          apiVersion: DEFAULT_API_VERSION$1,
-          requestTagPrefix: REQUEST_TAG_PREFIX,
-          token,
-          ignoreBrowserTokenWarning: !0,
-          useProjectHostname: !1,
-          ...apiHost && { apiHost }
-        })
-      ),
-      switchMap(
-        (client) => client.observable.request({ uri: "/users/me", method: "GET" })
-      )
-    );
-    return function() {
-      return currentUser$.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 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: "sdk.token-refresh",
+      useProjectHostname: !1,
+      token,
+      ignoreBrowserTokenWarning: !0,
+      ...apiHost && { apiHost }
+    }).observable.request({
+      uri: "auth/refresh-token",
+      method: "POST",
+      body: {
+        token
+      }
+    }).subscribe(subscriber);
+    return () => subscription.unsubscribe();
+  });
+}
+async function acquireTokenRefreshLock(refreshFn, storageArea, storageKey) {
+  if (!navigator.locks)
+    return !0;
+  try {
+    return await navigator.locks.request(LOCK_NAME, { mode: "exclusive" }, async (lock) => {
+      if (!lock) return !1;
+      for (; ; ) {
+        const delay2 = getNextRefreshDelay(storageArea, storageKey);
+        delay2 > 0 && await new Promise((resolve) => setTimeout(resolve, delay2)), await refreshFn(), setLastRefreshTime(storageArea, storageKey), await new Promise((resolve) => setTimeout(resolve, REFRESH_INTERVAL));
+      }
+    }) === !0;
+  } catch {
+    return !1;
+  }
+}
+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(),
+    filter((storeState) => storeState.authState.token.includes("-st")),
+    // Ensure we only try to refresh stamped tokens
+    switchMap((storeState) => {
+      const performRefresh = async () => {
+        const response = await firstValueFrom(
+          createTokenRefreshStream(storeState.authState.token, 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 ? timer(0, REFRESH_INTERVAL).pipe(
+        takeWhile(() => storeState.authState.type === AuthStateType.LOGGED_IN),
+        switchMap(
+          () => createTokenRefreshStream(storeState.authState.token, clientFactory, apiHost)
+        )
+      ) : from(acquireTokenRefreshLock(performRefresh, storageArea, storageKey)).pipe(
+        filter((hasLock) => hasLock),
+        // This observable will never emit after the first value
+        // because acquireTokenRefreshLock handles the refresh loop internally
+        map(() => ({ token: storeState.authState.token }))
+      );
+    })
+  ).subscribe({
+    next: (response) => {
+      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 }));
+    },
+    error: (error) => {
+      state.set("setRefreshStampedTokenError", { authState: { type: AuthStateType.ERROR, error } });
+    }
+  });
+}, subscribeToStateAndFetchCurrentUser = ({
+  state
+}) => {
+  const { clientFactory, apiHost } = state.get().options;
+  return state.observable.pipe(
+    map(({ authState }) => authState),
+    filter(
+      (authState) => authState.type === AuthStateType.LOGGED_IN && !authState.currentUser
+    ),
+    map((authState) => authState.token),
+    distinctUntilChanged()
+  ).pipe(
+    map(
+      (token) => clientFactory({
+        apiVersion: DEFAULT_API_VERSION$1,
+        requestTagPrefix: REQUEST_TAG_PREFIX,
+        token,
+        ignoreBrowserTokenWarning: !0,
+        useProjectHostname: !1,
+        ...apiHost && { apiHost }
+      })
+    ),
+    switchMap(
+      (client) => client.observable.request({ uri: "/users/me", method: "GET" })
+    )
+  ).subscribe({
+    next: (currentUser) => {
+      state.set("setCurrentUser", (prev) => ({
+        authState: prev.authState.type === AuthStateType.LOGGED_IN ? { ...prev.authState, currentUser } : prev.authState
+      }));
+    },
+    error: (error) => {
+      state.set("setError", { authState: { type: AuthStateType.ERROR, error } });
+    }
+  });
+};
 function getAuthCode(callbackUrl, locationHref) {
   const loc = new URL(locationHref, DEFAULT_BASE), callbackLocation = callbackUrl ? new URL(callbackUrl, DEFAULT_BASE) : void 0, callbackLocationMatches = callbackLocation ? loc.pathname.toLowerCase().startsWith(callbackLocation.pathname.toLowerCase()) : !0, authCode = new URLSearchParams(loc.hash.slice(1)).get(AUTH_CODE_PARAM) || new URLSearchParams(loc.search).get(AUTH_CODE_PARAM);
   return authCode && callbackLocationMatches ? authCode : null;
@@ -226,24 +330,22 @@ function getDefaultLocation() {
     return DEFAULT_BASE;
   }
 }
-const subscribeToStorageEventsAndSetToken = createInternalAction(
-  ({ state }) => {
-    const { storageArea, storageKey } = state.get().options, tokenFromStorage$ = defer(getStorageEvents).pipe(
-      filter(
-        (e3) => e3.storageArea === storageArea && e3.key === storageKey
-      ),
-      map(() => getTokenFromStorage(storageArea, storageKey)),
-      distinctUntilChanged()
-    );
-    return function() {
-      return tokenFromStorage$.subscribe((token) => {
-        state.set("updateTokenFromStorageEvent", {
-          authState: token ? { type: AuthStateType.LOGGED_IN, token, currentUser: null } : { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }
-        });
-      });
-    };
-  }
-);
+const subscribeToStorageEventsAndSetToken = ({
+  state
+}) => {
+  const { storageArea, storageKey } = state.get().options;
+  return defer(getStorageEvents).pipe(
+    filter(
+      (e3) => e3.storageArea === storageArea && e3.key === storageKey
+    ),
+    map(() => getTokenFromStorage(storageArea, storageKey)),
+    distinctUntilChanged()
+  ).subscribe((token) => {
+    state.set("updateTokenFromStorageEvent", {
+      authState: token ? { type: AuthStateType.LOGGED_IN, token, currentUser: null } : { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }
+    });
+  });
+};
 let tokenRefresherRunning = !1;
 const authStore = {
   name: "Auth",
@@ -257,12 +359,20 @@ const authStore = {
       initialLocationHref = getDefaultLocation(),
       storageArea = getDefaultStorage()
     } = instance.config.auth ?? {}, storageKey = "__sanity_auth_token";
+    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", initialLocationHref), loginUrl.searchParams.set("type", "stampedToken"), loginUrl.searchParams.set("withSid", "true");
     let authState;
     const token = getTokenFromStorage(storageArea, storageKey);
     return providedToken ? authState = { type: AuthStateType.LOGGED_IN, token: providedToken, currentUser: null } : getAuthCode(callbackUrl, initialLocationHref) ? authState = { type: AuthStateType.LOGGING_IN, isExchangingToken: !1 } : token ? authState = { type: AuthStateType.LOGGED_IN, token, currentUser: null } : authState = { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }, {
       authState,
       options: {
         apiHost,
+        loginUrl: loginUrl.toString(),
         callbackUrl,
         customProviders,
         providedToken,
@@ -273,61 +383,36 @@ const authStore = {
       }
     };
   },
-  initialize() {
-    const stateSubscription = subscribeToStateAndFetchCurrentUser(this);
-    let storageEventsSubscription;
-    this.state.get().options?.storageArea && (storageEventsSubscription = subscribeToStorageEventsAndSetToken(this));
-    let refreshStampedTokenSubscription;
-    return tokenRefresherRunning || (tokenRefresherRunning = !0, refreshStampedTokenSubscription = refreshStampedToken(this)), () => {
-      stateSubscription.unsubscribe(), storageEventsSubscription?.unsubscribe(), refreshStampedTokenSubscription?.unsubscribe();
+  initialize(context) {
+    const subscriptions = [];
+    return subscriptions.push(subscribeToStateAndFetchCurrentUser(context)), context.state.get().options?.storageArea && subscriptions.push(subscribeToStorageEventsAndSetToken(context)), tokenRefresherRunning || (tokenRefresherRunning = !0, subscriptions.push(refreshStampedToken(context))), () => {
+      for (const subscription of subscriptions)
+        subscription.unsubscribe();
     };
   }
-}, getCurrentUserState = createStateSourceAction(
+}, getCurrentUserState = bindActionGlobally(
   authStore,
-  ({ authState }) => authState.type === AuthStateType.LOGGED_IN ? authState.currentUser : null
-), getTokenState = createStateSourceAction(
+  createStateSourceAction(
+    ({ state: { authState } }) => authState.type === AuthStateType.LOGGED_IN ? authState.currentUser : null
+  )
+), getTokenState = bindActionGlobally(
   authStore,
-  ({ authState }) => authState.type === AuthStateType.LOGGED_IN ? authState.token : null
-), getLoginUrlsState = createStateSourceAction(
+  createStateSourceAction(
+    ({ state: { authState } }) => authState.type === AuthStateType.LOGGED_IN ? authState.token : null
+  )
+), getLoginUrlState = bindActionGlobally(
   authStore,
-  ({ providers }) => providers ?? null
-), getAuthState = createStateSourceAction(authStore, ({ authState }) => authState), getDashboardOrganizationId = createStateSourceAction(
+  createStateSourceAction(({ state: { options } }) => options.loginUrl)
+), getAuthState = bindActionGlobally(
   authStore,
-  ({ dashboardContext }) => dashboardContext?.orgId
-), fetchLoginUrls = createAction(authStore, ({ state }) => {
-  const { callbackUrl, clientFactory, apiHost, customProviders } = state.get().options, client = clientFactory({
-    apiVersion: DEFAULT_API_VERSION$1,
-    requestTagPrefix: REQUEST_TAG_PREFIX,
-    useProjectHostname: !1,
-    ...apiHost && { apiHost }
-  });
-  return async function() {
-    const cachedProviders = state.get().providers;
-    if (cachedProviders) return cachedProviders;
-    const { providers: defaultProviders } = await client.request({
-      uri: "/auth/providers",
-      tag: "fetch-providers"
-    });
-    let providers;
-    if (typeof customProviders == "function")
-      providers = await customProviders(defaultProviders);
-    else if (!customProviders?.length)
-      providers = defaultProviders;
-    else {
-      const customProviderUrls = new Set(customProviders.map((p2) => p2.url));
-      providers = defaultProviders.filter((official) => !customProviderUrls.has(official.url)).concat(customProviders);
-    }
-    const configuredProviders = providers.map((provider) => {
-      const url = new URL(provider.url), origin = new URL(
-        callbackUrl ? new URL(callbackUrl, new URL(getDefaultLocation()).origin).toString() : getDefaultLocation()
-      ), hashParams = new URLSearchParams(origin.hash.slice(1));
-      return hashParams.delete("sid"), origin.hash = hashParams.toString(), origin.searchParams.delete("sid"), origin.searchParams.delete("url"), origin.searchParams.delete("error"), url.searchParams.set("origin", origin.toString()), url.searchParams.set("withSid", "true"), url.searchParams.set("type", "stampedToken"), { ...provider, url: url.toString() };
-    });
-    return state.set("fetchedLoginUrls", { providers: configuredProviders }), configuredProviders;
-  };
-}), handleAuthCallback = createAction(authStore, ({ state }) => {
-  const { providedToken, callbackUrl, clientFactory, apiHost, storageArea, storageKey } = state.get().options;
-  return async function(locationHref = getDefaultLocation()) {
+  createStateSourceAction(({ state: { authState } }) => authState)
+), getDashboardOrganizationId = bindActionGlobally(
+  authStore,
+  createStateSourceAction(({ state: { dashboardContext } }) => dashboardContext?.orgId)
+), handleAuthCallback = bindActionGlobally(
+  authStore,
+  async ({ state }, locationHref = getDefaultLocation()) => {
+    const { providedToken, callbackUrl, clientFactory, apiHost, storageArea, storageKey } = state.get().options;
     if (providedToken) return !1;
     const { authState } = state.get();
     if (authState.type === AuthStateType.LOGGING_IN && authState.isExchangingToken) return !1;
@@ -364,35 +449,403 @@ const authStore = {
     } catch (error) {
       return state.set("exchangeSessionForTokenError", { authState: { type: AuthStateType.ERROR, error } }), !1;
     }
+  }
+), logout = bindActionGlobally(authStore, async ({ state }) => {
+  const { clientFactory, apiHost, providedToken, storageArea, storageKey } = state.get().options;
+  if (providedToken) return;
+  const { authState } = state.get();
+  if (authState.type === AuthStateType.LOGGED_OUT && authState.isDestroyingSession) return;
+  const token = authState.type === AuthStateType.LOGGED_IN && authState.token;
+  try {
+    token && (state.set("loggingOut", {
+      authState: { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !0 }
+    }), await clientFactory({
+      token,
+      requestTagPrefix: REQUEST_TAG_PREFIX,
+      apiVersion: DEFAULT_API_VERSION$1,
+      ...apiHost && { apiHost },
+      useProjectHostname: !1
+    }).request({ uri: "/auth/logout", method: "POST" }));
+  } finally {
+    state.set("logoutSuccess", {
+      authState: { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }
+    }), storageArea?.removeItem(storageKey);
+  }
+}), 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
+}), 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);
+    return () => subscription.unsubscribe();
+  }
+}, listenToToken = ({ instance, state }) => getTokenState(instance).observable.subscribe((token) => {
+  state.set("setTokenAndResetClients", { token, clients: {} });
+}), getClientConfigKey = (options) => JSON.stringify(pick(options, ...allowedKeys)), getClient = bindActionGlobally(
+  clientStore,
+  ({ state, instance }, options) => {
+    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 { token, clients } = state.get(), projectId = options.projectId ?? instance.config.projectId, dataset = options.dataset ?? instance.config.dataset, apiHost = options.apiHost ?? instance.config.auth?.apiHost, effectiveOptions = {
+      ...DEFAULT_CLIENT_CONFIG,
+      ...(options.scope === "global" || !projectId) && { useProjectHostname: !1 },
+      ...token && { token },
+      ...options,
+      ...projectId && { projectId },
+      ...dataset && { dataset },
+      ...apiHost && { apiHost }
+    }, 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))
+), destroyController$1 = ({ state }) => {
+  const { controller } = state.get();
+  controller && (controller.destroy(), state.set("destroyController", {
+    controller: null,
+    channels: /* @__PURE__ */ new Map()
+  }));
+}, getOrCreateChannel$1 = ({ state }, options) => {
+  const controller = state.get().controller;
+  if (!controller)
+    throw new Error("Controller must be initialized before using or creating channels");
+  const channels = state.get().channels, existing = channels.get(options.name);
+  if (existing) {
+    if (!isEqual(existing.options, options))
+      throw new Error(`Channel "${options.name}" already exists with different options`);
+    return state.set("incrementChannelRefCount", {
+      channels: new Map(channels).set(options.name, {
+        ...existing,
+        refCount: existing.refCount + 1
+      })
+    }), existing.channel.start(), existing.channel;
+  }
+  const channel = controller.createChannel(options);
+  return channel.start(), state.set("createChannel", {
+    channels: new Map(channels).set(options.name, {
+      channel,
+      options,
+      refCount: 1
+    })
+  }), channel;
+}, getOrCreateController$1 = ({ state, instance }, targetOrigin) => {
+  const { controller, controllerOrigin } = state.get();
+  if (controller && controllerOrigin === targetOrigin)
+    return controller;
+  controller && destroyController$1({ state });
+  const newController = createController({ targetOrigin });
+  return state.set("initializeController", {
+    controllerOrigin: targetOrigin,
+    controller: newController
+  }), newController;
+}, releaseChannel$1 = ({ state }, name) => {
+  const channels = state.get().channels, channelEntry = channels.get(name);
+  if (channelEntry) {
+    const newRefCount = channelEntry.refCount === 0 ? 0 : channelEntry.refCount - 1;
+    newRefCount === 0 ? (channelEntry.channel.stop(), channels.delete(name), state.set("releaseChannel", { channels: new Map(channels) })) : state.set("releaseChannel", {
+      channels: new Map(channels).set(name, {
+        ...channelEntry,
+        refCount: newRefCount
+      })
+    });
+  }
+}, comlinkControllerStore = {
+  name: "connectionStore",
+  getInitialState: () => ({
+    controller: null,
+    controllerOrigin: null,
+    channels: /* @__PURE__ */ new Map()
+  }),
+  initialize({ instance }) {
+    return () => {
+      destroyController(instance);
+    };
+  }
+}, destroyController = bindActionGlobally(
+  comlinkControllerStore,
+  destroyController$1
+), getOrCreateChannel = bindActionGlobally(
+  comlinkControllerStore,
+  getOrCreateChannel$1
+), getOrCreateController = bindActionGlobally(
+  comlinkControllerStore,
+  getOrCreateController$1
+), releaseChannel = bindActionGlobally(comlinkControllerStore, releaseChannel$1), getOrCreateNode$1 = ({ state }, options) => {
+  const nodes = state.get().nodes, existing = nodes.get(options.name);
+  if (existing) {
+    if (!isEqual(existing.options, options))
+      throw new Error(`Node "${options.name}" already exists with different options`);
+    return state.set("incrementNodeRefCount", {
+      nodes: new Map(nodes).set(options.name, {
+        ...existing,
+        refCount: existing.refCount + 1
+      })
+    }), existing.node.start(), existing.node;
+  }
+  const node = createNode(options);
+  return node.start(), nodes.set(options.name, { node, options, refCount: 1 }), state.set("createNode", { nodes }), node;
+}, releaseNode$1 = ({ state }, name) => {
+  const nodes = state.get().nodes, nodeEntry = nodes.get(name);
+  if (nodeEntry) {
+    const newRefCount = nodeEntry.refCount === 0 ? 0 : nodeEntry.refCount - 1;
+    newRefCount === 0 ? (nodeEntry.node.stop(), nodes.delete(name), state.set("releaseNode", { nodes: new Map(nodes) })) : state.set("releaseNode", {
+      nodes: new Map(nodes).set(name, {
+        ...nodeEntry,
+        refCount: newRefCount
+      })
+    });
+  }
+}, comlinkNodeStore = {
+  name: "nodeStore",
+  getInitialState: () => ({
+    nodes: /* @__PURE__ */ new Map()
+  }),
+  initialize({ state }) {
+    return () => {
+      state.get().nodes.forEach(({ node }) => {
+        node.stop();
+      });
+    };
+  }
+}, releaseNode = bindActionGlobally(comlinkNodeStore, releaseNode$1), getOrCreateNode = bindActionGlobally(comlinkNodeStore, getOrCreateNode$1);
+function createFetcherStore({
+  name,
+  fetcher: getObservable,
+  getKey,
+  fetchThrottleInternal = 1e3,
+  stateExpirationDelay = 5e3
+}) {
+  const store = {
+    name,
+    getInitialState: () => ({
+      stateByParams: {}
+    }),
+    initialize: (context) => {
+      const subscription = subscribeToSubscriptionsAndFetch(context);
+      return () => subscription.unsubscribe();
+    }
+  }, subscribeToSubscriptionsAndFetch = ({
+    state
+  }) => state.observable.pipe(
+    // Map the state to an array of [serialized, entry] pairs.
+    switchMap$1((s2) => {
+      const entries = Object.entries(s2.stateByParams);
+      return entries.length > 0 ? from(entries) : EMPTY;
+    }),
+    // Group by the serialized key.
+    groupBy(([key]) => key),
+    mergeMap(
+      (group$) => group$.pipe(
+        // Emit an initial value for pairwise comparisons.
+        startWith([group$.key, void 0]),
+        pairwise(),
+        // Trigger only when the subscriptions array grows.
+        filter$1(([[, prevEntry], [, currEntry]]) => {
+          const prevSubs = prevEntry?.subscriptions ?? [];
+          return (currEntry?.subscriptions ?? []).length > prevSubs.length;
+        }),
+        map$1(([, [, currEntry]]) => currEntry),
+        // Only trigger if we haven't fetched recently.
+        filter$1((entry) => {
+          const lastFetch = entry?.lastFetchInitiatedAt;
+          return lastFetch ? Date.now() - new Date(lastFetch).getTime() >= fetchThrottleInternal : !0;
+        }),
+        switchMap$1((entry) => entry ? (state.set("setLastFetchInitiatedAt", (prev) => ({
+          stateByParams: {
+            ...prev.stateByParams,
+            [entry.key]: {
+              ...entry,
+              ...prev.stateByParams[entry.key],
+              lastFetchInitiatedAt: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          }
+        })), getObservable(entry.instance)(...entry.params).pipe(
+          // the `createStateSourceAction` util requires the update
+          // to
+          delay(0, asapScheduler),
+          tap(
+            (data) => state.set("setData", (prev) => ({
+              stateByParams: {
+                ...prev.stateByParams,
+                [entry.key]: {
+                  ...omit(entry, "error"),
+                  ...omit(prev.stateByParams[entry.key], "error"),
+                  data
+                }
+              }
+            }))
+          ),
+          catchError((error) => (state.set("setError", (prev) => ({
+            stateByParams: {
+              ...prev.stateByParams,
+              [entry.key]: {
+                ...entry,
+                ...prev.stateByParams[entry.key],
+                error
+              }
+            }
+          })), EMPTY))
+        )) : EMPTY)
+      )
+    )
+  ).subscribe({
+    error: (error) => state.set("setError", { error })
+  }), getState = bindActionGlobally(
+    store,
+    createStateSourceAction({
+      selector: ({
+        instance,
+        state: { stateByParams, error }
+      }, ...params) => {
+        if (error) throw error;
+        const key = getKey(instance, ...params), entry = stateByParams[key];
+        if (entry?.error) throw entry.error;
+        return entry?.data;
+      },
+      onSubscribe: ({ instance, state }, ...params) => {
+        const subscriptionId = insecureRandomId(), key = getKey(instance, ...params);
+        return state.set("addSubscription", (prev) => ({
+          stateByParams: {
+            ...prev.stateByParams,
+            [key]: {
+              ...prev.stateByParams[key],
+              instance,
+              key,
+              params: prev.stateByParams[key]?.params || params,
+              subscriptions: [...prev.stateByParams[key]?.subscriptions || [], subscriptionId]
+            }
+          }
+        })), () => {
+          setTimeout(() => {
+            state.set("removeSubscription", (prev) => {
+              const entry = prev.stateByParams[key];
+              if (!entry) return prev;
+              const newSubs = (entry.subscriptions || []).filter((id) => id !== subscriptionId);
+              return newSubs.length === 0 ? { stateByParams: omit(prev.stateByParams, key) } : {
+                stateByParams: {
+                  ...prev.stateByParams,
+                  [key]: {
+                    ...entry,
+                    subscriptions: newSubs
+                  }
+                }
+              };
+            });
+          }, stateExpirationDelay);
+        };
+      }
+    })
+  ), resolveState = bindActionGlobally(
+    store,
+    ({ instance }, ...params) => firstValueFrom(getState(instance, ...params).observable.pipe(first((i2) => i2 !== void 0)))
+  );
+  return { getState, resolveState };
+}
+const API_VERSION$5 = "v2025-02-19", datasets = createFetcherStore({
+  name: "Datasets",
+  getKey: (instance, options) => {
+    const projectId = options?.projectId ?? instance.config.projectId;
+    if (!projectId)
+      throw new Error("A projectId is required to use the project API.");
+    return projectId;
+  },
+  fetcher: (instance) => (options) => getClientState(instance, {
+    apiVersion: API_VERSION$5,
+    // non-null assertion is fine because we check above
+    projectId: options?.projectId ?? instance.config.projectId,
+    useProjectHostname: !0
+  }).observable.pipe(switchMap((client) => client.observable.datasets.list()))
+}), getDatasetsState = datasets.getState, resolveDatasets = datasets.resolveState, isSanityMutatePatch = (value) => !(typeof value != "object" || !value || !("type" in value) || typeof value.type != "string" || value.type !== "patch" || !("id" in value) || typeof value.id != "string" || !("patches" in value) || !Array.isArray(value.patches));
+function createDocument(doc) {
+  return {
+    type: "document.create",
+    ...doc,
+    ...doc.documentId && { documentId: getPublishedId(doc.documentId) }
+  };
+}
+function deleteDocument(doc) {
+  return {
+    type: "document.delete",
+    ...doc,
+    documentId: getPublishedId(doc.documentId)
+  };
+}
+function convertSanityMutatePatch(sanityPatchMutation) {
+  return SanityEncoder.encode(sanityPatchMutation).map((i2) => {
+    const copy = { ...i2.patch };
+    return "id" in copy && delete copy.id, copy;
+  });
+}
+function editDocument(doc, patches) {
+  if (isSanityMutatePatch(patches)) {
+    const converted = convertSanityMutatePatch(patches) ?? [];
+    return {
+      ...doc,
+      type: "document.edit",
+      documentId: getPublishedId(doc.documentId),
+      patches: converted
+    };
+  }
+  return {
+    ...doc,
+    type: "document.edit",
+    documentId: getPublishedId(doc.documentId),
+    ...patches && { patches: Array.isArray(patches) ? patches : [patches] }
+  };
+}
+function publishDocument(doc) {
+  return {
+    type: "document.publish",
+    ...doc,
+    documentId: getPublishedId(doc.documentId)
+  };
+}
+function unpublishDocument(doc) {
+  return {
+    type: "document.unpublish",
+    ...doc,
+    documentId: getPublishedId(doc.documentId)
   };
-}), logout = createAction(authStore, ({ state }) => {
-  const { clientFactory, apiHost, providedToken, storageArea, storageKey } = state.get().options;
-  return async function() {
-    if (providedToken) return;
-    const { authState } = state.get();
-    if (authState.type === AuthStateType.LOGGED_OUT && authState.isDestroyingSession) return;
-    const token = authState.type === AuthStateType.LOGGED_IN && authState.token;
-    try {
-      token && (state.set("loggingOut", {
-        authState: { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !0 }
-      }), await clientFactory({
-        token,
-        requestTagPrefix: REQUEST_TAG_PREFIX,
-        apiVersion: DEFAULT_API_VERSION$1,
-        ...apiHost && { apiHost },
-        useProjectHostname: !1
-      }).request({ uri: "/auth/logout", method: "POST" }));
-    } finally {
-      state.set("logoutSuccess", {
-        authState: { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }
-      }), storageArea?.removeItem(storageKey);
-    }
+}
+function discardDocument(doc) {
+  return {
+    type: "document.discard",
+    ...doc,
+    documentId: getPublishedId(doc.documentId)
   };
-});
-function getResourceId(documentResourceId) {
-  if (documentResourceId)
-    return documentResourceId.split(":")[1];
 }
+const DOCUMENT_STATE_CLEAR_DELAY = 1e3, INITIAL_OUTGOING_THROTTLE_TIME = 1e3, API_VERSION$4 = "vX";
 function parseBracketContent(content) {
   const rangeMatch = content.match(/^(\d*):(\d*)$/);
   if (rangeMatch) {
@@ -635,447 +1088,77 @@ function ifRevisionID(input, revisionId) {
     );
   return input;
 }
-function isNonNullable(t2) {
-  return t2 != null;
-}
-const indexCache = /* @__PURE__ */ new WeakMap();
-function getIndexForKey(input, key) {
-  if (!Array.isArray(input)) return;
-  const cached = indexCache.get(input);
-  if (cached) return cached[key];
-  const lookup = input.reduce((acc, next, index) => (typeof next?._key == "string" && (acc[next._key] = index), acc), {});
-  return indexCache.set(input, lookup), lookup[key];
-}
-function getDeep(input, path) {
-  const [currentSegment, ...restOfPath] = path;
-  if (currentSegment === void 0) return input;
-  if (typeof input != "object" || input === null) return;
-  let key;
-  if (isKeySegment(currentSegment) ? key = getIndexForKey(input, currentSegment._key) : (typeof currentSegment == "string" || typeof currentSegment == "number") && (key = currentSegment), key === void 0) return;
-  const nestedInput = typeof key == "number" && Array.isArray(input) ? input.at(key) : input[key];
-  return getDeep(nestedInput, restOfPath);
-}
-function setDeep(input, path, value) {
-  const [currentSegment, ...restOfPath] = path;
-  if (currentSegment === void 0) return value;
-  if (typeof input != "object" || input === null) {
-    if (typeof currentSegment == "string")
-      return { [currentSegment]: setDeep(null, restOfPath, value) };
-    let index;
-    if (isKeySegment(currentSegment))
-      index = 0;
-    else if (typeof currentSegment == "number" && currentSegment >= 0)
-      index = currentSegment;
-    else
-      return input;
-    return [
-      // fill until index
-      ...Array.from({ length: index }).fill(null),
-      // then set deep here
-      setDeep(null, restOfPath, value)
-    ];
-  }
-  if (Array.isArray(input)) {
-    let index;
-    return isKeySegment(currentSegment) ? index = getIndexForKey(input, currentSegment._key) : typeof currentSegment == "number" && (index = currentSegment < 0 ? input.length + currentSegment : currentSegment), index === void 0 ? input : index in input ? input.map(
-      (nestedInput, i2) => i2 === index ? setDeep(nestedInput, restOfPath, value) : nestedInput
-    ) : [
-      ...input,
-      ...Array.from({ length: index - input.length }).fill(null),
-      setDeep(null, restOfPath, value)
-    ];
-  }
-  return typeof currentSegment == "object" ? input : currentSegment in input ? Object.fromEntries(
-    Object.entries(input).map(
-      ([key, nestedInput]) => key === currentSegment ? [key, setDeep(nestedInput, restOfPath, value)] : [key, nestedInput]
-    )
-  ) : { ...input, [currentSegment]: setDeep(null, restOfPath, value) };
-}
-function unsetDeep(input, path) {
-  const [currentSegment, ...restOfPath] = path;
-  if (currentSegment === void 0 || typeof input != "object" || input === null) return input;
-  let _segment;
-  if (isKeySegment(currentSegment) ? _segment = getIndexForKey(input, currentSegment._key) : (typeof currentSegment == "string" || typeof currentSegment == "number") && (_segment = currentSegment), _segment === void 0) return input;
-  let segment = _segment;
-  return typeof segment == "number" && Array.isArray(input) && (segment = segment < 0 ? input.length + segment : segment), segment in input ? restOfPath.length ? Array.isArray(input) ? input.map(
-    (nestedInput, index) => index === segment ? unsetDeep(nestedInput, restOfPath) : nestedInput
-  ) : Object.fromEntries(
-    Object.entries(input).map(
-      ([key, value]) => key === segment ? [key, unsetDeep(value, restOfPath)] : [key, value]
-    )
-  ) : Array.isArray(input) ? input.filter((_nestedInput, index) => index !== segment) : Object.fromEntries(Object.entries(input).filter(([key]) => key !== segment.toString())) : input;
-}
-const DEFAULT_API_VERSION = "2024-11-12", DEFAULT_REQUEST_TAG_PREFIX = "sanity.sdk", clientStore = {
-  name: "clientStore",
-  getInitialState: (instance) => {
-    const { identity, config } = instance, defaultClient = createClient({
-      projectId: identity.projectId,
-      dataset: identity.dataset,
-      token: config?.auth?.token,
-      useCdn: !1,
-      apiVersion: DEFAULT_API_VERSION,
-      requestTagPrefix: DEFAULT_REQUEST_TAG_PREFIX,
-      ...config?.auth?.apiHost ? { apiHost: config.auth.apiHost } : {}
-    }), defaultGlobalClient = createClient({
-      token: config?.auth?.token,
-      useCdn: !1,
-      apiVersion: "vX",
-      // Many global APIs are only available under this version, we may need to support other versions in the future
-      useProjectHostname: !1,
-      requestTagPrefix: DEFAULT_REQUEST_TAG_PREFIX,
-      ...config?.auth?.apiHost ? { apiHost: config.auth.apiHost } : {}
-    });
-    return {
-      defaultClient,
-      defaultGlobalClient
-    };
-  },
-  initialize() {
-    const authEventSubscription = subscribeToAuthEvents(this);
-    return () => {
-      authEventSubscription.unsubscribe();
-    };
-  }
-}, receiveToken = (prev, token) => {
-  const newDefaultClient = prev.defaultClient.withConfig({
-    token
-  }), newGlobalClient = prev.defaultGlobalClient.withConfig({
-    token
-  });
-  return {
-    defaultClient: newDefaultClient,
-    defaultGlobalClient: newGlobalClient
-  };
-}, subscribeToAuthEvents = createInternalAction(
-  ({ instance, state }) => () => getTokenState(instance).observable.subscribe((newToken) => {
-    state.set("receiveToken", (prev) => receiveToken(prev, newToken ?? void 0));
-  })
-), optionsCache = /* @__PURE__ */ new WeakMap(), defaultClientSelector = (state, options) => options?.scope === "global" ? state.defaultGlobalClient : state.defaultClient, memoizedOptionsSelector = createSelector(
-  [defaultClientSelector, (_state, options) => options],
-  (client, options) => {
-    let nestedCache = optionsCache.get(client);
-    nestedCache || (nestedCache = /* @__PURE__ */ new Map(), optionsCache.set(client, nestedCache));
-    const key = JSON.stringify(options);
-    return nestedCache.get(key) || (nestedCache.set(key, options), options);
-  }
-), clientSelector = createSelector(
-  [defaultClientSelector, memoizedOptionsSelector],
-  (client, options) => client.withConfig(options)
-), getClient = createAction(
-  clientStore,
-  ({ state }) => (options) => clientSelector(state.get(), options)
-), getClientState = createStateSourceAction(clientStore, clientSelector), comlinkControllerStore = {
-  name: "connectionStore",
-  getInitialState: () => ({
-    controller: null,
-    controllerOrigin: null,
-    channels: /* @__PURE__ */ new Map()
-  }),
-  initialize() {
-    return () => {
-      destroyController(this);
-    };
-  }
-}, destroyController = createInternalAction(
-  ({ state }) => () => {
-    const { controller } = state.get();
-    controller && (controller.destroy(), state.set("destroyController", {
-      controller: null,
-      channels: /* @__PURE__ */ new Map()
-    }));
-  }
-), getOrCreateChannel = createAction(comlinkControllerStore, ({ state }) => (options) => {
-  const controller = state.get().controller;
-  if (!controller)
-    throw new Error("Controller must be initialized before using or creating channels");
-  const channels = state.get().channels, existing = channels.get(options.name);
-  if (existing) {
-    if (!isEqual(existing.options, options))
-      throw new Error(`Channel "${options.name}" already exists with different options`);
-    return state.set("incrementChannelRefCount", {
-      channels: new Map(channels).set(options.name, {
-        ...existing,
-        refCount: existing.refCount + 1
-      })
-    }), existing.channel.start(), existing.channel;
-  }
-  const channel = controller.createChannel(options);
-  return channel.start(), state.set("createChannel", {
-    channels: new Map(channels).set(options.name, {
-      channel,
-      options,
-      refCount: 1
-    })
-  }), channel;
-}), getOrCreateController = createAction(comlinkControllerStore, ({ state, instance }) => (targetOrigin) => {
-  const { controller, controllerOrigin } = state.get();
-  if (controller && controllerOrigin === targetOrigin)
-    return controller;
-  controller && destroyController({ state, instance });
-  const newController = createController({ targetOrigin });
-  return state.set("initializeController", {
-    controllerOrigin: targetOrigin,
-    controller: newController
-  }), newController;
-}), releaseChannel = createAction(comlinkControllerStore, ({ state }) => (name) => {
-  const channels = state.get().channels, channelEntry = channels.get(name);
-  if (channelEntry) {
-    const newRefCount = channelEntry.refCount === 0 ? 0 : channelEntry.refCount - 1;
-    newRefCount === 0 ? (channelEntry.channel.stop(), channels.delete(name), state.set("releaseChannel", { channels: new Map(channels) })) : state.set("releaseChannel", {
-      channels: new Map(channels).set(name, {
-        ...channelEntry,
-        refCount: newRefCount
-      })
-    });
-  }
-}), comlinkNodeStore = {
-  name: "nodeStore",
-  getInitialState: () => ({
-    nodes: /* @__PURE__ */ new Map()
-  }),
-  initialize() {
-    return () => {
-      this.state.get().nodes.forEach(({ node }) => {
-        node.stop();
-      });
-    };
-  }
-}, getOrCreateNode = createAction(comlinkNodeStore, ({ state }) => (options) => {
-  const nodes = state.get().nodes, existing = nodes.get(options.name);
-  if (existing) {
-    if (!isEqual(existing.options, options))
-      throw new Error(`Node "${options.name}" already exists with different options`);
-    return state.set("incrementNodeRefCount", {
-      nodes: new Map(nodes).set(options.name, {
-        ...existing,
-        refCount: existing.refCount + 1
-      })
-    }), existing.node.start(), existing.node;
-  }
-  const node = createNode(options);
-  return node.start(), nodes.set(options.name, { node, options, refCount: 1 }), state.set("createNode", { nodes }), node;
-}), releaseNode = createAction(comlinkNodeStore, ({ state }) => (name) => {
-  const nodes = state.get().nodes, nodeEntry = nodes.get(name);
-  if (nodeEntry) {
-    const newRefCount = nodeEntry.refCount === 0 ? 0 : nodeEntry.refCount - 1;
-    newRefCount === 0 ? (nodeEntry.node.stop(), nodes.delete(name), state.set("releaseNode", { nodes: new Map(nodes) })) : state.set("releaseNode", {
-      nodes: new Map(nodes).set(name, {
-        ...nodeEntry,
-        refCount: newRefCount
-      })
-    });
-  }
-});
-function getPublishedId(id) {
-  const draftsPrefix = "drafts.";
-  return id.startsWith(draftsPrefix) ? id.slice(draftsPrefix.length) : id;
-}
-function getDraftId(id) {
-  const draftsPrefix = "drafts.";
-  return id.startsWith(draftsPrefix) ? id : `${draftsPrefix}${id}`;
-}
-function insecureRandomId() {
-  return Array.from({ length: 16 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
-}
-function createFetcherStore({
-  name,
-  fetcher: getObservable,
-  getKey,
-  fetchThrottleInternal = 1e3,
-  stateExpirationDelay = 5e3
-}) {
-  const store = {
-    name,
-    getInitialState: () => ({
-      stateByParams: {}
-    }),
-    initialize() {
-      const subscription = subscribeToSubscriptionsAndFetch(this);
-      return () => subscription.unsubscribe();
-    }
-  }, subscribeToSubscriptionsAndFetch = createInternalAction(
-    ({ instance, state }) => function() {
-      const factoryFn = getObservable(instance);
-      return state.observable.pipe(
-        // Map the state to an array of [serialized, entry] pairs.
-        switchMap$1((s2) => {
-          const entries = Object.entries(s2.stateByParams);
-          return entries.length > 0 ? from(entries) : EMPTY;
-        }),
-        // Group by the serialized key.
-        groupBy(([key]) => key),
-        mergeMap(
-          (group$) => group$.pipe(
-            // Emit an initial value for pairwise comparisons.
-            startWith([
-              group$.key,
-              void 0
-            ]),
-            pairwise(),
-            // Trigger only when the subscriptions array grows.
-            filter$1(([[, prevEntry], [, currEntry]]) => {
-              const prevSubs = prevEntry?.subscriptions ?? [];
-              return (currEntry?.subscriptions ?? []).length > prevSubs.length;
-            }),
-            map$1(([, [, currEntry]]) => currEntry),
-            // Only trigger if we haven't fetched recently.
-            filter$1((entry) => {
-              const lastFetch = entry?.lastFetchInitiatedAt;
-              return lastFetch ? Date.now() - new Date(lastFetch).getTime() >= fetchThrottleInternal : !0;
-            }),
-            switchMap$1((entry) => entry ? (state.set(
-              "setLastFetchInitiatedAt",
-              (prev) => ({
-                stateByParams: {
-                  ...prev.stateByParams,
-                  [entry.key]: {
-                    ...entry,
-                    ...prev.stateByParams[entry.key],
-                    lastFetchInitiatedAt: (/* @__PURE__ */ new Date()).toISOString()
-                  }
-                }
-              })
-            ), factoryFn(...entry.params).pipe(
-              // the `createStateSourceAction` util requires the update
-              // to
-              delay(0, asapScheduler),
-              tap(
-                (data) => state.set("setData", (prev) => ({
-                  stateByParams: {
-                    ...prev.stateByParams,
-                    [entry.key]: {
-                      ...omit(entry, "error"),
-                      ...omit(prev.stateByParams[entry.key], "error"),
-                      data
-                    }
-                  }
-                }))
-              ),
-              catchError((error) => (state.set("setError", (prev) => ({
-                stateByParams: {
-                  ...prev.stateByParams,
-                  [entry.key]: {
-                    ...entry,
-                    ...prev.stateByParams[entry.key],
-                    error
-                  }
-                }
-              })), EMPTY))
-            )) : EMPTY)
-          )
-        )
-      ).subscribe({
-        error: (error) => state.set("setError", { error })
-      });
-    }
-  ), getState2 = createStateSourceAction(store, {
-    selector: ({ stateByParams, error }, ...params) => {
-      if (error) throw error;
-      const key = getKey(...params), entry = stateByParams[key];
-      if (entry?.error) throw entry.error;
-      return entry?.data;
-    },
-    onSubscribe: ({ state }, ...params) => {
-      const subscriptionId = insecureRandomId(), key = getKey(...params);
-      return state.set("addSubscription", (prev) => ({
-        stateByParams: {
-          ...prev.stateByParams,
-          [key]: {
-            ...prev.stateByParams[key],
-            key,
-            params: prev.stateByParams[key]?.params || params,
-            subscriptions: [...prev.stateByParams[key]?.subscriptions || [], subscriptionId]
-          }
-        }
-      })), () => {
-        setTimeout(() => {
-          state.set("removeSubscription", (prev) => {
-            const entry = prev.stateByParams[key];
-            if (!entry) return prev;
-            const newSubs = (entry.subscriptions || []).filter((id) => id !== subscriptionId);
-            return newSubs.length === 0 ? { stateByParams: omit(prev.stateByParams, key) } : {
-              stateByParams: {
-                ...prev.stateByParams,
-                [key]: {
-                  ...entry,
-                  subscriptions: newSubs
-                }
-              }
-            };
-          });
-        }, stateExpirationDelay);
-      };
-    }
-  }), resolveState = createAction(store, () => function(...params) {
-    return firstValueFrom(
-      getState2(this, ...params).observable.pipe(first((i2) => i2 !== void 0))
-    );
-  });
-  return { getState: getState2, resolveState };
-}
-const datasets = createFetcherStore({
-  name: "Datasets",
-  getKey: () => "datasets",
-  fetcher: (instance) => () => getClientState(instance, { apiVersion: "vX", scope: "project" }).observable.pipe(
-    switchMap((client) => client.observable.datasets.list())
-  )
-}), getDatasetsState = datasets.getState, resolveDatasets = datasets.resolveState, isSanityMutatePatch = (value) => !(typeof value != "object" || !value || !("type" in value) || typeof value.type != "string" || value.type !== "patch" || !("id" in value) || typeof value.id != "string" || !("patches" in value) || !Array.isArray(value.patches));
-function createDocument(doc) {
-  return {
-    type: "document.create",
-    ...doc._id && { documentId: doc._id },
-    documentType: doc._type,
-    ...doc.resourceId && { resourceId: doc.resourceId }
-  };
-}
-function deleteDocument(doc) {
-  return {
-    type: "document.delete",
-    documentId: getPublishedId(doc._id),
-    ...doc.resourceId && { resourceId: doc.resourceId }
-  };
-}
-function convertSanityMutatePatch(sanityPatchMutation) {
-  const encoded = SanityEncoder.encode(sanityPatchMutation);
-  return {
-    documentId: sanityPatchMutation.id,
-    type: "document.edit",
-    patches: encoded.map((i2) => {
-      const copy = { ...i2.patch };
-      return "id" in copy && delete copy.id, copy;
-    })
-  };
+function isNonNullable(t2) {
+  return t2 != null;
 }
-function editDocument(doc, patches) {
-  return isSanityMutatePatch(doc) ? convertSanityMutatePatch(doc) : {
-    type: "document.edit",
-    documentId: getPublishedId(doc._id),
-    ...patches && { patches: Array.isArray(patches) ? patches : [patches] },
-    ...doc.resourceId && { resourceId: doc.resourceId }
-  };
+const indexCache = /* @__PURE__ */ new WeakMap();
+function getIndexForKey(input, key) {
+  if (!Array.isArray(input)) return;
+  const cached = indexCache.get(input);
+  if (cached) return cached[key];
+  const lookup = input.reduce((acc, next, index) => (typeof next?._key == "string" && (acc[next._key] = index), acc), {});
+  return indexCache.set(input, lookup), lookup[key];
 }
-function publishDocument(doc) {
-  return {
-    type: "document.publish",
-    documentId: getPublishedId(doc._id),
-    ...doc.resourceId && { resourceId: doc.resourceId }
-  };
+function getDeep(input, path) {
+  const [currentSegment, ...restOfPath] = path;
+  if (currentSegment === void 0) return input;
+  if (typeof input != "object" || input === null) return;
+  let key;
+  if (isKeySegment(currentSegment) ? key = getIndexForKey(input, currentSegment._key) : (typeof currentSegment == "string" || typeof currentSegment == "number") && (key = currentSegment), key === void 0) return;
+  const nestedInput = typeof key == "number" && Array.isArray(input) ? input.at(key) : input[key];
+  return getDeep(nestedInput, restOfPath);
 }
-function unpublishDocument(doc) {
-  return {
-    type: "document.unpublish",
-    documentId: getPublishedId(doc._id),
-    ...doc.resourceId && { resourceId: doc.resourceId }
-  };
+function setDeep(input, path, value) {
+  const [currentSegment, ...restOfPath] = path;
+  if (currentSegment === void 0) return value;
+  if (typeof input != "object" || input === null) {
+    if (typeof currentSegment == "string")
+      return { [currentSegment]: setDeep(null, restOfPath, value) };
+    let index;
+    if (isKeySegment(currentSegment))
+      index = 0;
+    else if (typeof currentSegment == "number" && currentSegment >= 0)
+      index = currentSegment;
+    else
+      return input;
+    return [
+      // fill until index
+      ...Array.from({ length: index }).fill(null),
+      // then set deep here
+      setDeep(null, restOfPath, value)
+    ];
+  }
+  if (Array.isArray(input)) {
+    let index;
+    return isKeySegment(currentSegment) ? index = getIndexForKey(input, currentSegment._key) : typeof currentSegment == "number" && (index = currentSegment < 0 ? input.length + currentSegment : currentSegment), index === void 0 ? input : index in input ? input.map(
+      (nestedInput, i2) => i2 === index ? setDeep(nestedInput, restOfPath, value) : nestedInput
+    ) : [
+      ...input,
+      ...Array.from({ length: index - input.length }).fill(null),
+      setDeep(null, restOfPath, value)
+    ];
+  }
+  return typeof currentSegment == "object" ? input : currentSegment in input ? Object.fromEntries(
+    Object.entries(input).map(
+      ([key, nestedInput]) => key === currentSegment ? [key, setDeep(nestedInput, restOfPath, value)] : [key, nestedInput]
+    )
+  ) : { ...input, [currentSegment]: setDeep(null, restOfPath, value) };
 }
-function discardDocument(doc) {
-  return {
-    type: "document.discard",
-    documentId: getPublishedId(doc._id),
-    ...doc.resourceId && { resourceId: doc.resourceId }
-  };
+function unsetDeep(input, path) {
+  const [currentSegment, ...restOfPath] = path;
+  if (currentSegment === void 0 || typeof input != "object" || input === null) return input;
+  let _segment;
+  if (isKeySegment(currentSegment) ? _segment = getIndexForKey(input, currentSegment._key) : (typeof currentSegment == "string" || typeof currentSegment == "number") && (_segment = currentSegment), _segment === void 0) return input;
+  let segment = _segment;
+  return typeof segment == "number" && Array.isArray(input) && (segment = segment < 0 ? input.length + segment : segment), segment in input ? restOfPath.length ? Array.isArray(input) ? input.map(
+    (nestedInput, index) => index === segment ? unsetDeep(nestedInput, restOfPath) : nestedInput
+  ) : Object.fromEntries(
+    Object.entries(input).map(
+      ([key, value]) => key === segment ? [key, unsetDeep(value, restOfPath)] : [key, value]
+    )
+  ) : Array.isArray(input) ? input.filter((_nestedInput, index) => index !== segment) : Object.fromEntries(Object.entries(input).filter(([key]) => key !== segment.toString())) : input;
 }
-const DOCUMENT_STATE_CLEAR_DELAY = 1e3, INITIAL_OUTGOING_THROTTLE_TIME = 1e3, API_VERSION$2 = "vX", patchOperations = {
+const patchOperations = {
   ifRevisionID,
   set,
   setIfMissing,
@@ -1284,50 +1367,48 @@ function sortListenerEvents(options) {
     mergeMap((state) => of(...state.emitEvents))
   );
 }
-const listen = createInternalAction(({ state }) => {
+const listen = ({ state }, documentId) => {
   const { sharedListener, fetchDocument } = state.get();
-  return function(documentId) {
-    return sharedListener.pipe(
-      concatMap((e3) => e3.type === "welcome" ? fetchDocument(documentId).pipe(
-        map((document) => ({ type: "sync", document }))
-      ) : e3.type === "mutation" && e3.documentId === documentId ? of(e3) : EMPTY),
-      sortListenerEvents(),
-      withLatestFrom(
-        state.observable.pipe(
-          map((s2) => s2.documentStates[documentId]),
-          filter(Boolean),
-          distinctUntilChanged()
-        )
-      ),
-      map(([next, documentState]) => {
-        if (next.type === "sync")
-          return {
-            type: "sync",
-            documentId,
-            document: next.document,
-            revision: next.document?._rev,
-            timestamp: next.document?._updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
-          };
-        const [document] = Object.values(
-          processMutations({
-            documents: { [documentId]: documentState.remote },
-            mutations: next.mutations,
-            transactionId: next.transactionId,
-            timestamp: next.timestamp
-          })
-        ), { previousRev, transactionId, timestamp } = next;
+  return sharedListener.events.pipe(
+    concatMap((e3) => e3.type === "welcome" ? fetchDocument(documentId).pipe(
+      map((document) => ({ type: "sync", document }))
+    ) : e3.type === "mutation" && e3.documentId === documentId ? of(e3) : EMPTY),
+    sortListenerEvents(),
+    withLatestFrom(
+      state.observable.pipe(
+        map((s2) => s2.documentStates[documentId]),
+        filter(Boolean),
+        distinctUntilChanged()
+      )
+    ),
+    map(([next, documentState]) => {
+      if (next.type === "sync")
         return {
-          type: "mutation",
+          type: "sync",
           documentId,
-          document: document ?? null,
-          revision: transactionId,
-          timestamp,
-          ...previousRev && { previousRev }
+          document: next.document,
+          revision: next.document?._rev,
+          timestamp: next.document?._updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
         };
-      })
-    );
-  };
-});
+      const [document] = Object.values(
+        processMutations({
+          documents: { [documentId]: documentState.remote },
+          mutations: next.mutations,
+          transactionId: next.transactionId,
+          timestamp: next.timestamp
+        })
+      ), { previousRev, transactionId, timestamp } = next;
+      return {
+        type: "mutation",
+        documentId,
+        document: document ?? null,
+        revision: transactionId,
+        timestamp,
+        ...previousRev && { previousRev }
+      };
+    })
+  );
+};
 class e {
   pattern;
   patternRe;
@@ -3189,8 +3270,8 @@ function createGrantsLookup(datasetAcl) {
 }
 const documentsCache = new MultiKeyWeakMap(), actionsCache = /* @__PURE__ */ new WeakMap(), nullReplacer = {}, documentsSelector = createSelector(
   [
-    ({ documentStates }) => documentStates,
-    (_state, actions) => actions
+    ({ state: { documentStates } }) => documentStates,
+    (_context, actions) => actions
   ],
   (documentStates, actions) => {
     const documentIds = new Set(
@@ -3225,7 +3306,11 @@ function checkGrant$1(grantExpr, document) {
   return C(grantExpr, { params: { document } }).get();
 }
 const enNarrowConjunction = new Intl.ListFormat("en", { style: "narrow", type: "conjunction" }), calculatePermissions = createSelector(
-  [({ grants }) => grants, documentsSelector, memoizedActionsSelector],
+  [
+    ({ state: { grants } }) => grants,
+    documentsSelector,
+    memoizedActionsSelector
+  ],
   (grants, documents, actions) => {
     if (!documents || !grants || !actions) return;
     const timestamp = (/* @__PURE__ */ new Date()).toISOString(), reasons = [];
@@ -3795,7 +3880,7 @@ function removeSubscriptionIdFromDocument(prev, documentId, subscriptionId) {
     }
   } : { ...prev, documentStates: omit(prev.documentStates, documentId) } : prev;
 }
-function manageSubscriberIds(state, documentId) {
+function manageSubscriberIds({ state }, documentId) {
   const documentIds = Array.from(
     new Set(
       (Array.isArray(documentId) ? documentId : [documentId]).flatMap((id) => [
@@ -3853,9 +3938,11 @@ function getDocumentEvents(outgoing) {
     )
   );
 }
-const API_VERSION$1 = "vX";
+const API_VERSION$3 = "vX";
 function createSharedListener(instance) {
-  const events$ = getClientState(instance, { apiVersion: API_VERSION$1 }).observable.pipe(
+  const dispose$ = new Subject(), events$ = getClientState(instance, {
+    apiVersion: API_VERSION$3
+  }).observable.pipe(
     switchMap(
       (client) => (
         // TODO: it seems like the client.listen method is not emitting disconnected
@@ -3876,17 +3963,21 @@ function createSharedListener(instance) {
         )
       )
     ),
+    takeUntil(dispose$),
     share()
   ), [welcome$, mutation$] = partition(events$, (e3) => e3.type === "welcome");
-  return merge(
-    // we replay the welcome event because that event kicks off fetching the document
-    welcome$.pipe(shareReplay(1)),
-    mutation$
-  );
+  return {
+    events: merge(
+      // we replay the welcome event because that event kicks off fetching the document
+      welcome$.pipe(shareReplay(1)),
+      mutation$
+    ),
+    dispose: () => dispose$.next()
+  };
 }
 function createFetchDocument(instance) {
   return function(documentId) {
-    return getClientState(instance, { apiVersion: API_VERSION$1 }).observable.pipe(
+    return getClientState(instance, { apiVersion: API_VERSION$3 }).observable.pipe(
       switchMap((client) => createDocumentLoaderFromClient(client)(documentId)),
       map((result) => {
         if (!result.accessible) {
@@ -3910,330 +4001,458 @@ const documentStore = {
     fetchDocument: createFetchDocument(instance),
     events: new Subject()
   }),
-  initialize() {
-    const queuedTransactionSubscription = subscribeToQueuedAndApplyNextTransaction(this), subscriptionsSubscription = subscribeToSubscriptionsAndListenToDocuments(this), appliedSubscription = subscribeToAppliedAndSubmitNextTransaction(this), clientSubscription = subscribeToClientAndFetchDatasetAcl(this);
+  initialize(context) {
+    const { sharedListener } = context.state.get(), subscriptions = [
+      subscribeToQueuedAndApplyNextTransaction(context),
+      subscribeToSubscriptionsAndListenToDocuments(context),
+      subscribeToAppliedAndSubmitNextTransaction(context),
+      subscribeToClientAndFetchDatasetAcl(context)
+    ];
     return () => {
-      queuedTransactionSubscription.unsubscribe(), subscriptionsSubscription.unsubscribe(), appliedSubscription.unsubscribe(), clientSubscription.unsubscribe();
+      sharedListener.dispose(), subscriptions.forEach((subscription) => subscription.unsubscribe());
     };
   }
 };
 function getDocumentState(...args) {
   return _getDocumentState(...args);
 }
-const _getDocumentState = createStateSourceAction(documentStore, {
-  selector: ({ error, documentStates }, doc, path) => {
-    const documentId = typeof doc == "string" ? doc : doc._id;
-    if (error) throw error;
-    const draftId = getDraftId(documentId), publishedId = getPublishedId$1(documentId), draft = documentStates[draftId]?.local, published = documentStates[publishedId]?.local, document = draft ?? published;
-    if (document !== void 0)
-      return path ? jsonMatch(document, path).at(0)?.value : document;
-  },
-  onSubscribe: ({ state }, doc) => manageSubscriberIds(state, typeof doc == "string" ? doc : doc._id)
-});
+const _getDocumentState = bindActionByDataset(
+  documentStore,
+  createStateSourceAction({
+    selector: ({ state: { error, documentStates } }, doc, path) => {
+      const documentId = typeof doc == "string" ? doc : doc.documentId;
+      if (error) throw error;
+      const draftId = getDraftId(documentId), publishedId = getPublishedId$1(documentId), draft = documentStates[draftId]?.local, published = documentStates[publishedId]?.local, document = draft ?? published;
+      if (document !== void 0)
+        return path ? jsonMatch(document, path).at(0)?.value : document;
+    },
+    onSubscribe: (context, doc) => manageSubscriberIds(context, typeof doc == "string" ? doc : doc.documentId)
+  })
+);
 function resolveDocument(...args) {
   return _resolveDocument(...args);
 }
-const _resolveDocument = createAction(documentStore, () => function(doc) {
-  const documentId = typeof doc == "string" ? doc : doc._id;
-  return firstValueFrom(
-    getDocumentState(this, documentId).observable.pipe(filter((i2) => i2 !== void 0))
-  );
-}), getDocumentSyncStatus = createStateSourceAction(documentStore, {
-  selector: ({ error, documentStates: documents, outgoing, applied, queued }, doc) => {
-    const documentId = doc._id;
-    if (error) throw error;
-    const draftId = getDraftId(documentId), publishedId = getPublishedId$1(documentId), draft = documents[draftId], published = documents[publishedId];
-    if (!(draft === void 0 || published === void 0))
-      return !queued.length && !applied.length && !outgoing;
-  },
-  onSubscribe: ({ state }, doc) => manageSubscriberIds(state, doc._id)
-}), getPermissionsState = createStateSourceAction(documentStore, {
-  selector: calculatePermissions,
-  onSubscribe: ({ state }, actions) => manageSubscriberIds(state, getDocumentIdsFromActions(actions))
-}), resolvePermissions = createAction(documentStore, () => function(actions) {
-  return firstValueFrom(
-    getPermissionsState(this, actions).observable.pipe(filter((i2) => i2 !== void 0))
-  );
-}), subscribeDocumentEvents = createAction(documentStore, ({ state }) => {
-  const { events } = state.get();
-  return function(eventHandler) {
-    const subscription = events.subscribe(eventHandler);
-    return () => subscription.unsubscribe();
-  };
-}), subscribeToQueuedAndApplyNextTransaction = createInternalAction(
-  ({ state }) => {
-    const { events } = state.get();
-    return function() {
-      return state.observable.pipe(
-        map(applyFirstQueuedTransaction),
-        distinctUntilChanged(),
-        tap$1((next) => state.set("applyFirstQueuedTransaction", next)),
-        catchError$1((error, caught) => {
-          if (error instanceof ActionError)
-            return state.set(
-              "removeQueuedTransaction",
-              (prev) => removeQueuedTransaction(prev, error.transactionId)
-            ), events.next({
-              type: "error",
-              message: error.message,
-              documentId: error.documentId,
-              transactionId: error.transactionId,
-              error
-            }), caught;
-          throw error;
-        })
-      ).subscribe({ error: (error) => state.set("setError", { error }) });
-    };
-  }
-), subscribeToAppliedAndSubmitNextTransaction = createInternalAction(
-  ({ state, instance }) => {
-    const { events } = state.get();
-    return function() {
-      return state.observable.pipe(
-        throttle(
-          (s2) => (
-            // if there is no outgoing transaction, we can throttle by the
-            // initial outgoing throttle time…
-            s2.outgoing ? (
-              // …otherwise, wait until the outgoing has been cleared
-              state.observable.pipe(first$1(({ outgoing }) => !outgoing))
-            ) : timer(INITIAL_OUTGOING_THROTTLE_TIME)
-          ),
-          { leading: !1, trailing: !0 }
-        ),
-        map(transitionAppliedTransactionsToOutgoing),
-        distinctUntilChanged((a2, b2) => a2.outgoing?.transactionId === b2.outgoing?.transactionId),
-        tap$1((next) => state.set("transitionAppliedTransactionsToOutgoing", next)),
-        map((s2) => s2.outgoing),
-        distinctUntilChanged(),
-        withLatestFrom(getClientState(instance, { apiVersion: API_VERSION$2 }).observable),
-        concatMap(([outgoing, client]) => outgoing ? client.observable.action(outgoing.outgoingActions, {
-          transactionId: outgoing.transactionId,
-          skipCrossDatasetReferenceValidation: !0
-        }).pipe(
-          catchError$1((error) => (state.set("revertOutgoingTransaction", revertOutgoingTransaction), events.next({ type: "reverted", message: error.message, outgoing, error }), EMPTY)),
-          map((result) => ({ result, outgoing }))
-        ) : EMPTY),
-        tap$1(({ outgoing, result }) => {
-          state.set("cleanupOutgoingTransaction", cleanupOutgoingTransaction);
-          for (const e3 of getDocumentEvents(outgoing)) events.next(e3);
-          events.next({ type: "accepted", outgoing, result });
-        })
-      ).subscribe({ error: (error) => state.set("setError", { error }) });
-    };
+const _resolveDocument = bindActionByDataset(
+  documentStore,
+  ({ instance }, doc) => {
+    const documentId = typeof doc == "string" ? doc : doc.documentId;
+    return firstValueFrom(
+      getDocumentState(instance, documentId).observable.pipe(filter((i2) => i2 !== void 0))
+    );
   }
-), subscribeToSubscriptionsAndListenToDocuments = createInternalAction(
-  ({ state }) => {
-    const { events } = state.get();
-    return function() {
-      return state.observable.pipe(
-        filter((s2) => !!s2.grants),
-        map((s2) => Object.keys(s2.documentStates)),
-        distinctUntilChanged((curr, next) => {
-          if (curr.length !== next.length) return !1;
-          const currSet = new Set(curr);
-          return next.every((i2) => currSet.has(i2));
-        }),
-        startWith$1(/* @__PURE__ */ new Set()),
-        pairwise$1(),
-        switchMap((pair) => {
-          const [curr, next] = pair.map((ids) => new Set(ids)), added = Array.from(next).filter((i2) => !curr.has(i2)), removed = Array.from(curr).filter((i2) => !next.has(i2)), changes = [
-            ...added.map((id) => ({ id, add: !0 })),
-            ...removed.map((id) => ({ id, add: !1 }))
-          ].sort((a2, b2) => {
-            const aIsDraft = a2.id === getDraftId(a2.id), bIsDraft = b2.id === getDraftId(b2.id);
-            return aIsDraft && bIsDraft ? a2.id.localeCompare(b2.id, "en-US") : aIsDraft ? -1 : bIsDraft ? 1 : a2.id.localeCompare(b2.id, "en-US");
-          });
-          return of(...changes);
-        }),
-        groupBy$1((i2) => i2.id),
-        mergeMap$1(
-          (group) => group.pipe(
-            switchMap((e3) => e3.add ? listen(this, e3.id).pipe(
-              catchError$1((error) => {
-                throw error instanceof OutOfSyncError && listen(this, e3.id), error;
-              }),
-              tap$1(
-                (remote) => state.set(
-                  "applyRemoteDocument",
-                  (prev) => applyRemoteDocument(prev, remote, events)
-                )
-              )
-            ) : EMPTY)
-          )
-        )
-      ).subscribe({ error: (error) => state.set("setError", { error }) });
-    };
+), getDocumentSyncStatus = bindActionByDataset(
+  documentStore,
+  createStateSourceAction({
+    selector: ({ state: { error, documentStates: documents, outgoing, applied, queued } }, doc) => {
+      const documentId = typeof doc == "string" ? doc : doc.documentId;
+      if (error) throw error;
+      const draftId = getDraftId(documentId), publishedId = getPublishedId$1(documentId), draft = documents[draftId], published = documents[publishedId];
+      if (!(draft === void 0 || published === void 0))
+        return !queued.length && !applied.length && !outgoing;
+    },
+    onSubscribe: (context, doc) => manageSubscriberIds(context, doc.documentId)
+  })
+), getPermissionsState = bindActionByDataset(
+  documentStore,
+  createStateSourceAction({
+    selector: calculatePermissions,
+    onSubscribe: (context, actions) => manageSubscriberIds(context, getDocumentIdsFromActions(actions))
+  })
+), resolvePermissions = bindActionByDataset(
+  documentStore,
+  ({ instance }, actions) => firstValueFrom(
+    getPermissionsState(instance, actions).observable.pipe(filter((i2) => i2 !== void 0))
+  )
+), subscribeDocumentEvents = bindActionByDataset(
+  documentStore,
+  ({ state }, eventHandler) => {
+    const { events } = state.get(), subscription = events.subscribe(eventHandler);
+    return () => subscription.unsubscribe();
   }
-), subscribeToClientAndFetchDatasetAcl = createInternalAction(
-  ({ instance, state }) => {
-    const { projectId, dataset } = instance.identity;
-    return function() {
-      return getClientState(instance, { apiVersion: API_VERSION$2 }).observable.pipe(
-        switchMap(
-          (client) => client.observable.request({
-            uri: `/projects/${projectId}/datasets/${dataset}/acl`,
-            tag: "acl.get",
-            withCredentials: !0
-          })
-        ),
-        tap$1((datasetAcl) => state.set("setGrants", { grants: createGrantsLookup(datasetAcl) }))
-      ).subscribe({
-        error: (error) => state.set("setError", { error })
+), subscribeToQueuedAndApplyNextTransaction = ({ state }) => {
+  const { events } = state.get();
+  return state.observable.pipe(
+    map(applyFirstQueuedTransaction),
+    distinctUntilChanged(),
+    tap$1((next) => state.set("applyFirstQueuedTransaction", next)),
+    catchError$1((error, caught) => {
+      if (error instanceof ActionError)
+        return state.set(
+          "removeQueuedTransaction",
+          (prev) => removeQueuedTransaction(prev, error.transactionId)
+        ), events.next({
+          type: "error",
+          message: error.message,
+          documentId: error.documentId,
+          transactionId: error.transactionId,
+          error
+        }), caught;
+      throw error;
+    })
+  ).subscribe({ error: (error) => state.set("setError", { error }) });
+}, subscribeToAppliedAndSubmitNextTransaction = ({
+  state,
+  instance
+}) => {
+  const { events } = state.get();
+  return state.observable.pipe(
+    throttle(
+      (s2) => (
+        // if there is no outgoing transaction, we can throttle by the
+        // initial outgoing throttle time…
+        s2.outgoing ? (
+          // …otherwise, wait until the outgoing has been cleared
+          state.observable.pipe(first$1(({ outgoing }) => !outgoing))
+        ) : timer(INITIAL_OUTGOING_THROTTLE_TIME)
+      ),
+      { leading: !1, trailing: !0 }
+    ),
+    map(transitionAppliedTransactionsToOutgoing),
+    distinctUntilChanged((a2, b2) => a2.outgoing?.transactionId === b2.outgoing?.transactionId),
+    tap$1((next) => state.set("transitionAppliedTransactionsToOutgoing", next)),
+    map((s2) => s2.outgoing),
+    distinctUntilChanged(),
+    withLatestFrom(getClientState(instance, { apiVersion: API_VERSION$4 }).observable),
+    concatMap(([outgoing, client]) => outgoing ? client.observable.action(outgoing.outgoingActions, {
+      transactionId: outgoing.transactionId,
+      skipCrossDatasetReferenceValidation: !0
+    }).pipe(
+      catchError$1((error) => (state.set("revertOutgoingTransaction", revertOutgoingTransaction), events.next({ type: "reverted", message: error.message, outgoing, error }), EMPTY)),
+      map((result) => ({ result, outgoing }))
+    ) : EMPTY),
+    tap$1(({ outgoing, result }) => {
+      state.set("cleanupOutgoingTransaction", cleanupOutgoingTransaction);
+      for (const e3 of getDocumentEvents(outgoing)) events.next(e3);
+      events.next({ type: "accepted", outgoing, result });
+    })
+  ).subscribe({ error: (error) => state.set("setError", { error }) });
+}, subscribeToSubscriptionsAndListenToDocuments = (context) => {
+  const { state } = context, { events } = state.get();
+  return state.observable.pipe(
+    filter((s2) => !!s2.grants),
+    map((s2) => Object.keys(s2.documentStates)),
+    distinctUntilChanged((curr, next) => {
+      if (curr.length !== next.length) return !1;
+      const currSet = new Set(curr);
+      return next.every((i2) => currSet.has(i2));
+    }),
+    startWith$1(/* @__PURE__ */ new Set()),
+    pairwise$1(),
+    switchMap((pair) => {
+      const [curr, next] = pair.map((ids) => new Set(ids)), added = Array.from(next).filter((i2) => !curr.has(i2)), removed = Array.from(curr).filter((i2) => !next.has(i2)), changes = [
+        ...added.map((id) => ({ id, add: !0 })),
+        ...removed.map((id) => ({ id, add: !1 }))
+      ].sort((a2, b2) => {
+        const aIsDraft = a2.id === getDraftId(a2.id), bIsDraft = b2.id === getDraftId(b2.id);
+        return aIsDraft && bIsDraft ? a2.id.localeCompare(b2.id, "en-US") : aIsDraft ? -1 : bIsDraft ? 1 : a2.id.localeCompare(b2.id, "en-US");
       });
-    };
-  }
-);
+      return of(...changes);
+    }),
+    groupBy$1((i2) => i2.id),
+    mergeMap$1(
+      (group) => group.pipe(
+        switchMap((e3) => e3.add ? listen(context, e3.id).pipe(
+          catchError$1((error) => {
+            throw error instanceof OutOfSyncError && listen(context, e3.id), error;
+          }),
+          tap$1(
+            (remote) => state.set(
+              "applyRemoteDocument",
+              (prev) => applyRemoteDocument(prev, remote, events)
+            )
+          )
+        ) : EMPTY)
+      )
+    )
+  ).subscribe({ error: (error) => state.set("setError", { error }) });
+}, subscribeToClientAndFetchDatasetAcl = ({
+  instance,
+  state
+}) => {
+  const { projectId, dataset } = instance.config;
+  return getClientState(instance, { apiVersion: API_VERSION$4 }).observable.pipe(
+    switchMap(
+      (client) => client.observable.request({
+        uri: `/projects/${projectId}/datasets/${dataset}/acl`,
+        tag: "acl.get",
+        withCredentials: !0
+      })
+    ),
+    tap$1((datasetAcl) => state.set("setGrants", { grants: createGrantsLookup(datasetAcl) }))
+  ).subscribe({
+    error: (error) => state.set("setError", { error })
+  });
+};
 function applyDocumentActions(...args) {
-  return _applyDocumentActions(...args);
+  return boundApplyDocumentActions(...args);
 }
-const _applyDocumentActions = createAction(documentStore, ({ state }) => {
-  const { events } = state.get();
-  return async function(action, { transactionId = crypto.randomUUID(), disableBatching } = {}) {
-    const actions = Array.isArray(action) ? action : [action], transaction = {
-      transactionId,
-      actions,
-      ...disableBatching && { disableBatching }
-    }, fatalError$ = state.observable.pipe(
-      map((s2) => s2.error),
-      first$1(Boolean),
-      map((error) => ({ type: "error", error }))
-    ), transactionError$ = events.pipe(
-      filter((e3) => e3.type === "error"),
-      first$1((e3) => e3.transactionId === transactionId)
-    ), appliedTransaction$ = state.observable.pipe(
-      map((s2) => s2.applied),
-      distinctUntilChanged(),
-      map((applied) => applied.find((t2) => t2.transactionId === transactionId)),
-      first$1(Boolean)
-    ), successfulTransaction$ = events.pipe(
-      filter((e3) => e3.type === "accepted"),
-      first$1((e3) => e3.outgoing.batchedTransactionIds.includes(transactionId))
-    ), rejectedTransaction$ = events.pipe(
-      filter((e3) => e3.type === "reverted"),
-      first$1((e3) => e3.outgoing.batchedTransactionIds.includes(transactionId))
-    ), appliedTransactionOrError = firstValueFrom(
-      race([fatalError$, transactionError$, appliedTransaction$])
-    ), acceptedOrRejectedTransaction = firstValueFrom(
-      race([successfulTransaction$, rejectedTransaction$, transactionError$])
-    );
-    state.set("queueTransaction", (prev) => queueTransaction(prev, transaction));
-    const result = await appliedTransactionOrError;
-    if ("type" in result && result.type === "error") throw result.error;
-    const { working: documents, previous, previousRevs } = result, existingIds = new Set(
-      Object.entries(previous).filter(([, value]) => !!value).map(([key]) => key)
-    ), resultingIds = new Set(
-      Object.entries(documents).filter(([, value]) => !!value).map(([key]) => key)
-    ), allIds = /* @__PURE__ */ new Set([...existingIds, ...resultingIds]), updated = [], appeared = [], disappeared = [];
-    for (const id of allIds)
-      existingIds.has(id) && resultingIds.has(id) ? updated.push(id) : !existingIds.has(id) && resultingIds.has(id) ? appeared.push(id) : !resultingIds.has(id) && existingIds.has(id) && disappeared.push(id);
-    async function submitted() {
-      const raceResult = await acceptedOrRejectedTransaction;
-      if (raceResult.type !== "accepted") throw raceResult.error;
-      return raceResult.result;
+const boundApplyDocumentActions = bindActionByDataset(documentStore, _applyDocumentActions);
+async function _applyDocumentActions({ instance, state }, actionOrActions, { transactionId = crypto.randomUUID(), disableBatching } = {}) {
+  const actions = Array.isArray(actionOrActions) ? actionOrActions : [actionOrActions];
+  let projectId, dataset;
+  for (const action of actions)
+    if (action.projectId) {
+      if (projectId || (projectId = action.projectId), action.projectId !== projectId)
+        throw new Error(
+          `Mismatched project IDs found in actions. All actions must belong to the same project. Found "${action.projectId}" but expected "${projectId}".`
+        );
+      if (action.dataset && (dataset || (dataset = action.dataset), action.dataset !== dataset))
+        throw new Error(
+          `Mismatched datasets found in actions. All actions must belong to the same dataset. Found "${action.dataset}" but expected "${dataset}".`
+        );
     }
-    return {
-      transactionId,
-      documents,
-      previous,
-      previousRevs,
-      appeared,
-      updated,
-      disappeared,
-      submitted
-    };
+  if (projectId && projectId !== instance.config.projectId || dataset && dataset !== instance.config.dataset) {
+    const matchedInstance = instance.match({ projectId, dataset });
+    if (!matchedInstance)
+      throw new Error(
+        `Could not find a matching instance for projectId: "${projectId}" and dataset: "${dataset}"`
+      );
+    return boundApplyDocumentActions(matchedInstance, actionOrActions, {
+      disableBatching,
+      transactionId
+    });
+  }
+  const { events } = state.get(), transaction = {
+    transactionId,
+    actions,
+    ...disableBatching && { disableBatching }
+  }, fatalError$ = state.observable.pipe(
+    map((s2) => s2.error),
+    first$1(Boolean),
+    map((error) => ({ type: "error", error }))
+  ), transactionError$ = events.pipe(
+    filter((e3) => e3.type === "error"),
+    first$1((e3) => e3.transactionId === transactionId)
+  ), appliedTransaction$ = state.observable.pipe(
+    map((s2) => s2.applied),
+    distinctUntilChanged(),
+    map((applied) => applied.find((t2) => t2.transactionId === transactionId)),
+    first$1(Boolean)
+  ), successfulTransaction$ = events.pipe(
+    filter((e3) => e3.type === "accepted"),
+    first$1((e3) => e3.outgoing.batchedTransactionIds.includes(transactionId))
+  ), rejectedTransaction$ = events.pipe(
+    filter((e3) => e3.type === "reverted"),
+    first$1((e3) => e3.outgoing.batchedTransactionIds.includes(transactionId))
+  ), appliedTransactionOrError = firstValueFrom(
+    race([fatalError$, transactionError$, appliedTransaction$])
+  ), acceptedOrRejectedTransaction = firstValueFrom(
+    race([successfulTransaction$, rejectedTransaction$, transactionError$])
+  );
+  state.set("queueTransaction", (prev) => queueTransaction(prev, transaction));
+  const result = await appliedTransactionOrError;
+  if ("type" in result && result.type === "error") throw result.error;
+  const { working: documents, previous, previousRevs } = result, existingIds = new Set(
+    Object.entries(previous).filter(([, value]) => !!value).map(([key]) => key)
+  ), resultingIds = new Set(
+    Object.entries(documents).filter(([, value]) => !!value).map(([key]) => key)
+  ), allIds = /* @__PURE__ */ new Set([...existingIds, ...resultingIds]), updated = [], appeared = [], disappeared = [];
+  for (const id of allIds)
+    existingIds.has(id) && resultingIds.has(id) ? updated.push(id) : !existingIds.has(id) && resultingIds.has(id) ? appeared.push(id) : !resultingIds.has(id) && existingIds.has(id) && disappeared.push(id);
+  async function submitted() {
+    const raceResult = await acceptedOrRejectedTransaction;
+    if (raceResult.type !== "accepted") throw raceResult.error;
+    return raceResult.result;
+  }
+  return {
+    transactionId,
+    documents,
+    previous,
+    previousRevs,
+    appeared,
+    updated,
+    disappeared,
+    submitted
   };
-});
-function getSdkIdentity({
-  projectId,
-  dataset
-}) {
-  const id = generateId();
-  return Object.freeze({
-    id,
-    projectId,
-    dataset,
-    resourceId: `${projectId}.${dataset}`
-  });
 }
-function generateId() {
-  return Array.from(
-    { length: 8 },
-    () => Math.floor(Math.random() * 16).toString(16).padStart(2, "0")
-  ).join("");
-}
-function createSanityInstance({
-  projectId = "",
-  dataset = "",
-  ...config
-}) {
-  const identity = getSdkIdentity({ projectId, dataset });
-  return {
-    identity,
-    config,
-    dispose: () => disposeResources(identity)
-  };
+const QUERY_STATE_CLEAR_DELAY = 1e3, QUERY_STORE_API_VERSION = "vX", setQueryError = (key, error) => (prev) => {
+  const prevQuery = prev.queries[key];
+  return prevQuery ? { ...prev, queries: { ...prev.queries, [key]: { ...prevQuery, error } } } : prev;
+}, setQueryData = (key, result, syncTags) => (prev) => {
+  const prevQuery = prev.queries[key];
+  return prevQuery ? {
+    ...prev,
+    queries: { ...prev.queries, [key]: { ...prevQuery, result: result ?? null, syncTags } }
+  } : prev;
+}, setLastLiveEventId = (key, lastLiveEventId) => (prev) => {
+  const prevQuery = prev.queries[key];
+  return prevQuery ? { ...prev, queries: { ...prev.queries, [key]: { ...prevQuery, lastLiveEventId } } } : prev;
+}, addSubscriber = (key, subscriptionId) => (prev) => {
+  const prevQuery = prev.queries[key], subscribers = [...prevQuery?.subscribers ?? [], subscriptionId];
+  return { ...prev, queries: { ...prev.queries, [key]: { ...prevQuery, subscribers } } };
+}, removeSubscriber = (key, subscriptionId) => (prev) => {
+  const prevQuery = prev.queries[key];
+  if (!prevQuery) return prev;
+  const subscribers = prevQuery.subscribers.filter((id) => id !== subscriptionId);
+  return subscribers.length ? { ...prev, queries: { ...prev.queries, [key]: { ...prevQuery, subscribers } } } : { ...prev, queries: omit(prev.queries, key) };
+}, cancelQuery = (key) => (prev) => {
+  const prevQuery = prev.queries[key];
+  return !prevQuery || prevQuery.subscribers.length ? prev : { ...prev, queries: omit(prev.queries, key) };
+}, initializeQuery = (key) => (prev) => prev.queries[key] ? prev : { ...prev, queries: { ...prev.queries, [key]: { subscribers: [] } } }, EMPTY_ARRAY = [], getQueryKey = (query, options = {}) => JSON.stringify({ query, options }), parseQueryKey = (key) => JSON.parse(key), queryStore = {
+  name: "QueryStore",
+  getInitialState: () => ({ queries: {} }),
+  initialize(context) {
+    const subscriptions = [
+      listenForNewSubscribersAndFetch(context),
+      listenToLiveClientAndSetLastLiveEventIds(context)
+    ];
+    return () => {
+      for (const subscription of subscriptions)
+        subscription.unsubscribe();
+    };
+  }
+}, errorHandler$1 = (state) => (error) => state.set("setError", { error }), listenForNewSubscribersAndFetch = ({ state, instance }) => state.observable.pipe(
+  map((s2) => new Set(Object.keys(s2.queries))),
+  distinctUntilChanged((curr, next) => curr.size !== next.size ? !1 : Array.from(next).every((i2) => curr.has(i2))),
+  startWith$1(/* @__PURE__ */ new Set()),
+  pairwise$1(),
+  mergeMap$1(([curr, next]) => {
+    const added = Array.from(next).filter((i2) => !curr.has(i2)), removed = Array.from(curr).filter((i2) => !next.has(i2));
+    return [
+      ...added.map((key) => ({ key, added: !0 })),
+      ...removed.map((key) => ({ key, added: !1 }))
+    ];
+  }),
+  groupBy$1((i2) => i2.key),
+  mergeMap$1(
+    (group$) => group$.pipe(
+      switchMap((e3) => {
+        if (!e3.added) return EMPTY;
+        const lastLiveEventId$ = state.observable.pipe(
+          map((s2) => s2.queries[group$.key]?.lastLiveEventId),
+          distinctUntilChanged()
+        ), { query, options: { params, projectId, dataset, tag, ...options } = {} } = parseQueryKey(group$.key), client$ = getClientState(instance, {
+          apiVersion: QUERY_STORE_API_VERSION,
+          projectId,
+          dataset
+        }).observable;
+        return combineLatest([lastLiveEventId$, client$]).pipe(
+          switchMap(
+            ([lastLiveEventId, client]) => client.observable.fetch(query, params, {
+              ...options,
+              filterResponse: !1,
+              returnQuery: !1,
+              lastLiveEventId,
+              tag
+            })
+          )
+        );
+      }),
+      catchError$1((error) => (state.set("setQueryError", setQueryError(group$.key, error)), EMPTY)),
+      tap$1(({ result, syncTags }) => {
+        state.set("setQueryData", setQueryData(group$.key, result, syncTags));
+      })
+    )
+  )
+).subscribe({ error: errorHandler$1(state) }), listenToLiveClientAndSetLastLiveEventIds = ({
+  state,
+  instance
+}) => {
+  const liveMessages$ = getClientState(instance, {
+    apiVersion: QUERY_STORE_API_VERSION
+  }).observable.pipe(
+    switchMap(
+      (client) => client.live.events({ includeDrafts: !!client.config().token, tag: "query-store" })
+    ),
+    share(),
+    filter((e3) => e3.type === "message")
+  );
+  return state.observable.pipe(
+    mergeMap$1((s2) => Object.entries(s2.queries)),
+    groupBy$1(([key]) => key),
+    mergeMap$1((group$) => {
+      const syncTags$ = group$.pipe(
+        map(([, queryState]) => queryState),
+        map((i2) => i2?.syncTags ?? EMPTY_ARRAY),
+        distinctUntilChanged()
+      );
+      return combineLatest([liveMessages$, syncTags$]).pipe(
+        filter(([message, syncTags]) => message.tags.some((tag) => syncTags.includes(tag))),
+        tap$1(([message]) => {
+          state.set("setLastLiveEventId", setLastLiveEventId(group$.key, message.id));
+        })
+      );
+    })
+  ).subscribe({ error: errorHandler$1(state) });
+};
+function getQueryState(...args) {
+  return _getQueryState(...args);
+}
+const _getQueryState = bindActionByDataset(
+  queryStore,
+  createStateSourceAction({
+    selector: ({ state }, query, options) => {
+      if (state.error) throw state.error;
+      const key = getQueryKey(query, options), queryState = state.queries[key];
+      if (queryState?.error) throw queryState.error;
+      return queryState?.result;
+    },
+    onSubscribe: ({ state }, query, options) => {
+      const subscriptionId = insecureRandomId(), key = getQueryKey(query, options);
+      return state.set("addSubscriber", addSubscriber(key, subscriptionId)), () => {
+        setTimeout(
+          () => state.set("removeSubscriber", removeSubscriber(key, subscriptionId)),
+          QUERY_STATE_CLEAR_DELAY
+        );
+      };
+    }
+  })
+);
+function resolveQuery(...args) {
+  return _resolveQuery(...args);
 }
-function createLiveEventSubscriber(tag) {
-  return createInternalAction(({ instance, state }) => {
-    const client$ = getClientState(instance, { apiVersion: "vX" }).observable, syncTags$ = state.observable.pipe(
-      map((i2) => i2.syncTags),
-      distinctUntilChanged()
+const _resolveQuery = bindActionByDataset(
+  queryStore,
+  ({ state, instance }, query, { signal, ...options } = {}) => {
+    const { getCurrent } = getQueryState(instance, query, options), key = getQueryKey(query, options), aborted$ = signal ? new Observable((observer) => {
+      const cleanup = () => {
+        signal.removeEventListener("abort", listener);
+      }, listener = () => {
+        observer.error(new DOMException("The operation was aborted.", "AbortError")), observer.complete(), cleanup();
+      };
+      return signal.addEventListener("abort", listener), cleanup;
+    }).pipe(
+      catchError$1((error) => {
+        throw error instanceof Error && error.name === "AbortError" && state.set("cancelQuery", cancelQuery(key)), error;
+      })
+    ) : NEVER;
+    state.set("initializeQuery", initializeQuery(key));
+    const resolved$ = state.observable.pipe(
+      map(getCurrent),
+      first$1((i2) => i2 !== void 0)
     );
-    return function() {
-      const messageEvents$ = client$.pipe(
-        switchMap(
-          (client) => client.live.events({ includeDrafts: !!client.config().token, tag }).pipe(filter((e3) => e3.type === "message"))
-        )
-      );
-      return combineLatest([messageEvents$, syncTags$]).subscribe({
-        next: ([event, currentSyncTags]) => {
-          for (const eventTag of event.tags)
-            if (currentSyncTags[eventTag]) {
-              state.set("setLastLiveEventId", (prevState) => ({
-                ...prevState,
-                lastLiveEventId: event.id
-              }));
-              return;
-            }
-        }
-      });
-    };
-  });
-}
+    return firstValueFrom(race([resolved$, aborted$]));
+  }
+);
 function hashString(str) {
   let hash = 0;
   for (let i2 = 0; i2 < str.length; i2++)
     hash = (hash * 31 + str.charCodeAt(i2)) % 2147483647;
   return Math.abs(hash).toString(16).padStart(8, "0");
 }
-const TITLE_CANDIDATES = ["title", "name", "label", "heading", "header", "caption"], SUBTITLE_CANDIDATES = ["description", "subtitle", ...TITLE_CANDIDATES];
-function getPreviewProjection() {
-  return `{
-    // Get all potential title fields
-    "titleCandidates": {
-      ${TITLE_CANDIDATES.map((field) => `"${field}": ${field}`).join(`,
+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(`,
+  },
+  // 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
-  }`;
-}
-const PREVIEW_TAG = "preview", STABLE_EMPTY_PREVIEW = { data: null, isPending: !1 }, STABLE_ERROR_PREVIEW = {
+  },
+  "media": coalesce(
+    select(
+      defined(asset) => {"type": "image-asset", "_ref": asset._ref},
+      defined(image.asset) => {"type": "image-asset", "_ref": image.asset._ref},
+      defined(mainImage.asset) => {"type": "image-asset", "_ref": mainImage.asset._ref},
+      null
+    )
+  ),
+  _type,
+  _id,
+  _updatedAt
+}`, PREVIEW_TAG = "preview", PREVIEW_PERSPECTIVE = "drafts", STABLE_EMPTY_PREVIEW = { data: null, isPending: !1 }, STABLE_ERROR_PREVIEW = {
   data: {
     title: "Preview Error",
     ...!!getEnv("DEV") && { subtitle: "Check the console for more details" }
@@ -4297,104 +4516,92 @@ function processPreviewQuery({
   );
 }
 function createPreviewQuery(documentIds) {
-  const allIds = Array.from(documentIds).flatMap((id) => [getPublishedId(id), getDraftId(id)]), projection = getPreviewProjection(), queryHash = hashString(projection);
+  const allIds = Array.from(documentIds).flatMap((id) => [getPublishedId(id), getDraftId(id)]), queryHash = hashString(PREVIEW_PROJECTION);
   return {
-    query: `*[_id in $__ids_${queryHash}]${projection}`,
+    query: `*[_id in $__ids_${queryHash}]${PREVIEW_PROJECTION}`,
     params: {
       [`__ids_${queryHash}`]: allIds
     }
   };
 }
-const BATCH_DEBOUNCE_TIME$1 = 50, subscribeToStateAndFetchBatches$1 = createInternalAction(
-  ({ state, instance }) => function() {
-    const client$ = getClientState(instance, { apiVersion: "vX" }).observable, documentTypes$ = state.observable.pipe(
-      map((i2) => i2.documentTypes),
-      distinctUntilChanged()
-    ), lastLiveEventId$ = state.observable.pipe(
-      map((i2) => i2.lastLiveEventId),
-      distinctUntilChanged()
-    ), newSubscriberIds$ = state.observable.pipe(
-      map(({ subscriptions }) => new Set(Object.keys(subscriptions))),
-      distinctUntilChanged(
-        (a2, b2) => a2.size !== b2.size ? !1 : Array.from(a2).every((i2) => b2.has(i2))
-      ),
-      debounceTime(BATCH_DEBOUNCE_TIME$1),
-      startWith$1(/* @__PURE__ */ new Set()),
-      pairwise$1(),
-      tap$1(([prevIds, currIds]) => {
-        const newIds = [...currIds].filter((element) => !prevIds.has(element));
-        state.set("updatingPending", (prev) => {
-          const pendingValues = newIds.reduce((acc, id) => {
-            const prevValue = prev.values[id], value = prevValue?.data ? prevValue.data : null;
-            return acc[id] = { data: value, isPending: !0 }, acc;
-          }, {});
-          return { values: { ...prev.values, ...pendingValues } };
-        });
-      }),
-      withLatestFrom(documentTypes$),
-      map(([[, ids], documentTypes]) => ({ ids, documentTypes }))
-    );
-    return combineLatest([newSubscriberIds$, lastLiveEventId$, client$]).pipe(
-      switchMap(([{ ids }, lastLiveEventId, client]) => {
-        if (!ids.size) return EMPTY;
-        const { query, params } = createPreviewQuery(ids);
-        return client.observable.fetch(query, params, {
-          filterResponse: !1,
-          returnQuery: !1,
-          perspective: "drafts",
+const BATCH_DEBOUNCE_TIME$1 = 50, isSetEqual$1 = (a2, b2) => a2.size === b2.size && Array.from(a2).every((i2) => b2.has(i2)), subscribeToStateAndFetchBatches$1 = ({
+  state,
+  instance
+}) => state.observable.pipe(
+  map(({ subscriptions }) => new Set(Object.keys(subscriptions))),
+  distinctUntilChanged(isSetEqual$1),
+  debounceTime(BATCH_DEBOUNCE_TIME$1),
+  startWith$1(/* @__PURE__ */ new Set()),
+  pairwise$1(),
+  tap$1(([prevIds, currIds]) => {
+    const newIds = [...currIds].filter((element) => !prevIds.has(element));
+    state.set("updatingPending", (prev) => {
+      const pendingValues = newIds.reduce((acc, id) => {
+        const prevValue = prev.values[id], value = prevValue?.data ? prevValue.data : null;
+        return acc[id] = { data: value, isPending: !0 }, acc;
+      }, {});
+      return { values: { ...prev.values, ...pendingValues } };
+    });
+  }),
+  map(([, ids]) => ids),
+  distinctUntilChanged(isSetEqual$1)
+).pipe(
+  switchMap((ids) => {
+    if (!ids.size) return EMPTY;
+    const { query, params } = createPreviewQuery(ids), controller = new AbortController();
+    return new Observable((observer) => {
+      const { getCurrent, observable } = getQueryState(instance, query, {
+        params,
+        tag: PREVIEW_TAG,
+        perspective: PREVIEW_PERSPECTIVE
+      }), subscription = defer(() => getCurrent() === void 0 ? from(
+        resolveQuery(instance, query, {
+          params,
           tag: PREVIEW_TAG,
-          lastLiveEventId
-        }).pipe(map((response) => ({ ...response, ids })));
-      }),
-      map(({ ids, result, syncTags }) => ({
-        syncTags,
-        values: processPreviewQuery({
-          projectId: instance.identity.projectId,
-          dataset: instance.identity.dataset,
-          ids,
-          results: result
+          perspective: PREVIEW_PERSPECTIVE,
+          signal: controller.signal
         })
-      }))
-    ).subscribe({
-      next: ({ syncTags = [], values }) => {
-        state.set("updateResult", (prev) => ({
-          values: { ...prev.values, ...values },
-          syncTags: syncTags.reduce((acc, next) => (acc[next] = !0, acc), {})
-        }));
-      }
-    });
+      ).pipe(switchMap(() => observable)) : observable).pipe(filter((result) => result !== void 0)).subscribe(observer);
+      return () => {
+        controller.signal.aborted || controller.abort(), subscription.unsubscribe();
+      };
+    }).pipe(map((data) => ({ data, ids })));
+  }),
+  map(({ ids, data }) => ({
+    values: processPreviewQuery({
+      projectId: instance.config.projectId,
+      dataset: instance.config.dataset,
+      ids,
+      results: data
+    })
+  }))
+).subscribe({
+  next: ({ values }) => {
+    state.set("updateResult", (prev) => ({ values: { ...prev.values, ...values } }));
   }
-), previewStore = {
+}), previewStore = {
   name: "Preview",
   getInitialState() {
     return {
-      documentTypes: {},
-      lastLiveEventId: null,
       subscriptions: {},
-      syncTags: {},
       values: {}
     };
   },
-  initialize() {
-    const subscribeToLiveAndSetLastLiveEventId = createLiveEventSubscriber(PREVIEW_TAG), stateSubscriptionForBatches = subscribeToStateAndFetchBatches$1(this), liveSubscription = subscribeToLiveAndSetLastLiveEventId(this);
-    return () => {
-      stateSubscriptionForBatches.unsubscribe(), liveSubscription.unsubscribe();
-    };
+  initialize: (context) => {
+    const subscription = subscribeToStateAndFetchBatches$1(context);
+    return () => subscription.unsubscribe;
   }
-}, _getPreviewState = createStateSourceAction(
+};
+function getPreviewState(...args) {
+  return _getPreviewState(...args);
+}
+const _getPreviewState = bindActionByDataset(
   previewStore,
-  (state, { document }) => state.values[document._id] ?? STABLE_EMPTY_PREVIEW
-), getPreviewState = createAction(previewStore, ({ state }) => function({ document }) {
-  const { _id, _type: documentType } = document, documentId = getPublishedId(_id), previewState = _getPreviewState(this, { document });
-  return {
-    ...previewState,
-    subscribe: (subscriber) => {
-      const subscriptionId = insecureRandomId();
-      state.set("addSubscription", (prev) => ({
-        documentTypes: {
-          ...prev.documentTypes,
-          [documentId]: documentType
-        },
+  createStateSourceAction({
+    selector: ({ state }, docHandle) => state.values[docHandle.documentId] ?? STABLE_EMPTY_PREVIEW,
+    onSubscribe: ({ state }, docHandle) => {
+      const subscriptionId = insecureRandomId(), documentId = getPublishedId(docHandle.documentId);
+      return state.set("addSubscription", (prev) => ({
         subscriptions: {
           ...prev.subscriptions,
           [documentId]: {
@@ -4402,10 +4609,8 @@ const BATCH_DEBOUNCE_TIME$1 = 50, subscribeToStateAndFetchBatches$1 = createInte
             [subscriptionId]: !0
           }
         }
-      }));
-      const unsubscribe = previewState.subscribe(subscriber);
-      return () => {
-        unsubscribe(), state.set("removeSubscription", (prev) => {
+      })), () => {
+        state.set("removeSubscription", (prev) => {
           const documentSubscriptions = omit(prev.subscriptions[documentId], subscriptionId), hasSubscribers = !!Object.keys(documentSubscriptions).length, prevValue = prev.values[documentId], previewValue = prevValue?.data ? prevValue.data : null;
           return {
             subscriptions: hasSubscribers ? { ...prev.subscriptions, [documentId]: documentSubscriptions } : omit(prev.subscriptions, documentId),
@@ -4414,40 +4619,46 @@ const BATCH_DEBOUNCE_TIME$1 = 50, subscribeToStateAndFetchBatches$1 = createInte
         });
       };
     }
-  };
-}), resolvePreview = createAction(previewStore, () => function({ document }) {
-  const { getCurrent, subscribe } = getPreviewState(this, { document });
-  return new Promise((resolve) => {
-    const unsubscribe = subscribe(() => {
-      const current = getCurrent();
-      current?.data && (resolve(current), unsubscribe());
-    });
-  });
-}), project = createFetcherStore({
+  })
+), resolvePreview = bindActionByDataset(
+  previewStore,
+  ({ instance }, docHandle) => firstValueFrom(getPreviewState(instance, docHandle).observable.pipe(filter((i2) => !!i2.data)))
+), API_VERSION$2 = "v2025-02-19", project = createFetcherStore({
   name: "Project",
-  getKey: (projectId) => projectId,
-  fetcher: (instance) => (projectId) => getClientState(instance, { apiVersion: "vX", scope: "global" }).observable.pipe(
-    switchMap((client) => client.observable.projects.getById(projectId))
-  )
-}), getProjectState = project.getState, resolveProject = project.resolveState, PROJECTION_TAG = "sdk.projection", STABLE_EMPTY_PROJECTION = {
-  data: null,
-  isPending: !1
-};
-function validateProjection(projection) {
-  if (!projection.startsWith("{") || !projection.endsWith("}"))
-    throw new Error(
-      `Invalid projection format: "${projection}". Projections must be enclosed in curly braces, e.g. "{title, 'author': author.name}"`
+  getKey: (instance, options) => {
+    const projectId = options?.projectId ?? instance.config.projectId;
+    if (!projectId)
+      throw new Error("A projectId is required to use the project API.");
+    return projectId;
+  },
+  fetcher: (instance) => (options = {}) => {
+    const projectId = options.projectId ?? instance.config.projectId;
+    return getClientState(instance, {
+      apiVersion: API_VERSION$2,
+      scope: "global",
+      projectId
+    }).observable.pipe(
+      switchMap(
+        (client) => client.observable.projects.getById(
+          // non-null assertion is fine with the above throwing
+          projectId ?? instance.config.projectId
+        )
+      )
     );
-  return projection;
-}
+  }
+}), getProjectState = project.getState, resolveProject = project.resolveState;
 function createProjectionQuery(documentIds, documentProjections) {
-  const projections = Array.from(documentIds).filter((id) => documentProjections[id]).map((id) => {
-    const projection = validateProjection(documentProjections[id]), projectionHash = hashString(projection);
-    return { documentId: id, projection, projectionHash };
+  const projections = Array.from(documentIds).flatMap((id) => {
+    const projectionsForDoc = documentProjections[id];
+    return projectionsForDoc ? Object.entries(projectionsForDoc).map(([projectionHash, projection]) => ({
+      documentId: id,
+      projection,
+      projectionHash
+    })) : [];
   }).reduce((acc, { documentId, projection, projectionHash }) => {
     const obj = acc[projectionHash] ?? { documentIds: /* @__PURE__ */ new Set(), projection };
     return obj.documentIds.add(documentId), acc[projectionHash] = obj, acc;
-  }, {}), query = `[${Object.entries(projections).map(([projectionHash, { projection }]) => `...*[_id in $__ids_${projectionHash}]{_id,_type,_updatedAt,"result":{...${projection}}}`).join(",")}]`, params = Object.fromEntries(
+  }, {}), query = `[${Object.entries(projections).map(([projectionHash, { projection }]) => `...*[_id in $__ids_${projectionHash}]{_id,_type,_updatedAt,"__projectionHash":"${projectionHash}","result":{...${projection}}}`).join(",")}]`, params = Object.fromEntries(
     Object.entries(projections).map(([projectionHash, value]) => {
       const idsInProjection = Array.from(value.documentIds).flatMap((id) => [
         getPublishedId(id),
@@ -4459,408 +4670,397 @@ function createProjectionQuery(documentIds, documentProjections) {
   return { query, params };
 }
 function processProjectionQuery({ ids, results }) {
-  const resultMap = results.reduce(
-    (acc, next) => (acc[next._id] = next, acc),
-    {}
-  );
-  return Object.fromEntries(
-    Array.from(ids).map((id) => {
-      const publishedId = getPublishedId(id), draftId = getDraftId(id), draftResult = resultMap[draftId], publishedResult = resultMap[publishedId], projectionResult = draftResult?.result ?? publishedResult?.result;
-      if (!projectionResult) return [id, { data: null, isPending: !1 }];
-      const status = {
-        ...draftResult?._updatedAt && { lastEditedDraftAt: draftResult._updatedAt },
-        ...publishedResult?._updatedAt && { lastEditedPublishedAt: publishedResult._updatedAt }
-      };
-      return [id, { data: { ...projectionResult, status }, isPending: !1 }];
-    })
-  );
+  const groupedResults = {};
+  for (const result of results) {
+    const originalId = getPublishedId(result._id), hash = result.__projectionHash, isDraft = result._id.startsWith("drafts.");
+    ids.has(originalId) && (groupedResults[originalId] || (groupedResults[originalId] = {}), groupedResults[originalId][hash] || (groupedResults[originalId][hash] = {}), isDraft ? groupedResults[originalId][hash].draft = result : groupedResults[originalId][hash].published = result);
+  }
+  const finalValues = {};
+  for (const originalId of ids) {
+    finalValues[originalId] = {};
+    const projectionsForDoc = groupedResults[originalId];
+    if (projectionsForDoc)
+      for (const hash in projectionsForDoc) {
+        const { draft, published } = projectionsForDoc[hash], projectionResultData = draft?.result ?? published?.result;
+        if (!projectionResultData) {
+          finalValues[originalId][hash] = { data: null, isPending: !1 };
+          continue;
+        }
+        const status = {
+          ...draft?._updatedAt && { lastEditedDraftAt: draft._updatedAt },
+          ...published?._updatedAt && { lastEditedPublishedAt: published._updatedAt }
+        };
+        finalValues[originalId][hash] = {
+          data: { ...projectionResultData, status },
+          isPending: !1
+        };
+      }
+  }
+  return finalValues;
 }
-const BATCH_DEBOUNCE_TIME = 50, subscribeToStateAndFetchBatches = createInternalAction(
-  ({ state, instance }) => function() {
-    const client$ = new Observable(
-      (observer) => getClientState(instance, { apiVersion: "vX" }).observable.subscribe(observer)
-    ), documentProjections$ = state.observable.pipe(
-      map((i2) => i2.documentProjections),
-      distinctUntilChanged()
-    ), lastLiveEventId$ = state.observable.pipe(
-      map((i2) => i2.lastLiveEventId),
-      distinctUntilChanged()
-    ), newSubscriberIds$ = state.observable.pipe(
-      map(({ subscriptions }) => new Set(Object.keys(subscriptions))),
-      distinctUntilChanged(
-        (a2, b2) => a2.size !== b2.size ? !1 : Array.from(a2).every((i2) => b2.has(i2))
-      ),
-      debounceTime(BATCH_DEBOUNCE_TIME),
-      startWith$1(/* @__PURE__ */ new Set()),
-      pairwise$1(),
-      tap$1(([prevIds, currIds]) => {
-        const newIds = [...currIds].filter((element) => !prevIds.has(element));
-        state.set("updatingPending", (prev) => {
-          const pendingValues = newIds.reduce((acc, id) => {
-            const prevValue = prev.values[id], value = prevValue?.data ? prevValue.data : null;
-            return acc[id] = { data: value, isPending: !0 }, acc;
-          }, {});
-          return { values: { ...prev.values, ...pendingValues } };
-        });
-      }),
-      withLatestFrom(documentProjections$),
-      map(([[, ids], documentProjections]) => ({ ids, documentProjections }))
+const PROJECTION_TAG = "sdk.projection", PROJECTION_PERSPECTIVE = "drafts", PROJECTION_STATE_CLEAR_DELAY = 1e3, STABLE_EMPTY_PROJECTION = {
+  data: null,
+  isPending: !1
+};
+function validateProjection(projection) {
+  if (!projection.startsWith("{") || !projection.endsWith("}"))
+    throw new Error(
+      `Invalid projection format: "${projection}". Projections must be enclosed in curly braces, e.g. "{title, 'author': author.name}"`
     );
-    return combineLatest([newSubscriberIds$, lastLiveEventId$, client$]).pipe(
-      switchMap(([{ ids, documentProjections }, lastLiveEventId, client]) => {
-        if (!ids.size) return EMPTY;
-        const { query, params } = createProjectionQuery(ids, documentProjections);
-        return client.observable.fetch(query, params, {
-          filterResponse: !1,
-          returnQuery: !1,
-          perspective: "drafts",
+  return projection;
+}
+const BATCH_DEBOUNCE_TIME = 50, isSetEqual = (a2, b2) => a2.size === b2.size && Array.from(a2).every((i2) => b2.has(i2)), subscribeToStateAndFetchBatches = ({
+  state,
+  instance
+}) => {
+  const documentProjections$ = state.observable.pipe(
+    map((s2) => s2.documentProjections),
+    distinctUntilChanged(isEqual)
+  ), activeDocumentIds$ = state.observable.pipe(
+    map(({ subscriptions }) => new Set(Object.keys(subscriptions))),
+    distinctUntilChanged(isSetEqual)
+  ), pendingUpdateSubscription = activeDocumentIds$.pipe(
+    debounceTime(BATCH_DEBOUNCE_TIME),
+    startWith$1(/* @__PURE__ */ new Set()),
+    pairwise$1(),
+    tap$1(([prevIds, currIds]) => {
+      const newIds = [...currIds].filter((id) => !prevIds.has(id));
+      newIds.length !== 0 && state.set("updatingPending", (prev) => {
+        const nextValues = { ...prev.values };
+        for (const id of newIds) {
+          const projectionsForDoc = prev.documentProjections[id];
+          if (!projectionsForDoc) continue;
+          const updatedValuesForDoc = { ...prev.values[id] ?? {} };
+          for (const hash in projectionsForDoc) {
+            const currentValue = updatedValuesForDoc[hash];
+            updatedValuesForDoc[hash] = {
+              data: currentValue?.data ?? null,
+              isPending: !0
+            };
+          }
+          nextValues[id] = updatedValuesForDoc;
+        }
+        return { values: nextValues };
+      });
+    })
+  ).subscribe(), queryExecutionSubscription = combineLatest([activeDocumentIds$, documentProjections$]).pipe(
+    debounceTime(BATCH_DEBOUNCE_TIME),
+    distinctUntilChanged(isEqual)
+  ).pipe(
+    switchMap(([ids, documentProjections]) => {
+      if (!ids.size) return EMPTY;
+      const { query, params } = createProjectionQuery(ids, documentProjections), controller = new AbortController();
+      return new Observable((observer) => {
+        const { getCurrent, observable } = getQueryState(instance, query, {
+          params,
           tag: PROJECTION_TAG,
-          lastLiveEventId
-        }).pipe(map((response) => ({ ...response, ids })));
-      }),
-      map(({ ids, result, syncTags }) => ({
-        syncTags,
-        values: processProjectionQuery({
-          ids,
-          results: result
-        })
-      }))
-    ).subscribe({
-      next: ({ syncTags = [], values }) => {
-        state.set("updateResult", (prev) => ({
-          values: { ...prev.values, ...values },
-          syncTags: syncTags.reduce((acc, next) => (acc[next] = !0, acc), {})
-        }));
-      }
-    });
-  }
-), projectionStore = {
+          perspective: PROJECTION_PERSPECTIVE
+        }), subscription = defer(() => getCurrent() === void 0 ? from(
+          resolveQuery(instance, query, {
+            params,
+            tag: PROJECTION_TAG,
+            perspective: PROJECTION_PERSPECTIVE,
+            signal: controller.signal
+          })
+        ).pipe(switchMap(() => observable)) : observable).pipe(filter((result) => result !== void 0)).subscribe(observer);
+        return () => {
+          controller.signal.aborted || controller.abort(), subscription.unsubscribe();
+        };
+      }).pipe(map((data) => ({ data, ids })));
+    }),
+    map(
+      ({ ids, data }) => processProjectionQuery({
+        ids,
+        results: data
+      })
+    )
+  ).subscribe({
+    next: (processedValues) => {
+      state.set("updateResult", (prev) => {
+        const nextValues = { ...prev.values };
+        for (const docId in processedValues)
+          processedValues[docId] && (nextValues[docId] = {
+            ...prev.values[docId] ?? {},
+            ...processedValues[docId]
+          });
+        return { values: nextValues };
+      });
+    },
+    error: (err) => {
+      console.error("Error fetching projection batches:", err);
+    }
+  });
+  return new Subscription(() => {
+    pendingUpdateSubscription.unsubscribe(), queryExecutionSubscription.unsubscribe();
+  });
+}, projectionStore = {
   name: "Projection",
   getInitialState() {
     return {
       values: {},
       documentProjections: {},
-      subscriptions: {},
-      syncTags: {},
-      lastLiveEventId: null
+      subscriptions: {}
     };
   },
-  initialize() {
-    const liveSubscription = createLiveEventSubscriber(PROJECTION_TAG)(this), batchSubscription = subscribeToStateAndFetchBatches(this);
-    return () => {
-      liveSubscription.unsubscribe(), batchSubscription.unsubscribe();
-    };
+  initialize(context) {
+    const batchSubscription = subscribeToStateAndFetchBatches(context);
+    return () => batchSubscription.unsubscribe();
   }
-}, getProjectStateSourceAction = createStateSourceAction(
-  projectionStore,
-  (state, { document }) => state.values[document._id] ?? STABLE_EMPTY_PROJECTION
-);
+};
 function getProjectionState(...args) {
   return _getProjectionState(...args);
 }
-const _getProjectionState = createAction(projectionStore, ({ state }) => function({
-  document,
-  projection
-}) {
-  const { _id } = document, documentId = getPublishedId(_id), projectionState = getProjectStateSourceAction(this, { document, projection });
-  return {
-    ...projectionState,
-    subscribe: (subscriber) => {
-      const subscriptionId = insecureRandomId();
-      state.set("addSubscription", (prev) => ({
+const _getProjectionState = bindActionByDataset(
+  projectionStore,
+  createStateSourceAction({
+    selector: ({ state }, options) => {
+      const documentId = getPublishedId(options.documentId), projectionHash = hashString(options.projection);
+      return state.values[documentId]?.[projectionHash] ?? STABLE_EMPTY_PROJECTION;
+    },
+    onSubscribe: ({ state }, { projection, ...docHandle }) => {
+      const subscriptionId = insecureRandomId(), documentId = getPublishedId(docHandle.documentId), validProjection = validateProjection(projection), projectionHash = hashString(validProjection);
+      return state.set("addSubscription", (prev) => ({
         documentProjections: {
           ...prev.documentProjections,
-          [documentId]: validateProjection(projection)
+          [documentId]: {
+            ...prev.documentProjections[documentId],
+            [projectionHash]: validProjection
+          }
         },
         subscriptions: {
           ...prev.subscriptions,
           [documentId]: {
             ...prev.subscriptions[documentId],
-            [subscriptionId]: !0
+            [projectionHash]: {
+              ...prev.subscriptions[documentId]?.[projectionHash],
+              [subscriptionId]: !0
+            }
           }
         }
-      }));
-      const unsubscribe = projectionState.subscribe(subscriber);
-      return () => {
-        unsubscribe(), state.set("removeSubscription", (prev) => {
-          const documentSubscriptions = omit(prev.subscriptions[documentId], subscriptionId), hasSubscribers = !!Object.keys(documentSubscriptions).length, prevValue = prev.values[documentId], projectionValue = prevValue?.data ? prevValue.data : null;
-          return {
-            subscriptions: hasSubscribers ? { ...prev.subscriptions, [documentId]: documentSubscriptions } : omit(prev.subscriptions, documentId),
-            values: hasSubscribers ? prev.values : { ...prev.values, [documentId]: { data: projectionValue, isPending: !1 } }
-          };
-        });
+      })), () => {
+        setTimeout(() => {
+          state.set("removeSubscription", (prev) => {
+            const documentSubscriptionsForHash = omit(
+              prev.subscriptions[documentId]?.[projectionHash],
+              subscriptionId
+            ), hasSubscribersForProjection = !!Object.keys(documentSubscriptionsForHash).length, nextSubscriptions = { ...prev.subscriptions }, nextDocumentProjections = { ...prev.documentProjections }, nextValues = { ...prev.values };
+            if (hasSubscribersForProjection)
+              nextSubscriptions[documentId] && (nextSubscriptions[documentId][projectionHash] = documentSubscriptionsForHash);
+            else {
+              delete nextSubscriptions[documentId][projectionHash], delete nextDocumentProjections[documentId][projectionHash];
+              const currentProjectionValue = prev.values[documentId]?.[projectionHash];
+              currentProjectionValue && nextValues[documentId] && (nextValues[documentId][projectionHash] = {
+                data: currentProjectionValue.data,
+                isPending: !1
+              });
+            }
+            return Object.values(
+              nextSubscriptions[documentId] ?? {}
+            ).some((subs) => Object.keys(subs).length > 0) || (delete nextSubscriptions[documentId], delete nextDocumentProjections[documentId]), {
+              subscriptions: nextSubscriptions,
+              documentProjections: nextDocumentProjections,
+              values: nextValues
+            };
+          });
+        }, PROJECTION_STATE_CLEAR_DELAY);
       };
     }
-  };
-}), resolveProjection = createAction(projectionStore, () => function({ document, projection }) {
-  const { getCurrent, subscribe } = getProjectionState(this, { document, projection });
-  return new Promise((resolve) => {
-    const unsubscribe = subscribe(() => {
-      const current = getCurrent();
-      current?.data && (resolve(current), unsubscribe());
-    });
-  });
-}), projects = createFetcherStore({
+  })
+), resolveProjection = bindActionByDataset(
+  projectionStore,
+  ({ instance }, { projection, ...docHandle }) => firstValueFrom(
+    getProjectionState(instance, { ...docHandle, projection }).observable.pipe(
+      filter((i2) => !!i2.data)
+    )
+  )
+), API_VERSION$1 = "v2025-02-19", projects = createFetcherStore({
   name: "Projects",
   getKey: () => "projects",
-  fetcher: (instance) => () => getClientState(instance, { apiVersion: "vX", scope: "global" }).observable.pipe(
+  fetcher: (instance) => () => getClientState(instance, {
+    apiVersion: API_VERSION$1,
+    scope: "global"
+  }).observable.pipe(
     switchMap((client) => client.observable.projects.list({ includeMembers: !1 }))
   )
-}), getProjectsState = projects.getState, resolveProjects = projects.resolveState, QUERY_STATE_CLEAR_DELAY = 1e3, setQueryError = (key, error) => (prev) => {
-  const prevQuery = prev.queries[key];
-  return prevQuery ? { ...prev, queries: { ...prev.queries, [key]: { ...prevQuery, error } } } : prev;
-}, setQueryData = (key, result, syncTags) => (prev) => {
-  const prevQuery = prev.queries[key];
-  return prevQuery ? {
-    ...prev,
-    queries: { ...prev.queries, [key]: { ...prevQuery, result: result ?? null, syncTags } }
-  } : prev;
-}, setLastLiveEventId = (key, lastLiveEventId) => (prev) => {
-  const prevQuery = prev.queries[key];
-  return prevQuery ? { ...prev, queries: { ...prev.queries, [key]: { ...prevQuery, lastLiveEventId } } } : prev;
-}, addSubscriber = (key, subscriptionId) => (prev) => {
-  const prevQuery = prev.queries[key], subscribers = [...prevQuery?.subscribers ?? [], subscriptionId];
-  return { ...prev, queries: { ...prev.queries, [key]: { ...prevQuery, subscribers } } };
-}, removeSubscriber = (key, subscriptionId) => (prev) => {
-  const prevQuery = prev.queries[key];
-  if (!prevQuery) return prev;
-  const subscribers = prevQuery.subscribers.filter((id) => id !== subscriptionId);
-  return subscribers.length ? { ...prev, queries: { ...prev.queries, [key]: { ...prevQuery, subscribers } } } : { ...prev, queries: omit(prev.queries, key) };
-}, cancelQuery = (key) => (prev) => {
-  const prevQuery = prev.queries[key];
-  return !prevQuery || prevQuery.subscribers.length ? prev : { ...prev, queries: omit(prev.queries, key) };
-}, initializeQuery = (key) => (prev) => prev.queries[key] ? prev : { ...prev, queries: { ...prev.queries, [key]: { subscribers: [] } } }, EMPTY_ARRAY = [], getQueryKey = (query, options = {}) => JSON.stringify({ query, options }), parseQueryKey = (key) => JSON.parse(key), queryStore = {
-  name: "QueryStore",
-  getInitialState: () => ({ queries: {} }),
-  initialize() {
-    const subscriptions = [
-      listenForNewSubscribersAndFetch(this),
-      listenToLiveClientAndSetLastLiveEventIds(this)
-    ];
-    return () => {
-      for (const subscription of subscriptions)
-        subscription.unsubscribe();
-    };
-  }
-}, errorHandler = createInternalAction(({ state }) => function() {
-  return (error) => state.set("setError", { error });
-}), listenForNewSubscribersAndFetch = createInternalAction(
-  ({ state, instance }) => function() {
-    return state.observable.pipe(
-      map((s2) => new Set(Object.keys(s2.queries))),
-      distinctUntilChanged((curr, next) => curr.size !== next.size ? !1 : Array.from(next).every((i2) => curr.has(i2))),
-      startWith$1(/* @__PURE__ */ new Set()),
-      pairwise$1(),
-      mergeMap$1(([curr, next]) => {
-        const added = Array.from(next).filter((i2) => !curr.has(i2)), removed = Array.from(curr).filter((i2) => !next.has(i2));
-        return [
-          ...added.map((key) => ({ key, added: !0 })),
-          ...removed.map((key) => ({ key, added: !1 }))
-        ];
-      }),
-      groupBy$1((i2) => i2.key),
-      mergeMap$1(
-        (group$) => group$.pipe(
-          switchMap((e3) => {
-            if (!e3.added) return EMPTY;
-            const lastLiveEventId$ = state.observable.pipe(
-              map((s2) => s2.queries[group$.key]?.lastLiveEventId),
-              distinctUntilChanged()
-            ), { query, options: { params, scope, ...options } = {} } = parseQueryKey(group$.key), client$ = getClientState(instance, { apiVersion: "vX", scope }).observable;
-            return combineLatest([lastLiveEventId$, client$]).pipe(
-              switchMap(
-                ([lastLiveEventId, client]) => client.observable.fetch(query, params, {
-                  ...options,
-                  filterResponse: !1,
-                  returnQuery: !1,
-                  lastLiveEventId
-                })
-              )
-            );
-          }),
-          catchError$1((error) => (state.set("setQueryError", setQueryError(group$.key, error)), EMPTY)),
-          tap$1(({ result, syncTags }) => {
-            state.set("setQueryData", setQueryData(group$.key, result, syncTags));
-          })
-        )
-      )
-    ).subscribe({ error: errorHandler(this) });
+}), getProjectsState = projects.getState, resolveProjects = projects.resolveState, API_VERSION = "vX", USERS_STATE_CLEAR_DELAY = 5e3, DEFAULT_USERS_BATCH_SIZE = 100, getUsersKey = (instance, {
+  resourceType,
+  organizationId,
+  batchSize = DEFAULT_USERS_BATCH_SIZE,
+  projectId = instance.config.projectId
+} = {}) => JSON.stringify({ resourceType, organizationId, batchSize, projectId }), parseUsersKey = (key) => JSON.parse(key), addSubscription = (subscriptionId, key) => (prev) => {
+  const group = prev.users[key], subscriptions = [...group?.subscriptions ?? [], subscriptionId];
+  return { ...prev, users: { ...prev.users, [key]: { ...group, subscriptions } } };
+}, removeSubscription = (subscriptionId, key) => (prev) => {
+  const group = prev.users[key];
+  if (!group) return prev;
+  const subscriptions = group.subscriptions.filter((id) => id !== subscriptionId);
+  return subscriptions.length ? { ...prev, users: { ...prev.users, [key]: { ...group, subscriptions } } } : { ...prev, users: omit(prev.users, key) };
+}, setUsersData = (key, { data, nextCursor, totalCount }) => (prev) => {
+  const group = prev.users[key];
+  if (!group) return prev;
+  const users = [...group.users ?? [], ...data];
+  return { ...prev, users: { ...prev.users, [key]: { ...group, users, totalCount, nextCursor } } };
+}, updateLastLoadMoreRequest = (timestamp, key) => (prev) => {
+  const group = prev.users[key];
+  return group ? { ...prev, users: { ...prev.users, [key]: { ...group, lastLoadMoreRequest: timestamp } } } : prev;
+}, setUsersError = (key, error) => (prev) => {
+  const group = prev.users[key];
+  return group ? { ...prev, users: { ...prev.users, [key]: { ...group, error } } } : prev;
+}, cancelRequest = (key) => (prev) => {
+  const group = prev.users[key];
+  return !group || group.subscriptions.length ? prev : { ...prev, users: omit(prev.users, key) };
+}, initializeRequest = (key) => (prev) => prev.users[key] ? prev : { ...prev, users: { ...prev.users, [key]: { subscriptions: [] } } }, usersStore = {
+  name: "UsersStore",
+  getInitialState: () => ({ users: {} }),
+  initialize: (context) => {
+    const subscription = listenForLoadMoreAndFetch(context);
+    return () => subscription.unsubscribe();
   }
-), listenToLiveClientAndSetLastLiveEventIds = createInternalAction(
-  ({ state, instance }) => function() {
-    const liveMessages$ = getClientState(instance, { apiVersion: "vX" }).observable.pipe(
-      switchMap(
-        (client) => client.live.events({ includeDrafts: !!client.config().token, tag: "query-store" })
-      ),
-      share(),
-      filter((e3) => e3.type === "message")
-    );
-    return state.observable.pipe(
-      mergeMap$1((s2) => Object.entries(s2.queries)),
-      groupBy$1(([key]) => key),
-      mergeMap$1((group$) => {
-        const syncTags$ = group$.pipe(
-          map(([, queryState]) => queryState),
-          map((i2) => i2?.syncTags ?? EMPTY_ARRAY),
+}, errorHandler = (state) => (error) => state.set("setError", { error }), listenForLoadMoreAndFetch = ({ state, instance }) => state.observable.pipe(
+  map((s2) => new Set(Object.keys(s2.users))),
+  distinctUntilChanged((curr, next) => curr.size !== next.size ? !1 : Array.from(next).every((i2) => curr.has(i2))),
+  startWith$1(/* @__PURE__ */ new Set()),
+  pairwise$1(),
+  mergeMap$1(([curr, next]) => {
+    const added = Array.from(next).filter((i2) => !curr.has(i2)), removed = Array.from(curr).filter((i2) => !next.has(i2));
+    return [
+      ...added.map((key) => ({ key, added: !0 })),
+      ...removed.map((key) => ({ key, added: !1 }))
+    ];
+  }),
+  groupBy$1((i2) => i2.key),
+  mergeMap$1(
+    (group$) => group$.pipe(
+      switchMap((e3) => {
+        if (!e3.added) return EMPTY;
+        const { batchSize, ...options } = parseUsersKey(group$.key), projectId = options.projectId ?? instance.config.projectId, resourceType = options.resourceType ?? (options.organizationId ? "organization" : projectId ? "project" : "organization"), organizationId$ = options.organizationId ? of(options.organizationId) : getDashboardOrganizationId(instance).observable.pipe(
+          filter((i2) => typeof i2 == "string")
+        ), resource$ = resourceType === "project" ? projectId ? of({ type: "project", id: projectId }) : throwError(() => new Error("Project ID required for this API.")) : organizationId$.pipe(map((id) => ({ type: "organization", id }))), client$ = getClientState(instance, {
+          scope: "global",
+          apiVersion: API_VERSION
+        }).observable, loadMore$ = state.observable.pipe(
+          map((s2) => s2.users[group$.key]?.lastLoadMoreRequest),
           distinctUntilChanged()
+        ), cursor$ = state.observable.pipe(
+          map((s2) => s2.users[group$.key]?.nextCursor),
+          distinctUntilChanged(),
+          filter((cursor) => cursor !== null)
         );
-        return combineLatest([liveMessages$, syncTags$]).pipe(
-          filter(([message, syncTags]) => message.tags.some((tag) => syncTags.includes(tag))),
-          tap$1(([message]) => {
-            state.set("setLastLiveEventId", setLastLiveEventId(group$.key, message.id));
-          })
+        return combineLatest([resource$, client$, loadMore$]).pipe(
+          withLatestFrom(cursor$),
+          switchMap(
+            ([[resource, client], cursor]) => client.observable.request({
+              method: "GET",
+              uri: `access/${resource.type}/${resource.id}/users`,
+              query: cursor ? { nextCursor: cursor, limit: batchSize.toString() } : { limit: batchSize.toString() }
+            })
+          ),
+          catchError$1((error) => (state.set("setUsersError", setUsersError(group$.key, error)), EMPTY)),
+          tap$1((response) => state.set("setUsersData", setUsersData(group$.key, response)))
         );
       })
-    ).subscribe({ error: errorHandler(this) });
-  }
-);
-function getQueryState(...args) {
-  return _getQueryState(...args);
-}
-const _getQueryState = createStateSourceAction(queryStore, {
-  selector: (state, query, options) => {
-    if (state.error) throw state.error;
-    const key = getQueryKey(query, options), queryState = state.queries[key];
-    if (queryState?.error) throw queryState.error;
-    return queryState?.result;
-  },
-  onSubscribe: ({ state }, query, options) => {
-    const subscriptionId = insecureRandomId(), key = getQueryKey(query, options);
-    return state.set("addSubscriber", addSubscriber(key, subscriptionId)), () => {
-      setTimeout(
-        () => state.set("removeSubscriber", removeSubscriber(key, subscriptionId)),
-        QUERY_STATE_CLEAR_DELAY
-      );
-    };
-  }
-});
-function resolveQuery(...args) {
-  return _resolveQuery(...args);
-}
-const _resolveQuery = createAction(queryStore, ({ state }) => function(query, { signal, ...options } = {}) {
-  const { getCurrent } = getQueryState(this, query, options), key = getQueryKey(query, options), aborted$ = signal ? new Observable((observer) => {
-    const cleanup = () => {
-      signal.removeEventListener("abort", listener);
-    }, listener = () => {
-      observer.error(new DOMException("The operation was aborted.", "AbortError")), observer.complete(), cleanup();
-    };
-    return signal.addEventListener("abort", listener), cleanup;
-  }).pipe(
-    catchError$1((error) => {
-      throw error instanceof Error && error.name === "AbortError" && state.set("cancelQuery", cancelQuery(key)), error;
-    })
-  ) : NEVER;
-  state.set("initializeQuery", initializeQuery(key));
-  const resolved$ = state.observable.pipe(
-    map(getCurrent),
-    first$1((i2) => i2 !== void 0)
-  );
-  return firstValueFrom(race([resolved$, aborted$]));
-});
-function createStore(resource, actions) {
-  return function(dependencies) {
-    const instance = "instance" in dependencies ? dependencies.instance : dependencies, { state, dispose } = "state" in dependencies ? { state: dependencies.state, dispose: noop } : initializeResource(instance, resource), boundActions = Object.entries(actions).reduce((acc, [key, action]) => (acc[key] = action.bind(null, { state, instance }), acc), {});
-    return { dispose, ...boundActions };
-  };
-}
-const API_VERSION = "vX", usersStore = {
-  name: "users",
-  getInitialState: () => ({
-    users: [],
-    totalCount: 0,
-    nextCursor: null,
-    hasMore: !1,
-    initialFetchCompleted: !1,
-    options: {
-      resourceType: "",
-      resourceId: "",
-      limit: 100
+    )
+  )
+).subscribe({ error: errorHandler(state) }), getUsersState = bindActionGlobally(
+  usersStore,
+  createStateSourceAction({
+    selector: createSelector(
+      [
+        ({ instance, state }, options) => state.error ?? state.users[getUsersKey(instance, options)]?.error,
+        ({ instance, state }, options) => state.users[getUsersKey(instance, options)]?.users,
+        ({ instance, state }, options) => state.users[getUsersKey(instance, options)]?.totalCount,
+        ({ instance, state }, options) => state.users[getUsersKey(instance, options)]?.nextCursor
+      ],
+      (error, data, totalCount, nextCursor) => {
+        if (error) throw error;
+        if (!(data === void 0 || totalCount === void 0 || nextCursor === void 0))
+          return { data, totalCount, hasMore: nextCursor !== null };
+      }
+    ),
+    onSubscribe: ({ instance, state }, options) => {
+      const subscriptionId = insecureRandomId(), key = getUsersKey(instance, options);
+      return state.set("addSubscription", addSubscription(subscriptionId, key)), () => {
+        setTimeout(
+          () => state.set("removeSubscription", removeSubscription(subscriptionId, key)),
+          USERS_STATE_CLEAR_DELAY
+        );
+      };
     }
-  }),
-  initialize() {
-    return () => {
-    };
+  })
+), resolveUsers = bindActionGlobally(
+  usersStore,
+  async ({ state, instance }, { signal, ...options }) => {
+    const key = getUsersKey(instance, options), { getCurrent } = getUsersState(instance, options), aborted$ = signal ? new Observable((observer) => {
+      const cleanup = () => {
+        signal.removeEventListener("abort", listener);
+      }, listener = () => {
+        observer.error(new DOMException("The operation was aborted.", "AbortError")), observer.complete(), cleanup();
+      };
+      return signal.addEventListener("abort", listener), cleanup;
+    }).pipe(
+      catchError$1((error) => {
+        throw error instanceof Error && error.name === "AbortError" && state.set("cancelRequest", cancelRequest(key)), error;
+      })
+    ) : NEVER;
+    state.set("initializeRequest", initializeRequest(key));
+    const resolved$ = state.observable.pipe(
+      map(getCurrent),
+      first$1((i2) => i2 !== void 0)
+    );
+    return firstValueFrom(race([resolved$, aborted$]));
   }
-}, getState = createStateSourceAction(
+), loadMoreUsers = bindActionGlobally(
   usersStore,
-  createSelector(
-    [
-      (state) => state.users,
-      (state) => state.totalCount,
-      (state) => state.nextCursor,
-      (state) => state.hasMore,
-      (state) => state.initialFetchCompleted,
-      (state) => state.options
-    ],
-    (users, totalCount, nextCursor, hasMore, initialFetchCompleted, options) => ({
-      users,
-      totalCount,
-      nextCursor,
-      hasMore,
-      options,
-      initialFetchCompleted
-    })
-  )
-), fetchUsers = (instance, params) => {
-  const { resourceType, resourceId, nextCursor, limit = 100 } = params;
-  return getClient(instance, { scope: "global", apiVersion: API_VERSION }).request({
-    method: "GET",
-    uri: `access/${resourceType}/${resourceId}/users`,
-    query: nextCursor ? { nextCursor, limit: limit.toString() } : { limit: limit.toString() },
-    tag: "users"
-  });
-}, loadMore = createAction(usersStore, ({ state, instance }) => async function() {
-  const { users, nextCursor, options } = state.get(), { resourceType, resourceId, limit } = options;
-  if (!resourceType || !resourceId)
-    throw new Error("Resource type and ID are required to load more users");
-  const response = await fetchUsers(instance, { resourceType, resourceId, nextCursor, limit }), allUsers = [...users, ...response.data], hasMore = allUsers.length < response.totalCount;
-  state.set("loadMore", {
-    users: allUsers,
-    totalCount: response.totalCount,
-    nextCursor: response.nextCursor,
-    hasMore
-  });
-}), resolveUsers = createAction(usersStore, ({ state, instance }) => async function() {
-  const { options } = state.get(), { resourceType, resourceId, limit } = options;
-  if (!resourceType || !resourceId)
-    throw new Error("Resource type and ID are required to resolve users");
-  const response = await fetchUsers(instance, { resourceType, resourceId, limit }), hasMore = response.data.length < response.totalCount;
-  return state.set("resolveUsers", {
-    users: response.data,
-    totalCount: response.totalCount,
-    nextCursor: response.nextCursor,
-    hasMore,
-    initialFetchCompleted: !0
-  }), response;
-}), setOptions = createAction(usersStore, ({ state }) => function(options) {
-  state.set("options", {
-    ...state.get(),
-    options: {
-      ...state.get().options,
-      resourceType: options.resourceType,
-      resourceId: options.resourceId
-    }
-  });
-}), createUsersStore = createStore(usersStore, {
-  getState,
-  loadMore,
-  resolveUsers,
-  setOptions
-});
-var version = "0.0.0-chore-react-18-compat.1";
+  async ({ state, instance }, options) => {
+    const key = getUsersKey(instance, options), users = getUsersState(instance, options), usersState = users.getCurrent();
+    if (!usersState)
+      throw new Error("Users not loaded for specified resource. Please call resolveUsers first.");
+    if (!usersState.hasMore)
+      throw new Error("No more users available to load for this resource.");
+    const promise = firstValueFrom(
+      users.observable.pipe(
+        filter((i2) => i2 !== void 0),
+        skip(1)
+      )
+    ), timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    return state.set("updateLastLoadMoreRequest", updateLastLoadMoreRequest(timestamp, key)), await promise;
+  }
+), WILDCARD_TOKEN = "*", NEGATION_TOKEN = "-", TOKEN_REGEX = /(?:[^\s"]+|"[^"]*")+/g;
+function isNegationToken(token) {
+  return typeof token < "u" && token.trim().startsWith(NEGATION_TOKEN);
+}
+function isPrefixToken(token) {
+  return typeof token < "u" && token.trim().endsWith(WILDCARD_TOKEN);
+}
+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}${WILDCARD_TOKEN}`
+  ), `[@] match text::query("${processedTokens.join(" ").replace(/"/g, '\\"')}")`;
+}
+var version = "0.0.0-chore-react-18-compat.3";
 const CORE_SDK_VERSION = getEnv("PKG_VERSION") || `${version}-development`;
 export {
   AuthStateType,
   CORE_SDK_VERSION,
   applyDocumentActions,
   createDocument,
+  createGroqSearchFilter,
   createSanityInstance,
-  createUsersStore,
   deleteDocument,
   destroyController,
   discardDocument,
   editDocument,
-  fetchLoginUrls,
   getAuthState,
   getClient,
   getClientState,
@@ -4869,7 +5069,7 @@ export {
   getDatasetsState,
   getDocumentState,
   getDocumentSyncStatus,
-  getLoginUrlsState,
+  getLoginUrlState,
   getOrCreateChannel,
   getOrCreateController,
   getOrCreateNode,
@@ -4880,12 +5080,15 @@ export {
   getProjectsState,
   getQueryKey,
   getQueryState,
-  getResourceId,
   getTokenState,
+  getUsersKey,
+  getUsersState,
   handleAuthCallback,
   jsonMatch,
+  loadMoreUsers,
   logout,
   parseQueryKey,
+  parseUsersKey,
   publishDocument,
   releaseChannel,
   releaseNode,
@@ -4897,6 +5100,7 @@ export {
   resolveProjection,
   resolveProjects,
   resolveQuery,
+  resolveUsers,
   subscribeDocumentEvents,
   unpublishDocument
 };