@sanity/sdk 2.1.0 → 2.1.1

package/dist/index.js

@@ -1,5 +1,5 @@
 import { createClient } from "@sanity/client";
-import { Observable, share, map, distinctUntilChanged, skip, filter, exhaustMap, timer, from, takeWhile, switchMap, firstValueFrom, fromEvent, EMPTY, defer, asapScheduler, combineLatest, of, concatMap, withLatestFrom, concat, throwError, first as first$1, Subject, takeUntil, partition, merge, shareReplay, tap as tap$1, catchError as catchError$1, startWith as startWith$1, pairwise as pairwise$1, groupBy as groupBy$1, mergeMap as mergeMap$1, throttle, race, retry, NEVER, debounceTime as debounceTime$1, Subscription } from "rxjs";
+import { Observable, share, map, distinctUntilChanged, skip, filter, exhaustMap, from, timer, switchMap, takeWhile, firstValueFrom, fromEvent, EMPTY, defer, asapScheduler, combineLatest, of, concatMap, withLatestFrom, concat, throwError, first as first$1, Subject, takeUntil, partition, merge, shareReplay, tap as tap$1, catchError as catchError$1, startWith as startWith$1, pairwise as pairwise$1, groupBy as groupBy$1, mergeMap as mergeMap$1, throttle, race, NEVER, Subscription, retry, debounceTime as debounceTime$1 } from "rxjs";
 import { devtools } from "zustand/middleware";
 import { createStore } from "zustand/vanilla";
 import { pick, omit, isEqual, isObject } from "lodash-es";
@@ -15,6 +15,7 @@ import { applyPatches, parsePatch } from "@sanity/diff-match-patch";
 import { isKeySegment, isKeyedObject } from "@sanity/types";
 import { createDocumentLoaderFromClient } from "@sanity/mutate/_unstable_store";
 import { SDK_CHANNEL_NAME, SDK_NODE_NAME } from "@sanity/message-protocol";
+import { fromUrl } from "@sanity/bifur-client";
 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.";
@@ -86,8 +87,8 @@ function createStoreState(initialState, devToolsOptions) {
     })
   };
 }
-function createStoreInstance(instance, { name, getInitialState, initialize }) {
-  const state = createStoreState(getInitialState(instance), {
+function createStoreInstance(instance, { name, getInitialState: getInitialState2, initialize }) {
+  const state = createStoreState(getInitialState2(instance), {
     enabled: !!getEnv("DEV"),
     name: `${name}-${instance.config.projectId}.${instance.config.dataset}`
   }), dispose = initialize?.({ state, instance }), disposed = { current: !1 };
@@ -168,8 +169,8 @@ function createStateSourceAction(options) {
 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;
+    const data = storageArea?.getItem(`${storageKey}_last_refresh`), parsed = data ? parseInt(data, 10) : 0;
+    return isNaN(parsed) ? 0 : parsed;
   } catch {
     return 0;
   }
@@ -227,6 +228,9 @@ async function acquireTokenRefreshLock(refreshFn, storageArea, storageKey) {
     return console.error("Failed to request token refresh lock:", error), !1;
   }
 }
+function shouldRefreshToken(lastRefresh) {
+  return lastRefresh ? Date.now() - lastRefresh >= REFRESH_INTERVAL : !0;
+}
 const refreshStampedToken = ({ state }) => {
   const { clientFactory, apiHost, storageArea, storageKey } = state.get().options;
   return state.observable.pipe(
@@ -256,26 +260,69 @@ const refreshStampedToken = ({ state }) => {
           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(REFRESH_INTERVAL, REFRESH_INTERVAL).pipe(
-        // Check if still logged in before each refresh attempt in the timer
+      return storeState.dashboardContext ? new Observable((subscriber) => {
+        const visibilityHandler = () => {
+          const currentState = state.get();
+          document.visibilityState === "visible" && currentState.authState.type === AuthStateType.LOGGED_IN && shouldRefreshToken(currentState.authState.lastTokenRefresh) && createTokenRefreshStream(
+            currentState.authState.token,
+            clientFactory,
+            apiHost
+          ).subscribe({
+            next: (response) => {
+              state.set("setRefreshStampedToken", (prev) => ({
+                authState: prev.authState.type === AuthStateType.LOGGED_IN ? {
+                  ...prev.authState,
+                  token: response.token,
+                  lastTokenRefresh: Date.now()
+                } : prev.authState
+              })), subscriber.next(response);
+            },
+            error: (error) => subscriber.error(error)
+          });
+        }, timerSubscription = timer(REFRESH_INTERVAL, REFRESH_INTERVAL).pipe(
+          filter(() => document.visibilityState === "visible"),
+          switchMap(() => {
+            const currentState = state.get().authState;
+            if (currentState.type !== AuthStateType.LOGGED_IN)
+              throw new Error("User logged out before refresh could complete");
+            return createTokenRefreshStream(currentState.token, clientFactory, apiHost);
+          })
+        ).subscribe({
+          next: (response) => {
+            state.set("setRefreshStampedToken", (prev) => ({
+              authState: prev.authState.type === AuthStateType.LOGGED_IN ? {
+                ...prev.authState,
+                token: response.token,
+                lastTokenRefresh: Date.now()
+              } : prev.authState
+            })), subscriber.next(response);
+          },
+          error: (error) => subscriber.error(error)
+        });
+        return document.addEventListener("visibilitychange", visibilityHandler), () => {
+          document.removeEventListener("visibilitychange", visibilityHandler), timerSubscription.unsubscribe();
+        };
+      }).pipe(
         takeWhile(() => state.get().authState.type === AuthStateType.LOGGED_IN),
-        // Use switchMap here: if the timer ticks again, we *do* want the latest token request
-        switchMap(
-          () => createTokenRefreshStream(storeState.authState.token, clientFactory, apiHost)
-        ),
-        // Map the successful response for the outer subscribe block
         map((response) => ({ token: response.token }))
       ) : from(acquireTokenRefreshLock(performRefresh, storageArea, storageKey)).pipe(
         filter((hasLock) => hasLock),
-        // If acquireTokenRefreshLock *does* somehow resolve true (e.g., locks unsupported),
-        // emit the token that triggered this exhaustMap execution.
-        map(() => ({ token: storeState.authState.token }))
+        map(() => {
+          const currentState = state.get().authState;
+          if (currentState.type !== AuthStateType.LOGGED_IN)
+            throw new Error("User logged out before refresh could complete");
+          return { token: currentState.token };
+        })
       );
     })
   ).subscribe({
     next: (response) => {
       state.set("setRefreshStampedToken", (prev) => ({
-        authState: prev.authState.type === AuthStateType.LOGGED_IN ? { ...prev.authState, token: response.token } : prev.authState
+        authState: prev.authState.type === AuthStateType.LOGGED_IN ? {
+          ...prev.authState,
+          token: response.token,
+          lastTokenRefresh: Date.now()
+        } : prev.authState
       })), storageArea?.setItem(storageKey, JSON.stringify({ token: response.token }));
     },
     error: (error) => {
@@ -1291,7 +1338,7 @@ function processMutations({
         throw new Error(
           `Cannot create document with \`_id\` \`${id}\` because another document with the same ID already exists.`
         );
-      const document = {
+      const document2 = {
         // > `_createdAt` and `_updatedAt` may be submitted and will override
         // > the default which is of course the current time. This can be used
         // > to reconstruct a data-set with its timestamp structure intact.
@@ -1304,11 +1351,11 @@ function processMutations({
         _rev: transactionId,
         _id: id
       };
-      dataset[id] = document;
+      dataset[id] = document2;
       continue;
     }
     if ("createOrReplace" in mutation) {
-      const id = getId(mutation.createOrReplace._id), prev = dataset[id], document = {
+      const id = getId(mutation.createOrReplace._id), prev = dataset[id], document2 = {
         ...mutation.createOrReplace,
         // otherwise, if the mutation provided, a `_createdAt` time, use it,
         // otherwise default to now
@@ -1335,13 +1382,13 @@ function processMutations({
         _rev: transactionId,
         _id: id
       };
-      dataset[id] = document;
+      dataset[id] = document2;
       continue;
     }
     if ("createIfNotExists" in mutation) {
       const id = getId(mutation.createIfNotExists._id);
       if (dataset[id]) continue;
-      const document = {
+      const document2 = {
         // same logic as `create`:
         // prefer the user's `_createdAt` and `_updatedAt`
         _createdAt: now,
@@ -1350,7 +1397,7 @@ function processMutations({
         _rev: transactionId,
         _id: id
       };
-      dataset[id] = document;
+      dataset[id] = document2;
       continue;
     }
     if ("delete" in mutation) {
@@ -1467,7 +1514,7 @@ const listen$1 = ({ state }, documentId) => {
   const { sharedListener, fetchDocument } = state.get();
   return sharedListener.events.pipe(
     concatMap((e3) => e3.type === "welcome" ? fetchDocument(documentId).pipe(
-      map((document) => ({ type: "sync", document }))
+      map((document2) => ({ type: "sync", document: document2 }))
     ) : e3.type === "mutation" && e3.documentId === documentId ? of(e3) : EMPTY),
     sortListenerEvents(),
     withLatestFrom(
@@ -1486,7 +1533,7 @@ const listen$1 = ({ state }, documentId) => {
           revision: next.document?._rev,
           timestamp: next.document?._updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
         };
-      const [document] = Object.values(
+      const [document2] = Object.values(
         processMutations({
           documents: { [documentId]: documentState.remote },
           mutations: next.mutations,
@@ -1497,7 +1544,7 @@ const listen$1 = ({ state }, documentId) => {
       return {
         type: "mutation",
         documentId,
-        document: document ?? null,
+        document: document2 ?? null,
         revision: transactionId,
         timestamp,
         ...previousRev && { previousRev }
@@ -3279,8 +3326,8 @@ const documentsCache = new MultiKeyWeakMap(), actionsCache = /* @__PURE__ */ new
     return nestedCache.get(actionsKey) || (nestedCache.set(actionsKey, normalizedActions), normalizedActions);
   }
 );
-function checkGrant$1(grantExpr, document) {
-  return C(grantExpr, { params: { document } }).get();
+function checkGrant$1(grantExpr, document2) {
+  return C(grantExpr, { params: { document: document2 } }).get();
 }
 const enNarrowConjunction = new Intl.ListFormat("en", { style: "narrow", type: "conjunction" });
 function calculatePermissions(...args) {
@@ -3343,8 +3390,8 @@ const _calculatePermissions = createSelector(
     };
   }
 );
-function checkGrant(grantExpr, document) {
-  return C(grantExpr, { params: { document } }).get();
+function checkGrant(grantExpr, document2) {
+  return C(grantExpr, { params: { document: document2 } }).get();
 }
 class ActionError extends Error {
   documentId;
@@ -3782,7 +3829,7 @@ function revertOutgoingTransaction(prev) {
     )
   };
 }
-function applyRemoteDocument(prev, { document, documentId, previousRev, revision, timestamp, type }, events) {
+function applyRemoteDocument(prev, { document: document2, documentId, previousRev, revision, timestamp, type }, events) {
   if (!prev.grants) return prev;
   const prevDocState = prev.documentStates[documentId];
   if (!prevDocState) return prev;
@@ -3797,13 +3844,13 @@ function applyRemoteDocument(prev, { document, documentId, previousRev, revision
         ...prev.documentStates,
         [documentId]: {
           ...prevDocState,
-          remote: document,
+          remote: document2,
           remoteRev: revision,
           unverifiedRevisions
         }
       }
     };
-  let working = { ...prev.applied.at(0)?.previous, [documentId]: document };
+  let working = { ...prev.applied.at(0)?.previous, [documentId]: document2 };
   const nextApplied = [];
   for (const curr of prev.applied)
     try {
@@ -3829,7 +3876,7 @@ function applyRemoteDocument(prev, { document, documentId, previousRev, revision
       ...prev.documentStates,
       [documentId]: {
         ...prevDocState,
-        remote: document,
+        remote: document2,
         remoteRev: revision,
         local: working[documentId],
         unverifiedRevisions
@@ -4005,9 +4052,9 @@ const _getDocumentState = bindActionByDataset(
       if (error) throw error;
       const draftId = getDraftId(documentId), publishedId = getPublishedId$1(documentId), draft = documentStates[draftId]?.local, published = documentStates[publishedId]?.local;
       if (draft === void 0 || published === void 0) return;
-      const document = draft ?? published;
-      if (!path) return document;
-      const result = jsonMatch(document, path).next();
+      const document2 = draft ?? published;
+      if (!path) return document2;
+      const result = jsonMatch(document2, path).next();
       if (result.done) return;
       const { value } = result.value;
       return value;
@@ -4291,7 +4338,356 @@ const favorites = createFetcherStore({
       })
     );
   }
-}), getFavoritesState = favorites.getState, resolveFavoritesState = favorites.resolveState, fetch = (client, query, params, options) => defer(
+}), getFavoritesState = favorites.getState, resolveFavoritesState = favorites.resolveState, API_VERSION$1 = "vX", PROJECT_API_VERSION = "2025-07-18", USERS_STATE_CLEAR_DELAY = 5e3, DEFAULT_USERS_BATCH_SIZE = 100, getUsersKey = (instance, {
+  resourceType,
+  organizationId,
+  batchSize = DEFAULT_USERS_BATCH_SIZE,
+  projectId = instance.config.projectId,
+  userId
+} = {}) => JSON.stringify({
+  resourceType,
+  organizationId,
+  batchSize,
+  projectId,
+  userId
+}), parseUsersKey = (key) => JSON.parse(key), addSubscription = (subscriptionId, key) => (prev) => {
+  const group = prev.users[key], subscriptions = [...group?.subscriptions ?? [], subscriptionId];
+  return { ...prev, users: { ...prev.users, [key]: { ...group, subscriptions } } };
+}, removeSubscription = (subscriptionId, key) => (prev) => {
+  const group = prev.users[key];
+  if (!group) return prev;
+  const subscriptions = group.subscriptions.filter((id) => id !== subscriptionId);
+  return subscriptions.length ? { ...prev, users: { ...prev.users, [key]: { ...group, subscriptions } } } : { ...prev, users: omit(prev.users, key) };
+}, setUsersData = (key, { data, nextCursor, totalCount }) => (prev) => {
+  const group = prev.users[key];
+  if (!group) return prev;
+  const users = [...group.users ?? [], ...data];
+  return { ...prev, users: { ...prev.users, [key]: { ...group, users, totalCount, nextCursor } } };
+}, updateLastLoadMoreRequest = (timestamp, key) => (prev) => {
+  const group = prev.users[key];
+  return group ? { ...prev, users: { ...prev.users, [key]: { ...group, lastLoadMoreRequest: timestamp } } } : prev;
+}, setUsersError = (key, error) => (prev) => {
+  const group = prev.users[key];
+  return group ? { ...prev, users: { ...prev.users, [key]: { ...group, error } } } : prev;
+}, cancelRequest = (key) => (prev) => {
+  const group = prev.users[key];
+  return !group || group.subscriptions.length ? prev : { ...prev, users: omit(prev.users, key) };
+}, initializeRequest = (key) => (prev) => prev.users[key] ? prev : { ...prev, users: { ...prev.users, [key]: { subscriptions: [] } } }, usersStore = {
+  name: "UsersStore",
+  getInitialState: () => ({ users: {} }),
+  initialize: (context) => {
+    const subscription = listenForLoadMoreAndFetch(context);
+    return () => subscription.unsubscribe();
+  }
+}, errorHandler$1 = (state) => (error) => state.set("setError", { error }), listenForLoadMoreAndFetch = ({ state, instance }) => state.observable.pipe(
+  map((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 { userId, batchSize, ...options } = parseUsersKey(group$.key);
+        if (userId) {
+          if (userId.startsWith("p"))
+            return getClient(instance, {
+              apiVersion: PROJECT_API_VERSION,
+              // this is a global store, so we need to use the projectId from the options when we're fetching
+              // users from a project subdomain
+              projectId: options.projectId,
+              useProjectHostname: !0
+            }).observable.request({
+              method: "GET",
+              uri: `/users/${userId}`
+            }).pipe(
+              map((user) => ({
+                data: [{
+                  sanityUserId: user.sanityUserId,
+                  profile: {
+                    id: user.id,
+                    displayName: user.displayName,
+                    familyName: user.familyName ?? void 0,
+                    givenName: user.givenName ?? void 0,
+                    middleName: user.middleName ?? void 0,
+                    imageUrl: user.imageUrl ?? void 0,
+                    createdAt: user.createdAt,
+                    updatedAt: user.updatedAt,
+                    isCurrentUser: user.isCurrentUser,
+                    email: user.email,
+                    provider: user.provider
+                  },
+                  memberships: []
+                }],
+                totalCount: 1,
+                nextCursor: null
+              })),
+              catchError$1((error) => (state.set("setUsersError", setUsersError(group$.key, error)), EMPTY)),
+              tap$1(
+                (response) => state.set("setUsersData", setUsersData(group$.key, response))
+              )
+            );
+          const scope = userId.startsWith("g") ? "global" : void 0, client = getClient(instance, {
+            scope,
+            apiVersion: API_VERSION$1
+          }), resourceType2 = options.resourceType || "project", resourceId = resourceType2 === "organization" ? options.organizationId : options.projectId;
+          return resourceId ? client.observable.request({
+            method: "GET",
+            uri: `access/${resourceType2}/${resourceId}/users/${userId}`
+          }).pipe(
+            map((response) => "sanityUserId" in response ? {
+              data: [response],
+              totalCount: 1,
+              nextCursor: null
+            } : response),
+            catchError$1((error) => (state.set("setUsersError", setUsersError(group$.key, error)), EMPTY)),
+            tap$1((response) => state.set("setUsersData", setUsersData(group$.key, response)))
+          ) : throwError(() => new Error("An organizationId or a projectId is required"));
+        }
+        const projectId = options.projectId, resourceType = options.resourceType ?? (options.organizationId ? "organization" : projectId ? "project" : "organization"), organizationId$ = options.organizationId ? of(options.organizationId) : getDashboardOrganizationId$1(instance).observable.pipe(
+          filter((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$1
+        }).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([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$1(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
+        );
+      };
+    }
+  })
+), 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$]));
+  }
+), loadMoreUsers = bindActionGlobally(
+  usersStore,
+  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;
+  }
+), getUserState = bindActionGlobally(
+  usersStore,
+  ({ instance }, { userId, ...options }) => getUsersState(instance, { userId, ...options }).observable.pipe(
+    map((res) => res?.data[0]),
+    distinctUntilChanged((a2, b2) => a2?.profile.updatedAt === b2?.profile.updatedAt)
+  )
+), resolveUser = bindActionGlobally(
+  usersStore,
+  async ({ instance }, { signal, ...options }) => (await resolveUsers(instance, {
+    signal,
+    ...options
+  }))?.data[0]
+);
+function getBifurClient(client, token$) {
+  const bifurVersionedClient = client.withConfig({ apiVersion: "2022-06-30" }), { dataset, url: baseUrl, requestTagPrefix = "sanity.studio" } = bifurVersionedClient.config(), urlWithTag = `${`${baseUrl.replace(/\/+$/, "")}/socket/${dataset}`.replace(/^http/, "ws")}?tag=${requestTagPrefix}`;
+  return fromUrl(urlWithTag, { token$ });
+}
+const handleIncomingMessage = (event) => {
+  switch (event.type) {
+    case "rollCall":
+      return {
+        type: "rollCall",
+        userId: event.i,
+        sessionId: event.session
+      };
+    case "state": {
+      const { sessionId, locations } = event.m;
+      return {
+        type: "state",
+        userId: event.i,
+        sessionId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        locations
+      };
+    }
+    case "disconnect":
+      return {
+        type: "disconnect",
+        userId: event.i,
+        sessionId: event.m.session,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    default:
+      throw new Error(`Got unknown presence event: ${JSON.stringify(event)}`);
+  }
+}, createBifurTransport = (options) => {
+  const { client, token$, sessionId } = options, bifur = getBifurClient(client, token$), incomingEvents$ = bifur.listen("presence").pipe(map$1(handleIncomingMessage)), dispatchMessage = (message) => {
+    switch (message.type) {
+      case "rollCall":
+        return bifur.request("presence_rollcall", { session: sessionId });
+      case "state":
+        return bifur.request("presence_announce", {
+          data: { locations: message.locations, sessionId }
+        });
+      case "disconnect":
+        return bifur.request("presence_disconnect", { session: sessionId });
+      default:
+        return EMPTY;
+    }
+  };
+  return typeof window < "u" && fromEvent(window, "beforeunload").pipe(switchMap$1(() => dispatchMessage({ type: "disconnect" }))).subscribe(), [incomingEvents$.pipe(share$1()), dispatchMessage];
+}, getInitialState = () => ({
+  locations: /* @__PURE__ */ new Map(),
+  users: {}
+}), presenceStore = {
+  name: "presence",
+  getInitialState,
+  initialize: (context) => {
+    const { instance, state } = context, sessionId = crypto.randomUUID(), client = getClient(instance, {
+      apiVersion: "2022-06-30"
+    }), token$ = getTokenState(instance).observable.pipe(distinctUntilChanged()), [incomingEvents$, dispatch] = createBifurTransport({
+      client,
+      token$,
+      sessionId
+    }), subscription = new Subscription();
+    return subscription.add(
+      incomingEvents$.subscribe((event) => {
+        "sessionId" in event && event.sessionId === sessionId || (event.type === "state" ? state.set("presence/state", (prevState) => {
+          const newLocations = new Map(prevState.locations);
+          return newLocations.set(event.sessionId, {
+            userId: event.userId,
+            locations: event.locations
+          }), {
+            ...prevState,
+            locations: newLocations
+          };
+        }) : event.type === "disconnect" && state.set("presence/disconnect", (prevState) => {
+          const newLocations = new Map(prevState.locations);
+          return newLocations.delete(event.sessionId), { ...prevState, locations: newLocations };
+        }));
+      })
+    ), dispatch({ type: "rollCall" }).subscribe(), () => {
+      dispatch({ type: "disconnect" }).subscribe(), subscription.unsubscribe();
+    };
+  }
+}, selectLocations = (state) => state.locations, selectUsers = (state) => state.users, selectPresence = createSelector(
+  selectLocations,
+  selectUsers,
+  (locations, users) => Array.from(locations.entries()).map(([sessionId, { userId, locations: locs }]) => ({
+    user: users[userId] || {
+      id: userId,
+      displayName: "Unknown user",
+      name: "Unknown user",
+      email: ""
+    },
+    sessionId,
+    locations: locs
+  }))
+), getPresence = bindActionByDataset(
+  presenceStore,
+  createStateSourceAction({
+    selector: (context) => selectPresence(context.state),
+    onSubscribe: (context) => {
+      const subscription = context.state.observable.pipe(
+        map(
+          (state) => Array.from(state.locations.values()).map((l2) => l2.userId).filter((id) => !!id)
+        ),
+        distinctUntilChanged((a2, b2) => a2.length === b2.length && a2.every((v2, i2) => v2 === b2[i2]))
+      ).pipe(
+        switchMap((userIds) => {
+          if (userIds.length === 0)
+            return of([]);
+          const userObservables = userIds.map(
+            (userId) => getUserState(context.instance, {
+              userId,
+              resourceType: "project",
+              projectId: context.instance.config.projectId
+            }).pipe(filter((v2) => !!v2))
+          );
+          return combineLatest(userObservables);
+        })
+      ).subscribe((users) => {
+        users && context.state.set("presence/users", (prevState) => ({
+          ...prevState,
+          users: {
+            ...prevState.users,
+            ...users.reduce((acc, user) => (user && (acc[user.profile.id] = user), acc), {})
+          }
+        }));
+      });
+      return () => subscription.unsubscribe();
+    }
+  })
+), fetch = (client, query, params, options) => defer(
   () => client.observable.fetch(query, params, {
     tag: options.tag,
     filterResponse: !0
@@ -4452,7 +4848,7 @@ const DEFAULT_PERSPECTIVE = "drafts", optionsCache = /* @__PURE__ */ new Map(),
         subscription.unsubscribe();
     };
   }
-}, errorHandler$1 = (state) => (error) => state.set("setError", { error }), listenForNewSubscribersAndFetch = ({ state, instance }) => state.observable.pipe(
+}, errorHandler = (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()),
@@ -4506,7 +4902,7 @@ const DEFAULT_PERSPECTIVE = "drafts", optionsCache = /* @__PURE__ */ new Map(),
       })
     )
   )
-).subscribe({ error: errorHandler$1(state) }), listenToLiveClientAndSetLastLiveEventIds = ({
+).subscribe({ error: errorHandler(state) }), listenToLiveClientAndSetLastLiveEventIds = ({
   state,
   instance
 }) => {
@@ -4535,7 +4931,7 @@ const DEFAULT_PERSPECTIVE = "drafts", optionsCache = /* @__PURE__ */ new Map(),
         })
       );
     })
-  ).subscribe({ error: errorHandler$1(state) });
+  ).subscribe({ error: errorHandler(state) });
 };
 function getQueryState(...args) {
   return _getQueryState(...args);
@@ -5020,159 +5416,16 @@ const _resolveProjection = bindActionByDataset(
       filter((state) => !!state?.data)
     )
   )
-), API_VERSION$1 = "v2025-02-19", projects = createFetcherStore({
+), API_VERSION = "v2025-02-19", projects = createFetcherStore({
   name: "Projects",
   getKey: () => "projects",
   fetcher: (instance) => () => getClientState(instance, {
-    apiVersion: API_VERSION$1,
+    apiVersion: API_VERSION,
     scope: "global"
   }).observable.pipe(
     switchMap((client) => client.observable.projects.list({ includeMembers: !1 }))
   )
-}), 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();
-  }
-}, 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$1(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([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(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
-        );
-      };
-    }
-  })
-), 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$]));
-  }
-), loadMoreUsers = bindActionGlobally(
-  usersStore,
-  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;
+}), getProjectsState = projects.getState, resolveProjects = projects.resolveState, WILDCARD_TOKEN = "*", NEGATION_TOKEN = "-", TOKEN_REGEX = /(?:[^\s"]+|"[^"]*")+/g;
 function isNegationToken(token) {
   return typeof token < "u" && token.trim().startsWith(NEGATION_TOKEN);
 }
@@ -5195,7 +5448,60 @@ function createGroqSearchFilter(query) {
     `${finalIncrementalToken}${WILDCARD_TOKEN}`
   ), `[@] match text::query("${processedTokens.join(" ").replace(/"/g, '\\"')}")`;
 }
-var version = "2.1.0";
+function defineIntent(intent) {
+  if (!intent.id)
+    throw new Error("Intent must have an id");
+  if (!intent.action)
+    throw new Error("Intent must have an action");
+  if (!intent.title)
+    throw new Error("Intent must have a title");
+  if (!Array.isArray(intent.filters))
+    throw new Error("Intent must have a filters array");
+  if (intent.filters.length === 0)
+    throw new Error(
+      "Intent must have at least one filter. If you want to match everything, use {types: ['*']}"
+    );
+  return intent.filters.forEach((filter2, index) => {
+    validateFilter(filter2, index);
+  }), intent;
+}
+function validateFilter(filter2, index) {
+  const filterContext = `Filter at index ${index}`;
+  if (!filter2 || typeof filter2 != "object")
+    throw new Error(`${filterContext} must be an object`);
+  if (filter2.types === void 0)
+    throw new Error(
+      `${filterContext} must have a types property. Use ['*'] to match all document types.`
+    );
+  if (filter2.projectId !== void 0) {
+    if (typeof filter2.projectId != "string")
+      throw new Error(`${filterContext}: projectId must be a string`);
+    if (filter2.projectId.trim() === "")
+      throw new Error(`${filterContext}: projectId cannot be empty`);
+  }
+  if (filter2.dataset !== void 0) {
+    if (typeof filter2.dataset != "string")
+      throw new Error(`${filterContext}: dataset must be a string`);
+    if (filter2.dataset.trim() === "")
+      throw new Error(`${filterContext}: dataset cannot be empty`);
+    if (filter2.projectId === void 0)
+      throw new Error(`${filterContext}: dataset cannot be specified without projectId`);
+  }
+  if (!Array.isArray(filter2.types))
+    throw new Error(`${filterContext}: types must be an array`);
+  if (filter2.types.length === 0)
+    throw new Error(`${filterContext}: types array cannot be empty`);
+  if (filter2.types.forEach((type, typeIndex) => {
+    if (typeof type != "string")
+      throw new Error(`${filterContext}: types[${typeIndex}] must be a string`);
+    if (type.trim() === "")
+      throw new Error(`${filterContext}: types[${typeIndex}] cannot be empty`);
+  }), filter2.types.includes("*") && filter2.types.length > 1)
+    throw new Error(
+      `${filterContext}: when using wildcard '*', it must be the only type in the array`
+    );
+}
+var version = "2.1.1";
 const CORE_SDK_VERSION = getEnv("PKG_VERSION") || `${version}-development`;
 export {
   AuthStateType,
@@ -5208,6 +5514,7 @@ export {
   createGroqSearchFilter,
   createProjectHandle,
   createSanityInstance,
+  defineIntent,
   deleteDocument,
   destroyController,
   discardDocument,
@@ -5232,6 +5539,7 @@ export {
   getPathDepth,
   getPermissionsState,
   getPerspectiveState,
+  getPresence,
   getPreviewState,
   getProjectState,
   getProjectionState,
@@ -5239,6 +5547,7 @@ export {
   getQueryKey,
   getQueryState,
   getTokenState,
+  getUserState,
   getUsersKey,
   getUsersState,
   handleAuthCallback,
@@ -5261,6 +5570,7 @@ export {
   resolveProjection,
   resolveProjects,
   resolveQuery,
+  resolveUser,
   resolveUsers,
   setAuthToken,
   slicePath2 as slicePath,