@sanity/sdk 3.3.0 → 3.4.0-rc.0

package/dist/_exports/_internal.d.ts

@@ -1,6 +1,6 @@
-import { m as SanityConfig, s as DocumentResource, t as SanityInstance } from "../createSanityInstance-BQIqyGLX.js";
-import { Ai as CacheWriter, Ar as getCommentsOptionsKey, Bi as BoundStoreAction, Et as GetUsersOptions, Fi as MutationResult, G as getQueryKey, Ii as defineFetcher, Li as defineMutation, Mi as FetcherDefinition, Mr as parseCommentsOptionsKey, Ni as FetcherSnapshot, Pi as MutationDefinition, Sr as createLogger, ct as PreviewValue, ji as Fetcher, ki as CacheTag, q as parseQueryKey, r as ApplicationBase, st as PreviewQueryResult } from "../applications-pRS8tuC2.js";
-import { A as MessageBusTopics, E as ApplicationStatusUpdate, S as resetMessageBus, T as ApplicationStatus, i as resolveTopic, o as InstallMessageBusOptions, r as getTopicState, u as MessageBusConnection, x as installMessageBus } from "../topicStore-D-jEwzlX.js";
+import { m as SanityConfig, s as DocumentResource, t as SanityInstance } from "../createSanityInstance--Lrldto8.js";
+import { Ai as CacheWriter, Ar as getCommentsOptionsKey, Bi as BoundStoreAction, Et as GetUsersOptions, Fi as MutationResult, G as getQueryKey, Ii as defineFetcher, Li as defineMutation, Mi as FetcherDefinition, Mr as parseCommentsOptionsKey, Ni as FetcherSnapshot, Pi as MutationDefinition, Sr as createLogger, ct as PreviewValue, ji as Fetcher, ki as CacheTag, q as parseQueryKey, r as ApplicationBase, st as PreviewQueryResult } from "../applications-903KQTrD.js";
+import { A as MessageBusTopics, E as ApplicationStatusUpdate, S as resetMessageBus, T as ApplicationStatus, i as resolveTopic, o as InstallMessageBusOptions, r as getTopicState, u as MessageBusConnection, x as installMessageBus } from "../topicStore-VQILEI1R.js";
 import { ClientError, SanityClient } from "@sanity/client";
 import { Observable } from "rxjs";
 import { CurrentUser } from "@sanity/types";

package/dist/_exports/_internal.js

@@ -1,5 +1,5 @@
-import { A as __exportAll, C as isStudioConfig, _ as getClientErrorApiDescription, g as getClientErrorApiBody, k as createLogger, n as getClient, v as getClientErrorApiType, x as isProjectUserNotFoundClientError } from "../clientStore-BI4D8HhJ.js";
-import { G as defineMutation, K as randomId, S as getCommentsOptionsKey, W as defineFetcher, d as getUsersKey, i as parseQueryKey, n as getQueryKey, p as parseUsersKey, q as randomUuid, t as CORE_SDK_VERSION, w as parseCommentsOptionsKey } from "../version-CD4aBigm.js";
+import { A as __exportAll, C as isStudioConfig, _ as getClientErrorApiDescription, g as getClientErrorApiBody, k as createLogger, n as getClient, v as getClientErrorApiType, x as isProjectUserNotFoundClientError } from "../clientStore-QDrJNTM4.js";
+import { G as defineMutation, K as randomId, S as getCommentsOptionsKey, W as defineFetcher, d as getUsersKey, i as parseQueryKey, n as getQueryKey, p as parseUsersKey, q as randomUuid, t as CORE_SDK_VERSION, w as parseCommentsOptionsKey } from "../version-CYqZgJX1.js";
 import { i as pickProperties, n as isObject, t as isDeepEqual } from "../object-CxXlSVg7.js";
 import { a as isDashboardEnvironment, i as getDashboardMessageBus, l as installMessageBus, n as getTopicState, o as requireDashboardMessageBus, r as resolveTopic, u as resetMessageBus } from "../topicStore-BJ54_X6H.js";
 import "@sanity/client";
@@ -328,8 +328,8 @@ function initTelemetry(instance, projectId) {
 		environment
 	}), Promise.all([
 		Promise.resolve().then(() => telemetryManager_exports),
-		import("../clientStore-BI4D8HhJ.js").then((n) => n.t),
-		import("../clientStore-BI4D8HhJ.js").then((n) => n.a)
+		import("../clientStore-QDrJNTM4.js").then((n) => n.t),
+		import("../clientStore-QDrJNTM4.js").then((n) => n.a)
 	]).then(async ([{ createTelemetryManager }, { getClient }, { getTokenState }]) => {
 		if (instance.isDisposed()) {
 			initInFlight.delete(instance), logger.debug("telemetry skipped: instance disposed before imports resolved");

package/dist/_exports/agent.d.ts

@@ -1,4 +1,4 @@
-import { s as DocumentResource, t as SanityInstance } from "../createSanityInstance-BQIqyGLX.js";
+import { s as DocumentResource, t as SanityInstance } from "../createSanityInstance--Lrldto8.js";
 import { SanityClient } from "@sanity/client";
 import { Observable } from "rxjs";
 /** @alpha */

package/dist/_exports/agent.js

@@ -1,4 +1,4 @@
-import { r as getClientState } from "../clientStore-BI4D8HhJ.js";
+import { r as getClientState } from "../clientStore-QDrJNTM4.js";
 import "@sanity/client";
 import { from, switchMap } from "rxjs";
 /**

package/dist/_exports/comlink.d.ts

@@ -1,4 +1,4 @@
-import { Bi as BoundStoreAction, zi as StateSource } from "../applications-pRS8tuC2.js";
+import { Bi as BoundStoreAction, zi as StateSource } from "../applications-903KQTrD.js";
 import { ChannelInput, ChannelInstance, Controller, Message, Node, NodeInput, Status } from "@sanity/comlink";
 /**
  * Message sent from a containing app to an iframe

package/dist/_exports/dashboard.d.ts

@@ -1,2 +1,2 @@
-import { B as Topics, C as ApplicationConfig, D as DashboardTopics, F as ReplyOf, I as StateTopic, L as StateTopicDef, M as NavigationTarget, N as PayloadOf, O as EventTopic, P as RemoteModuleRef, R as TopicName, V as ValueOf, _ as MessageBusMeta, a as ConnectMessageBusOptions, b as connectMessageBus, c as MessageBusAbortOptions, d as MessageBusEmitOptions, f as MessageBusEmitResult, g as MessageBusMessage, h as MessageBusHost, j as NavigationLocation, k as EventTopicDef, l as MessageBusClient, m as MessageBusErrorCode, n as TopicError, p as MessageBusError, s as MessageBus, t as TopicData, u as MessageBusConnection, v as MessageBusQueryOptions, w as ApplicationConfigAppType, y as MessageBusStateSource, z as TopicResult } from "../topicStore-D-jEwzlX.js";
+import { B as Topics, C as ApplicationConfig, D as DashboardTopics, F as ReplyOf, I as StateTopic, L as StateTopicDef, M as NavigationTarget, N as PayloadOf, O as EventTopic, P as RemoteModuleRef, R as TopicName, V as ValueOf, _ as MessageBusMeta, a as ConnectMessageBusOptions, b as connectMessageBus, c as MessageBusAbortOptions, d as MessageBusEmitOptions, f as MessageBusEmitResult, g as MessageBusMessage, h as MessageBusHost, j as NavigationLocation, k as EventTopicDef, l as MessageBusClient, m as MessageBusErrorCode, n as TopicError, p as MessageBusError, s as MessageBus, t as TopicData, u as MessageBusConnection, v as MessageBusQueryOptions, w as ApplicationConfigAppType, y as MessageBusStateSource, z as TopicResult } from "../topicStore-VQILEI1R.js";
 export { type ApplicationConfig, type ApplicationConfigAppType, type ConnectMessageBusOptions, type DashboardTopics, type EventTopic, type EventTopicDef, type MessageBus, type MessageBusAbortOptions, type MessageBusClient, type MessageBusConnection, type MessageBusEmitOptions, type MessageBusEmitResult, MessageBusError, type MessageBusErrorCode, type MessageBusHost, type MessageBusMessage, type MessageBusMeta, type MessageBusQueryOptions, type MessageBusStateSource, type NavigationLocation, type NavigationTarget, type PayloadOf, type RemoteModuleRef, type ReplyOf, type StateTopic, type StateTopicDef, type TopicData, TopicError, type TopicName, type TopicResult, type Topics, type ValueOf, connectMessageBus };

package/dist/{applications-pRS8tuC2.d.ts → applications-903KQTrD.d.ts}

@@ -1,4 +1,4 @@
-import { b as AuthConfig, c as DocumentTypeHandle, d as ProjectHandle, f as ReleaseHandle, i as DatasetHandle, o as DocumentHandle, s as DocumentResource, t as SanityInstance, u as PerspectiveHandle, x as AuthProvider } from "./createSanityInstance-BQIqyGLX.js";
+import { b as AuthConfig, c as DocumentTypeHandle, d as ProjectHandle, f as ReleaseHandle, i as DatasetHandle, o as DocumentHandle, s as DocumentResource, t as SanityInstance, u as PerspectiveHandle, x as AuthProvider } from "./createSanityInstance--Lrldto8.js";
 import { ClientConfig, ClientPerspective, DatasetsResponse, ListenEvent, MultipleMutationResult, ReleaseDocument, ReleaseDocument as ReleaseDocument$1, ResponseQueryOptions, SanityClient, SanityDocument, SanityProject } from "@sanity/client";
 import { Observable, Subject } from "rxjs";
 import { CurrentUser, CurrentUser as CurrentUser$1, InsertPatch, Mutation, PatchOperations, Path, PortableTextBlock, Role, SanityDocument as SanityDocument$1, SanityDocument as SanityDocument$3, SanityDocumentLike } from "@sanity/types";
@@ -531,10 +531,20 @@ interface OrgVerificationResult {
  */
 declare function observeOrganizationVerificationState(instance: SanityInstance, projectIds: string[]): Observable<OrgVerificationResult>;
 /**
+ * Handles the auth redirect callback. In OAuth mode this delegates to
+ * {@link handleOAuthCallback}; otherwise it exchanges the legacy `sid` for a
+ * long-lived token.
+ *
  * @public
  */
 declare const handleAuthCallback: BoundStoreAction<AuthStoreState, [locationHref?: string | undefined], Promise<string | false>>;
 /**
+ * Logs the current user out. In OAuth mode this revokes the OAuth tokens
+ * instead of calling the legacy `/auth/logout` endpoint; revocation is
+ * best-effort, so the OAuth path resolves even if the revoke request fails,
+ * whereas the legacy path rejects when `/auth/logout` fails. Local state and
+ * storage are cleared in both cases.
+ *
  * @public
  */
 declare const logout: BoundStoreAction<AuthStoreState, [], Promise<void>>;
@@ -551,9 +561,14 @@ declare const startOAuthAuthorization: BoundStoreAction<AuthStoreState, [], Prom
  * responses, exchanges the authorization `code` for tokens, persists them, and
  * transitions to `LOGGED_IN`.
  *
- * Returns the callback URL cleaned of OAuth params (for the caller to
- * `history.replaceState`) when a callback was processed, or `false` when there
- * was nothing to handle (no code, or an exchange already in progress).
+ * Returns the URL for the caller to `history.replaceState` to when a callback
+ * was processed: on success, the same-origin location the user was on when
+ * the flow started (if any), otherwise the callback URL cleaned of OAuth
+ * params. Returns `false` when there was nothing to handle (no code, or an
+ * exchange already in progress). A callback that fails validation while a
+ * session is already `LOGGED_IN` (e.g. a remount before the params were
+ * stripped) is ignored with a warning and still returns the cleaned URL, so a
+ * string result does not imply an exchange ran.
  *
  * @public
  */
@@ -3617,4 +3632,4 @@ interface DeleteApplicationInput {
  */
 declare const deleteApplication: (instance: SanityInstance, input: DeleteApplicationInput) => Promise<MutationResult<DeletedResult>>;
 export { Project as $, createRelease as $n, ClientOptions as $r, FavoriteStatusResponse as $t, stringifyPath$1 as A, CacheWriter as Ai, patchOperations as An, getCommentsOptionsKey as Ar, SanityUser as At, getPerspectiveState as B, BoundStoreAction as Bi, DocumentAction as Bn, createComment as Br, OrganizationMember as Bt, SanityDocument$3 as C, getTokenState as Ci, resolveDocument as Cn, createDatasetHandle as Cr, TransportEvent as Ct, joinPaths as D, AccessResourceType as Di, PermissionDeniedReason as Dn, CommentsOptions as Dr, Membership as Dt, getPathDepth as E, AuthStateType as Ei, DocumentPermissionsResult as En, createProjectHandle as Er, GetUsersOptions as Et, getUsersState as F, MutationResult as Fi, CreateDocumentAction as Fn, CreateCommentOptions as Fr, Organizations as Ft, getQueryKey as G, PublishReleaseAction as Gn, Comment as Gr, InstallationActiveConfig as Gt, getActiveReleasesState as H, EditDocumentOptions as Hn, replyToComment as Hr, organization as Ht, loadMoreUsers as I, defineFetcher as Ii, CreateReleaseAction as In, RemoveCommentOptions as Ir, OrganizationsOptions as It, resolveQuery as J, UnarchiveReleaseAction as Jn, CommentReaction as Jr, InstallationsOptions as Jt, getQueryState as K, ReleaseAction as Kn, CommentLocalState as Kr, InstallationBase as Kt, resolveUser as L, defineMutation as Li, DeleteDocumentAction as Ln, ReplyToCommentOptions as Lr, organizations as Lt, isImportError as M, FetcherDefinition as Mi, JsonMatch as Mn, parseCommentsOptionsKey as Mr, UserProfile as Mt, getCorsErrorProjectId as N, FetcherSnapshot as Ni, Action as Nn, resolveCommentThreads as Nr, UsersGroupState as Nt, jsonMatch$1 as O, checkPermissions as Oi, DocumentSet as On, ResolveCommentsOptions as Or, ResolveUserOptions as Ot, getUserState as P, MutationDefinition as Pi, ArchiveReleaseAction as Pn, resolveComments as Pr, UsersStoreState as Pt, getProjectionState as Q, createDocument as Qn, CommentThread as Qr, FavoriteDocumentContext as Qt, resolveUsers as R, Selector as Ri, DeleteReleaseAction as Rn, SetCommentStatusOptions as Rr, Organization as Rt, Role as S, getLoginUrlState as Si, getPermissionsState as Sn, createLogger as Sr, StateEvent as St, getIndexForKey$1 as T, OAuthTokens as Ti, subscribeDocumentEvents as Tn, createDocumentTypeHandle as Tr, GetUserOptions as Tt, getAllReleasesState as U, EditReleaseAction as Un, setCommentStatus as Ur, Installation as Ut, ReleaseState as V, EditDocumentAction as Vn, removeComment as Vr, OrganizationOptions as Vt, QueryOptions as W, PublishDocumentAction as Wn, updateComment as Wr, InstallationAccess as Wt, projects as X, UnscheduleReleaseAction as Xn, CommentTextSelection as Xr, installation as Xt, ProjectsOptions as Y, UnpublishDocumentAction as Yn, CommentStatus as Yr, InstallationsResponse as Yt, resolveProjection as Z, archiveRelease as Zn, CommentTextSelectionItem as Zr, installations as Zt, applications as _, LoggingInAuthState as _i, TransactionAcceptedEvent as _n, LogContext as _r, PresencePerspectiveOptions as _t, ApplicationInclude as a, refreshOAuthTokens as ai, ApplyDocumentActionsOptions as an, publishDocument as ar, project as at, CurrentUser$1 as b, getDashboardOrganizationId as bi, getDocumentState as bn, Logger as br, ReportPresenceOptions as bt, ApplicationStudioConfig as c, logout as ci, DocumentCreatedEvent as cn, unarchiveRelease as cr, PreviewValue as ct, ApplicationsOptions as d, OrgVerificationResult as di, DocumentEditedEvent as dn, ResolveDocument as dr, getPresence as dt, ClientStoreState as ei, SetFavoriteInput as en, deleteDocument as er, ProjectBase as et, ApplicationsResponse as f, AuthState as fi, DocumentEvent as fn, ResolveProjectionResult as fr, reportPresence as ft, application as g, LoggedOutAuthState as gi, DocumentUnpublishedEvent as gn, InstanceContext as gr, PresenceLocation as gt, UpdateApplicationInput as h, LoggedInAuthState as hi, DocumentTransactionSubmissionResult as hn, configureLogging as hr, DocumentPresenceOptions as ht, ApplicationDeployment as i, handleOAuthCallback as ii, ActionsResult as in, editRelease as ir, ProjectOptions as it, CORE_SDK_VERSION as j, Fetcher as ji, processMutations as jn, getCommentsState as jr, SanityUserResponse as jt, slicePath$1 as k, CacheTag as ki, ProcessMutationsOptions as kn, getCommentThreadsState as kr, ResolveUsersOptions as kt, ApplicationVisibility as l, handleAuthCallback as li, DocumentDeletedEvent as ln, unpublishDocument as lr, ProjectionValuePending as lt, DeletedResult as m, ErrorAuthState as mi, DocumentRemotePatchesEvent as mn, datasets as mr, DocumentPresence as mt, ApplicationAccess as n, getClientState as ni, setFavorite as nn, discardDocument as nr, ProjectMemberRole as nt, ApplicationInterface as o, revokeOAuthTokens as oi, applyDocumentActions as on, publishRelease as or, PreviewMedia as ot, DeleteApplicationInput as p, AuthStoreState as pi, DocumentPublishedEvent as pn, ResolveQueryResult as pr, DisconnectEvent as pt, parseQueryKey as q, ScheduleReleaseAction as qn, CommentMessage as qr, InstallationInclude as qt, ApplicationBase as r, getOAuthTokensState as ri, getReleaseDocumentId as rn, editDocument as rr, ProjectMetadata as rt, ApplicationInterfacePlacementMetadata as s, startOAuthAuthorization as si, ActionErrorEvent as sn, scheduleRelease as sr, PreviewQueryResult as st, Application as t, getClient as ti, favorites as tn, deleteRelease as tr, ProjectMember as tt, ApplicationWorkspace as u, observeOrganizationVerificationState as ui, DocumentDiscardedEvent as un, unscheduleRelease as ur, getDocumentPresence as ut, deleteApplication as v, getAuthState as vi, TransactionRevertedEvent as vn, LogLevel as vr, PresenceSelection as vt, SanityProject$1 as w, setAuthToken as wi, resolvePermissions as wn, createDocumentHandle as wr, UserPresence as wt, ReleaseDocument$1 as x, getIsInDashboardState as xi, getDocumentSyncStatus as xn, LoggerConfig as xr, RollCallEvent as xt, updateApplication as y, getCurrentUserState as yi, DocumentOptions as yn, LogNamespace as yr, PresenceSelectionPoint as yt, defineProjection as z, StateSource as zi, DiscardDocumentAction as zn, UpdateCommentOptions as zr, OrganizationBase as zt };
-//# sourceMappingURL=applications-pRS8tuC2.d.ts.map
+//# sourceMappingURL=applications-903KQTrD.d.ts.map

package/dist/applications-903KQTrD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applications-903KQTrD.d.ts","names":[],"sources":["../src/store/createStoreState.ts","../src/store/defineStore.ts","../src/store/createActionBinder.ts","../src/store/createStateSourceAction.ts","../src/store/fetcherStore.ts","../src/access/checkPermissions.ts","../src/auth/authStateType.ts","../src/auth/oauth/types.ts","../src/auth/authStore.ts","../src/project/organizationVerification.ts","../src/auth/getOrganizationVerificationState.ts","../src/auth/handleAuthCallback.ts","../src/auth/logout.ts","../src/auth/oauth/oauthActions.ts","../src/client/clientStore.ts","../src/comments/types.ts","../src/comments/commentActions.ts","../src/comments/commentsStore.ts","../src/config/handles.ts","../src/utils/logger.ts","../src/config/loggingConfig.ts","../src/datasets/datasets.ts","../src/typegen/groqCompat.ts","../src/typegen/resolve.ts","../src/document/actions.ts","../src/document/patchOperations.ts","../src/document/processMutations.ts","../src/document/permissions.ts","../src/document/sharedListener.ts","../src/document/documentStore.ts","../src/document/reducers.ts","../src/document/events.ts","../src/document/applyDocumentActions.ts","../src/document/processActions/releaseUtil.ts","../src/favorites/favorites.ts","../src/utils/includeShape.ts","../src/installations/installations.ts","../src/organization/organization.ts","../src/organizations/organizations.ts","../src/users/types.ts","../src/presence/types.ts","../src/presence/presenceStore.ts","../src/projection/types.ts","../src/preview/types.ts","../src/project/project.ts","../src/projection/getProjectionState.ts","../src/projection/resolveProjection.ts","../src/projects/projects.ts","../src/query/queryStore.ts","../src/releases/releasesStore.ts","../src/releases/getPerspectiveState.ts","../src/typegen/defineProjection.ts","../src/users/usersStore.ts","../src/utils/getCorsErrorProjectId.ts","../src/utils/isImportError.ts","../src/version.ts","../src/_exports/index.ts","../src/applications/applications.ts"],"mappings":"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"}

package/dist/{clientStore-BI4D8HhJ.js → clientStore-QDrJNTM4.js}

@@ -573,9 +573,13 @@ function initializeDashboardAuth(context, tokenRefresherRunning) {
 		tokenRefresherStarted: startedRefresher
 	};
 }
+/** localStorage (or configured `storageArea`) key for persisted OAuth tokens. */
+const OAUTH_TOKENS_KEY = "__sanity_oauth_tokens";
 /**
 * Parses persisted token JSON back into {@link OAuthTokens}. Returns `null`
-* when the value is missing or malformed.
+* when the value is missing or malformed, including an `expiresAt` that does
+* not parse to a valid date (an `Invalid Date` would otherwise read as never
+* expiring, since `NaN <= now` is always `false`).
 *
 * @internal
 */
@@ -584,12 +588,12 @@ function deserializeTokens(raw) {
 	try {
 		let parsed = JSON.parse(raw);
 		if (typeof parsed != "object" || !parsed || !("accessToken" in parsed) || typeof parsed.accessToken != "string" || !("expiresAt" in parsed) || typeof parsed.expiresAt != "string") return null;
-		let value = parsed;
-		return {
+		let value = parsed, expiresAt = new Date(value.expiresAt);
+		return Number.isNaN(expiresAt.getTime()) ? null : {
 			accessToken: value.accessToken,
 			tokenType: "bearer",
 			expiresIn: value.expiresIn,
-			expiresAt: new Date(value.expiresAt),
+			expiresAt,
 			...value.refreshToken !== void 0 && { refreshToken: value.refreshToken }
 		};
 	} catch {
@@ -601,15 +605,15 @@ function deserializeTokens(raw) {
 *
 * State discovery order:
 * 1. Persisted tokens in `__sanity_oauth_tokens` → `LOGGED_IN`
-* 2. Callback URL (contains `code`/`state`/`error` and matches `redirectUri`)
+* 2. Callback URL (contains `code` or `error` and matches `redirectUri`)
 *    → `LOGGING_IN`
 * 3. Otherwise → `LOGGED_OUT`
 *
 * @internal
 */
 function getOauthInitialState(options) {
-	let { authConfig, initialLocationHref } = options, storageKey = "__sanity_oauth_tokens", storageArea = authConfig.storageArea ?? getDefaultStorage(), redirectUri = authConfig.oauth?.redirectUri, tokens = deserializeTokens(storageArea?.getItem("__sanity_oauth_tokens") ?? null);
-	if (tokens) return {
+	let { authConfig, initialLocationHref } = options, storageKey = OAUTH_TOKENS_KEY, storageArea = authConfig.storageArea ?? getDefaultStorage(), redirectUri = authConfig.oauth?.redirectUri, rawTokens = storageArea?.getItem("__sanity_oauth_tokens") ?? null, tokens = deserializeTokens(rawTokens);
+	if (rawTokens && !tokens && storageArea?.removeItem(OAUTH_TOKENS_KEY), tokens) return {
 		authState: createLoggedInAuthState(tokens.accessToken, null),
 		storageKey,
 		storageArea,
@@ -617,7 +621,7 @@ function getOauthInitialState(options) {
 		dashboardContext: {},
 		oauthTokens: tokens
 	};
-	let { searchParams } = new URL(initialLocationHref, DEFAULT_BASE), isCallback = searchParams.has("code") || searchParams.has("state") || searchParams.has("error");
+	let { searchParams } = new URL(initialLocationHref, DEFAULT_BASE), isCallback = searchParams.has("code") || searchParams.has("error");
 	if (redirectUri && isCallback) {
 		let loc = new URL(initialLocationHref, DEFAULT_BASE), redirect = new URL(redirectUri, DEFAULT_BASE);
 		if (loc.origin === redirect.origin && loc.pathname === redirect.pathname) return {
@@ -1005,7 +1009,7 @@ const authStore = defineStore({
 				storageKey: result.storageKey,
 				storageArea: result.storageArea,
 				authMethod: result.authMethod,
-				oauth: authConfig.oauth
+				oauth: mode === "oauth" ? authConfig.oauth : void 0
 			}
 		};
 	},
@@ -1126,4 +1130,4 @@ const allowedKeys = Object.keys({
 }), getClientState = bindActionGlobally(clientStore, createStateSourceAction(({ instance }, options) => getClient(instance, options)));
 export { __exportAll as A, isStudioConfig as C, getAuthLogger as D, REQUEST_TAG_PREFIX as E, configureLogging as O, AuthStateType as S, DEFAULT_BASE as T, getClientErrorApiDescription as _, authStore_exports as a, getTokenFromLocation as b, getDashboardOrganizationId as c, getTokenState as d, setAuthToken as f, getClientErrorApiBody as g, getCleanedUrl as h, authStore as i, createLogger as k, getIsInDashboardState as l, getAuthCode as m, getClient as n, getAuthState as o, createLoggedInAuthState as p, getClientState as r, getCurrentUserState as s, clientStore_exports as t, getLoginUrlState as u, getClientErrorApiType as v, DEFAULT_API_VERSION$1 as w, isProjectUserNotFoundClientError as x, getDefaultLocation as y };
 
-//# sourceMappingURL=clientStore-BI4D8HhJ.js.map
+//# sourceMappingURL=clientStore-QDrJNTM4.js.map

package/dist/clientStore-QDrJNTM4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clientStore-QDrJNTM4.js","names":["DEFAULT_API_VERSION","DEFAULT_API_VERSION","DEFAULT_API_VERSION"],"sources":["../src/utils/logger.ts","../src/utils/getStagingApiHost.ts","../src/auth/authLogger.ts","../src/auth/authConstants.ts","../src/auth/authMode.ts","../src/auth/authStateType.ts","../src/auth/refreshStampedToken.ts","../src/auth/subscribeToStateAndFetchCurrentUser.ts","../src/auth/utils.ts","../src/auth/dashboardAuth.ts","../src/auth/oauth/oauthAuth.ts","../src/auth/subscribeToStorageEventsAndSetToken.ts","../src/auth/standaloneAuth.ts","../src/auth/studioModeAuth.ts","../src/auth/studioAuth.ts","../src/auth/authStore.ts","../src/client/clientStore.ts"],"sourcesContent":["/**\n * Logging infrastructure for the Sanity SDK\n *\n * Provides multi-level, namespace-based logging for both SDK users and maintainers.\n * In production builds, all logging can be stripped via tree-shaking.\n *\n * @example SDK User\n * ```ts\n * import {configureLogging} from '@sanity/sdk'\n *\n * configureLogging({\n *   level: 'info',\n *   namespaces: ['auth', 'document']\n * })\n * ```\n *\n * @example SDK Maintainer\n * ```ts\n * configureLogging({\n *   level: 'trace',\n *   namespaces: ['*'],\n *   internal: true\n * })\n * ```\n */\n\n/**\n * Log levels in order of verbosity (least to most)\n * - error: Critical failures that prevent operation\n * - warn: Issues that may cause problems but don't stop execution\n * - info: High-level informational messages (SDK user level)\n * - debug: Detailed debugging information (maintainer level)\n * - trace: Very detailed tracing (maintainer level, includes RxJS streams)\n * @public\n */\nexport type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace'\n\n/**\n * Log namespaces organize logs by functional domain\n *\n * @remarks\n * This is an extensible string type. As logging is added to more modules,\n * additional namespaces will be recognized. Currently implemented namespaces\n * will be documented as they are added.\n * @internal\n */\nexport type LogNamespace = string\n\n/**\n * Configuration for the logging system\n * @public\n */\nexport interface LoggerConfig {\n  /**\n   * Minimum log level to output\n   * @defaultValue 'warn'\n   */\n  level?: LogLevel\n\n  /**\n   * Namespaces to enable. Use ['*'] for all namespaces\n   * @defaultValue []\n   * @remarks\n   * Available namespaces depend on which modules have logging integrated.\n   * Check the SDK documentation for the current list of instrumented modules.\n   * @example ['auth', 'document']\n   */\n  namespaces?: string[]\n\n  /**\n   * Enable internal/maintainer-level logging\n   * Shows RxJS streams, store internals, etc.\n   * @defaultValue false\n   */\n  internal?: boolean\n\n  /**\n   * Custom log handler (for testing or custom output)\n   * @defaultValue console methods\n   */\n  handler?: LogHandler\n\n  /**\n   * Enable timestamps in log output\n   * @defaultValue true\n   */\n  timestamps?: boolean\n\n  /**\n   * Enable in production builds\n   * @defaultValue false\n   */\n  enableInProduction?: boolean\n}\n\n/**\n * Custom log handler interface\n *\n * @internal\n */\nexport interface LogHandler {\n  error: (message: string, context?: LogContext) => void\n  warn: (message: string, context?: LogContext) => void\n  info: (message: string, context?: LogContext) => void\n  debug: (message: string, context?: LogContext) => void\n  trace: (message: string, context?: LogContext) => void\n}\n\n/**\n * Context object attached to log messages\n *\n * This interface allows you to attach arbitrary contextual data to log messages.\n * The index signature `[key: string]: unknown` enables you to add any custom\n * properties relevant to your log entry (e.g., `userId`, `documentId`, `action`, etc.).\n *\n * **Sensitive data sanitization:**\n * Top-level keys containing sensitive names (`token`, `password`, `secret`, `apiKey`,\n * `authorization`) are automatically redacted to `[REDACTED]` in log output.\n *\n * @example\n * ```ts\n * logger.info('User logged in', {\n *   userId: '123',          // Custom context\n *   action: 'login',        // Custom context\n *   token: 'secret'         // Will be redacted to [REDACTED]\n * })\n * ```\n *\n * @internal\n */\nexport interface LogContext {\n  /**\n   * Custom context properties that provide additional information about the log entry.\n   * Any key-value pairs can be added here (e.g., userId, documentId, requestId, etc.).\n   * Keys with sensitive names (token, password, secret, apiKey, authorization) are\n   * automatically sanitized.\n   */\n  [key: string]: unknown\n  /** Error object if logging an error */\n  error?: Error | unknown\n  /** Duration in milliseconds for timed operations */\n  duration?: number\n  /** Stack trace for debugging */\n  stack?: string\n  /** Instance context (automatically added when available) */\n  instanceContext?: InstanceContext\n}\n\n/**\n * Instance context information automatically added to logs\n * @internal\n */\nexport interface InstanceContext {\n  /** Unique instance ID */\n  instanceId?: string\n  /** Project ID */\n  projectId?: string\n  /** Dataset name */\n  dataset?: string\n}\n\n/**\n * Logger instance for a specific namespace\n * @internal\n */\nexport interface Logger {\n  readonly namespace: string\n  error: (message: string, context?: LogContext) => void\n  warn: (message: string, context?: LogContext) => void\n  info: (message: string, context?: LogContext) => void\n  debug: (message: string, context?: LogContext) => void\n  trace: (message: string, context?: LogContext) => void\n  /** Check if a log level is enabled (for performance-sensitive code) */\n  isLevelEnabled: (level: LogLevel) => boolean\n  /** Create a child logger with extended context */\n  child: (context: LogContext) => Logger\n  /** Get the instance context if available */\n  getInstanceContext: () => InstanceContext | undefined\n}\n\n// Log level priority (lower number = higher priority)\nconst LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {\n  error: 0,\n  warn: 1,\n  info: 2,\n  debug: 3,\n  trace: 4,\n}\n\n// Default logging configuration\nconst DEFAULT_CONFIG: Required<LoggerConfig> = {\n  level: 'warn',\n  namespaces: [],\n  internal: false,\n  timestamps: true,\n  enableInProduction: false,\n  handler: {\n    // eslint-disable-next-line no-console\n    error: console.error.bind(console),\n    // eslint-disable-next-line no-console\n    warn: console.warn.bind(console),\n    // eslint-disable-next-line no-console\n    info: console.info.bind(console),\n    // eslint-disable-next-line no-console\n    debug: console.debug.bind(console),\n    // eslint-disable-next-line no-console\n    trace: console.debug.bind(console), // trace uses console.debug\n  },\n}\n\n/**\n * Parse DEBUG environment variable for automatic logging configuration\n *\n * Supports patterns similar to Sanity CLI/Studio:\n * - DEBUG=sanity:* (all namespaces, debug level)\n * - DEBUG=sanity:auth,sanity:document (specific namespaces)\n * - DEBUG=sanity:trace:* (all namespaces, trace level)\n * - DEBUG=sanity:*:internal (enable internal logs)\n *\n * @internal\n */\nexport function parseDebugEnvVar(): Partial<LoggerConfig> | null {\n  if (typeof process === 'undefined' || !process.env?.['DEBUG']) {\n    return null\n  }\n\n  const debug = process.env['DEBUG']\n\n  // Only process if it includes 'sanity'\n  if (!debug.includes('sanity')) {\n    return null\n  }\n\n  const config: Partial<LoggerConfig> = {}\n\n  // Parse level from pattern like \"sanity:trace:*\" or \"sanity:debug:*\"\n  const levelMatch = debug.match(/sanity:(trace|debug|info|warn|error):/)\n  const hasLevelSpecifier = !!levelMatch\n  if (levelMatch) {\n    config.level = levelMatch[1] as LogLevel\n  } else {\n    // Default to debug level if just \"sanity:*\" or \"sanity:namespace\"\n    config.level = 'debug'\n  }\n\n  // Parse namespaces\n  if (debug === 'sanity') {\n    config.namespaces = ['*']\n  } else if (hasLevelSpecifier && debug.match(/sanity:(trace|debug|info|warn|error):\\*/)) {\n    // Pattern like \"sanity:trace:*\" - wildcard after level\n    config.namespaces = ['*']\n  } else if (!hasLevelSpecifier && debug.includes('sanity:*')) {\n    // Pattern like \"sanity:*\" - wildcard without level\n    config.namespaces = ['*']\n  } else {\n    // Extract specific namespaces like \"sanity:auth,sanity:document\"\n    const namespaces = debug\n      .split(',')\n      .filter((s) => s.includes('sanity:'))\n      .map((s) => {\n        // Remove 'sanity:' prefix\n        const cleaned = s.replace(/^sanity:/, '')\n        // If there's a level specifier, skip it\n        if (hasLevelSpecifier && cleaned.match(/^(trace|debug|info|warn|error):/)) {\n          // Get the part after the level: \"trace:auth\" -> \"auth\"\n          return cleaned.split(':').slice(1).join(':')\n        }\n        // Otherwise get the first part: \"auth:something\" -> \"auth\"\n        return cleaned.split(':')[0]\n      })\n      .filter(Boolean)\n      .filter((ns) => ns !== '*') // Filter out wildcards\n\n    if (namespaces.length > 0) {\n      config.namespaces = namespaces\n    }\n  }\n\n  // Check for internal flag: DEBUG=sanity:*:internal\n  if (debug.includes(':internal')) {\n    config.internal = true\n  }\n\n  return config\n}\n\n// Global configuration - initialized with env var settings if present\nconst envConfig = parseDebugEnvVar()\nlet globalConfig: Required<LoggerConfig> = {\n  ...DEFAULT_CONFIG,\n  ...(envConfig ?? {}),\n}\n\n// Log that env var configuration was detected (only if DEBUG is set)\n// Note: This runs at module initialization, difficult to test without complex module mocking\n/* c8 ignore next 14 */\nif (envConfig) {\n  const shouldLog =\n    ['info', 'debug', 'trace'].includes(globalConfig.level) || globalConfig.level === 'warn'\n  if (shouldLog) {\n    // eslint-disable-next-line no-console\n    console.info(\n      `[${new Date().toISOString()}] [INFO] [sdk] Logging auto-configured from DEBUG environment variable`,\n      {\n        level: globalConfig.level,\n        namespaces: globalConfig.namespaces,\n        internal: globalConfig.internal,\n        source: 'env:DEBUG',\n        value: typeof process !== 'undefined' ? process.env?.['DEBUG'] : undefined,\n      },\n    )\n  }\n}\n\n/**\n * Configure the global logging system\n * @public\n */\nexport function configureLogging(config: LoggerConfig): void {\n  globalConfig = {\n    ...globalConfig,\n    ...config,\n    handler: config.handler ?? globalConfig.handler,\n  }\n}\n\n/**\n * Get the current logging configuration\n * @internal\n */\nexport function getLoggingConfig(): Readonly<Required<LoggerConfig>> {\n  return globalConfig\n}\n\n/**\n * Reset logging to default configuration\n * @internal\n */\nexport function resetLogging(): void {\n  globalConfig = {...DEFAULT_CONFIG}\n}\n\n/**\n * Check if logging is enabled in the current environment\n * @internal\n */\nfunction isLoggingEnabled(): boolean {\n  // In production, only log if explicitly enabled\n  if (typeof process !== 'undefined' && process.env?.['NODE_ENV'] === 'production') {\n    return globalConfig.enableInProduction\n  }\n  return true\n}\n\n/**\n * Check if a namespace is enabled\n * @internal\n */\nfunction isNamespaceEnabled(namespace: string): boolean {\n  if (!isLoggingEnabled()) return false\n  if (globalConfig.namespaces.includes('*')) return true\n  return globalConfig.namespaces.includes(namespace)\n}\n\n/**\n * Check if a log level is enabled\n * @internal\n */\nfunction isLevelEnabled(level: LogLevel): boolean {\n  if (!isLoggingEnabled()) return false\n  return LOG_LEVEL_PRIORITY[level] <= LOG_LEVEL_PRIORITY[globalConfig.level]\n}\n\n/**\n * Format a log message with timestamp, namespace, and instance context\n * @internal\n */\nfunction formatMessage(\n  namespace: LogNamespace,\n  level: LogLevel,\n  message: string,\n  context?: LogContext,\n): [string, LogContext | undefined] {\n  const parts: string[] = []\n\n  if (globalConfig.timestamps) {\n    const timestamp = new Date().toISOString()\n    parts.push(`[${timestamp}]`)\n  }\n\n  parts.push(`[${level.toUpperCase()}]`)\n  parts.push(`[${namespace}]`)\n\n  // Add instance context if available\n  const instanceContext = context?.instanceContext\n  if (instanceContext) {\n    if (instanceContext.projectId) {\n      parts.push(`[project:${instanceContext.projectId}]`)\n    }\n    if (instanceContext.dataset) {\n      parts.push(`[dataset:${instanceContext.dataset}]`)\n    }\n    if (instanceContext.instanceId) {\n      parts.push(`[instance:${instanceContext.instanceId.slice(0, 8)}]`)\n    }\n  }\n\n  parts.push(message)\n\n  return [parts.join(' '), context]\n}\n\n/**\n * Sanitize context for logging (remove sensitive data)\n * @internal\n * @remarks\n * This performs shallow sanitization only - it redacts top-level keys that contain\n * sensitive names (token, password, secret, apiKey, authorization).\n * Nested sensitive data (e.g., `\\{auth: \\{token: 'secret'\\}\\}`) will NOT be redacted.\n * If deep sanitization is needed in the future, this can be enhanced to recursively\n * traverse nested objects.\n */\nfunction sanitizeContext(context?: LogContext): LogContext | undefined {\n  if (!context || Object.keys(context).length === 0) return undefined\n\n  const sanitized = {...context}\n\n  // Remove or redact sensitive fields at the top level\n  const sensitiveKeys = ['token', 'password', 'secret', 'apiKey', 'authorization']\n  for (const key of Object.keys(sanitized)) {\n    if (sensitiveKeys.some((sensitive) => key.toLowerCase().includes(sensitive))) {\n      sanitized[key] = '[REDACTED]'\n    }\n  }\n\n  return sanitized\n}\n\n/**\n * Create a logger for a specific namespace\n * @param namespace - A string identifier for the logging domain (e.g., 'auth', 'document')\n * @param baseContext - Optional base context to include in all log messages\n * @remarks\n * If baseContext includes an `instanceContext` property (with projectId, dataset, instanceId),\n * it will be automatically formatted into the log output for easier debugging of\n * multi-instance scenarios.\n * @public\n */\nexport function createLogger(namespace: string, baseContext?: LogContext): Logger {\n  const logAtLevel = (level: LogLevel, message: string, context?: LogContext) => {\n    // Early return if namespace or level not enabled\n    if (!isNamespaceEnabled(namespace)) return\n    if (!isLevelEnabled(level)) return\n\n    // Skip internal logs if not enabled\n    if (context?.['internal'] && !globalConfig.internal) return\n\n    const mergedContext = {...baseContext, ...context}\n    const sanitized = sanitizeContext(mergedContext)\n    const [formatted, finalContext] = formatMessage(namespace, level, message, sanitized)\n\n    globalConfig.handler[level](formatted, finalContext)\n  }\n\n  const logger: Logger = {\n    namespace,\n    error: (message, context) => logAtLevel('error', message, context),\n    warn: (message, context) => logAtLevel('warn', message, context),\n    info: (message, context) => logAtLevel('info', message, context),\n    debug: (message, context) => logAtLevel('debug', message, context),\n    trace: (message, context) => logAtLevel('trace', message, {...context, internal: true}),\n    isLevelEnabled: (level) => isNamespaceEnabled(namespace) && isLevelEnabled(level),\n    child: (childContext) => createLogger(namespace, {...baseContext, ...childContext}),\n    getInstanceContext: () => baseContext?.instanceContext,\n  }\n\n  return logger\n}\n\n/**\n * Create a performance timer for measuring operation duration\n * @internal\n */\nexport function createTimer(\n  namespace: string,\n  operation: string,\n): {end: (message?: string, context?: LogContext) => number} {\n  const logger = createLogger(namespace)\n  const start = performance.now()\n\n  return {\n    end: (message?: string, context?: LogContext): number => {\n      const duration = performance.now() - start\n      logger.debug(message ?? `${operation} completed`, {\n        ...context,\n        operation,\n        duration,\n      })\n      return duration\n    },\n  }\n}\n\n/**\n * Utility to log RxJS operator execution (for maintainers)\n * Will be exported in future PR when logging is added to stores\n * @internal\n */\n/* c8 ignore next 4 */\nfunction logRxJSOperator(namespace: string, operator: string, context?: LogContext): void {\n  const logger = createLogger(namespace)\n  logger.trace(`RxJS: ${operator}`, {...context, internal: true, operator})\n}\n\n/**\n * Extract instance context from a SanityInstance for logging\n * Will be exported in future PR when logging is added to stores\n * @param instance - The SanityInstance to extract context from\n * @returns Instance context suitable for logging\n * @internal\n */\n/* c8 ignore next 7 */\nfunction getInstanceContext(instance: {\n  instanceId?: string\n  config?: {projectId?: string; dataset?: string}\n}): InstanceContext {\n  return {\n    instanceId: instance.instanceId,\n    projectId: instance.config?.projectId,\n    dataset: instance.config?.dataset,\n  }\n}\n\n// Prevent unused function warnings - these will be exported and used in future PRs\n/* c8 ignore next 2 */\nvoid logRxJSOperator\nvoid getInstanceContext\n","declare const __SANITY_STAGING__: boolean | undefined\n\n/**\n * Returns the staging API host if the `__SANITY_STAGING__` build-time flag is\n * set to `true` (mirroring how Sanity Studio detects staging builds).\n *\n * @internal\n */\nexport function getStagingApiHost(): string | undefined {\n  if (typeof __SANITY_STAGING__ !== 'undefined' && __SANITY_STAGING__ === true) {\n    return 'https://api.sanity.work'\n  }\n  return undefined\n}\n","import {type SanityInstance} from '../store/createSanityInstance'\nimport {createLogger, type Logger} from '../utils/logger'\n\nconst loggers = new WeakMap<SanityInstance, Logger>()\n\n/**\n * Returns the auth logger for a Sanity instance, creating it on first use.\n *\n * The logger is cached per instance so repeated action calls (logout,\n * setAuthToken, handleAuthCallback) reuse the same logger instead of\n * rebuilding it. The instance details are nested under `instanceContext`,\n * which is what the logger's formatter reads to render the\n * `[project:x] [dataset:y] [instance:z]` prefix.\n *\n * @internal\n */\nexport function getAuthLogger(instance: SanityInstance): Logger {\n  let logger = loggers.get(instance)\n  if (!logger) {\n    logger = createLogger('auth', {\n      instanceContext: {\n        instanceId: instance.instanceId,\n        projectId: instance.config.projectId,\n        dataset: instance.config.dataset,\n      },\n    })\n    loggers.set(instance, logger)\n  }\n  return logger\n}\n","export const DEFAULT_BASE = 'http://localhost'\nexport const AUTH_CODE_PARAM = 'sid'\nexport const DEFAULT_API_VERSION = '2021-06-07'\nexport const REQUEST_TAG_PREFIX = 'sanity.sdk.auth'\n","import {type SanityConfig} from '../config/sanityConfig'\nimport {DEFAULT_BASE} from './authConstants'\n\n/**\n * The runtime auth mode determines which authentication strategy the SDK uses.\n *\n * - `studio`     — Running inside Sanity Studio. Token is discovered from\n *                  Studio's localStorage entry or via cookie auth.\n * - `oauth`      — Configured with `auth.oauth`. Authenticates via Sanity's\n *                  OAuth 2.0 authorization-code + PKCE flow.\n * - `dashboard`  — Running inside the Sanity Dashboard iframe. Token is\n *                  provided by the parent frame via Comlink.\n * - `standalone` — Running as an independent app. Token comes from\n *                  localStorage or the OAuth login flow.\n *\n * @internal\n */\ntype AuthMode = 'studio' | 'oauth' | 'dashboard' | 'standalone'\n\n/**\n * Determines the auth mode from instance config and environment.\n *\n * Priority:\n * 1. `studio` config provided → `'studio'`\n * 2. `auth.oauth` config provided → `'oauth'` (explicit config wins over\n *    environment detection)\n * 3. Dashboard context detected (`_context` URL param with content) → `'dashboard'`\n * 4. Otherwise → `'standalone'`\n *\n * @internal\n */\nexport function resolveAuthMode(config: SanityConfig, locationHref: string): AuthMode {\n  if (isStudioConfig(config)) return 'studio'\n  if (config.auth?.oauth) return 'oauth'\n  if (detectDashboardContext(locationHref)) return 'dashboard'\n  return 'standalone'\n}\n\n/**\n * Returns `true` when the config indicates the SDK is running inside a Studio.\n *\n * @internal\n */\nexport function isStudioConfig(config: SanityConfig): boolean {\n  return !!config.studio\n}\n\n/**\n * Checks whether the given location href contains a `_context` URL parameter\n * with a non-empty JSON object, indicating the SDK is running inside the\n * Sanity Dashboard.\n *\n * @internal\n */\nfunction detectDashboardContext(locationHref: string): boolean {\n  try {\n    const parsedUrl = new URL(locationHref, DEFAULT_BASE)\n    const contextParam = parsedUrl.searchParams.get('_context')\n    if (!contextParam) return false\n\n    const parsed: unknown = JSON.parse(contextParam)\n    return (\n      typeof parsed === 'object' &&\n      parsed !== null &&\n      !Array.isArray(parsed) &&\n      Object.keys(parsed as Record<string, unknown>).length > 0\n    )\n  } catch (err) {\n    // eslint-disable-next-line no-console\n    console.error('Failed to parse dashboard context from initial location:', err)\n    return false\n  }\n}\n","/**\n * Represents the various states the authentication type can be in.\n *\n * @public\n */\nexport enum AuthStateType {\n  LOGGED_IN = 'logged-in',\n  LOGGING_IN = 'logging-in',\n  ERROR = 'error',\n  LOGGED_OUT = 'logged-out',\n}\n","import {\n  distinctUntilChanged,\n  exhaustMap,\n  filter,\n  map,\n  Observable,\n  type Subscription,\n  switchMap,\n  takeWhile,\n  timer,\n} from 'rxjs'\n\nimport {type StoreContext} from '../store/defineStore'\nimport {DEFAULT_API_VERSION, REQUEST_TAG_PREFIX} from './authConstants'\nimport {getAuthLogger} from './authLogger'\nimport {AuthStateType} from './authStateType'\nimport {type AuthState, type AuthStoreState} from './authStore'\n\nconst REFRESH_INTERVAL = 12 * 60 * 60 * 1000 // 12 hours in milliseconds\n\nfunction createTokenRefreshStream(\n  token: string,\n  clientFactory: AuthStoreState['options']['clientFactory'],\n  apiHost: string | undefined,\n): Observable<{token: string}> {\n  return new Observable((subscriber) => {\n    const client = clientFactory({\n      apiVersion: DEFAULT_API_VERSION,\n      requestTagPrefix: REQUEST_TAG_PREFIX,\n      useProjectHostname: false,\n      useCdn: false,\n      token,\n      ignoreBrowserTokenWarning: true,\n      ...(apiHost && {apiHost}),\n    })\n\n    const subscription = client.observable\n      .request<{token: string}>({\n        url: 'auth/refresh-token',\n        method: 'POST',\n        tag: 'refresh-token',\n        body: {\n          token,\n        },\n      })\n      .subscribe(subscriber)\n\n    return () => subscription.unsubscribe()\n  })\n}\n\nfunction shouldRefreshToken(lastRefresh: number | undefined): boolean {\n  if (!lastRefresh) return true\n  const timeSinceLastRefresh = Date.now() - lastRefresh\n  return timeSinceLastRefresh >= REFRESH_INTERVAL\n}\n\n/**\n * Periodically refreshes stamped auth tokens (those containing `-st`).\n *\n * Two triggers cause a refresh while the user stays logged in:\n * - a 12-hour interval timer (only fires while the tab is visible)\n * - the tab becoming visible again after `lastTokenRefresh` has gone stale\n *\n * Non-stamped tokens (e.g. personal access tokens) are never refreshed.\n *\n * @internal\n */\nexport const refreshStampedToken = ({\n  state,\n  instance,\n}: StoreContext<AuthStoreState>): Subscription => {\n  const logger = getAuthLogger(instance)\n\n  const {clientFactory, apiHost, storageArea, storageKey} = state.get().options\n\n  const refreshToken$ = state.observable.pipe(\n    map((storeState) => storeState.authState),\n    filter(\n      (authState): authState is Extract<AuthState, {type: AuthStateType.LOGGED_IN}> =>\n        authState.type === AuthStateType.LOGGED_IN,\n    ),\n    distinctUntilChanged((prev, curr) => prev.token === curr.token),\n    filter((authState) => authState.token.includes('-st')), // Ensure we only try to refresh stamped tokens\n    exhaustMap(() =>\n      new Observable<{token: string}>((subscriber) => {\n        const visibilityHandler = () => {\n          const currentState = state.get()\n          if (\n            document.visibilityState === 'visible' &&\n            currentState.authState.type === AuthStateType.LOGGED_IN &&\n            shouldRefreshToken(currentState.authState.lastTokenRefresh)\n          ) {\n            createTokenRefreshStream(\n              currentState.authState.token,\n              clientFactory,\n              apiHost,\n            ).subscribe({\n              next: (response) => {\n                state.set('setRefreshStampedToken', (prev) => ({\n                  authState:\n                    prev.authState.type === AuthStateType.LOGGED_IN\n                      ? {\n                          ...prev.authState,\n                          token: response.token,\n                          lastTokenRefresh: Date.now(),\n                        }\n                      : prev.authState,\n                }))\n                subscriber.next(response)\n              },\n              error: (error) => subscriber.error(error),\n            })\n          }\n        }\n\n        const timerSubscription = timer(REFRESH_INTERVAL, REFRESH_INTERVAL)\n          .pipe(\n            filter(() => document.visibilityState === 'visible'),\n            switchMap(() => {\n              const currentState = state.get().authState\n              if (currentState.type !== AuthStateType.LOGGED_IN) {\n                throw new Error('User logged out before refresh could complete')\n              }\n              return createTokenRefreshStream(currentState.token, clientFactory, apiHost)\n            }),\n          )\n          .subscribe({\n            next: (response) => {\n              state.set('setRefreshStampedToken', (prev) => ({\n                authState:\n                  prev.authState.type === AuthStateType.LOGGED_IN\n                    ? {\n                        ...prev.authState,\n                        token: response.token,\n                        lastTokenRefresh: Date.now(),\n                      }\n                    : prev.authState,\n              }))\n              subscriber.next(response)\n            },\n            error: (error) => subscriber.error(error),\n          })\n\n        document.addEventListener('visibilitychange', visibilityHandler)\n\n        return () => {\n          document.removeEventListener('visibilitychange', visibilityHandler)\n          timerSubscription.unsubscribe()\n        }\n      }).pipe(\n        takeWhile(() => state.get().authState.type === AuthStateType.LOGGED_IN),\n        map((response: {token: string}) => ({token: response.token})),\n      ),\n    ),\n  )\n\n  return refreshToken$.subscribe({\n    next: (response: {token: string}) => {\n      logger.debug('Token refresh completed, updating state')\n      state.set('setRefreshStampedToken', (prev) => ({\n        authState:\n          prev.authState.type === AuthStateType.LOGGED_IN\n            ? {\n                ...prev.authState,\n                token: response.token,\n                lastTokenRefresh: Date.now(),\n              }\n            : prev.authState,\n      }))\n      storageArea?.setItem(storageKey, JSON.stringify({token: response.token}))\n    },\n    error: (error) => {\n      logger.error('Token refresh failed', {error})\n      state.set('setRefreshStampedTokenError', {authState: {type: AuthStateType.ERROR, error}})\n    },\n  })\n}\n","import {type CurrentUser} from '@sanity/types'\nimport {\n  catchError,\n  distinctUntilChanged,\n  EMPTY,\n  filter,\n  map,\n  type Subscription,\n  switchMap,\n} from 'rxjs'\n\nimport {type StoreContext} from '../store/defineStore'\nimport {DEFAULT_API_VERSION, REQUEST_TAG_PREFIX} from './authConstants'\nimport {getAuthLogger} from './authLogger'\nimport {isStudioConfig} from './authMode'\nimport {AuthStateType} from './authStateType'\nimport {type AuthMethodOptions, type AuthState, type AuthStoreState} from './authStore'\n\n/**\n * Subscribes to auth state changes and fetches the current user when\n * the state transitions to `LOGGED_IN` without a `currentUser`.\n *\n * @param context - The store context for the auth store.\n * @param fetchOptions - Configuration options. When `useProjectHostname` is\n *   `true`, requests use the project-specific hostname (required for Studio\n *   cookie auth). Set to `true` for studio mode, `false` otherwise.\n *\n * @internal\n */\nexport const subscribeToStateAndFetchCurrentUser = (\n  {state, instance}: StoreContext<AuthStoreState>,\n  fetchOptions?: {useProjectHostname?: boolean},\n): Subscription => {\n  const logger = getAuthLogger(instance)\n\n  const {clientFactory, apiHost} = state.get().options\n  const useProjectHostname = fetchOptions?.useProjectHostname ?? isStudioConfig(instance.config)\n  const projectId = instance.config.projectId\n\n  const currentUser$ = state.observable\n    .pipe(\n      map(({authState, options: storeOptions}) => ({\n        authState,\n        authMethod: storeOptions.authMethod,\n      })),\n      filter(\n        (\n          value,\n        ): value is {\n          authState: Extract<AuthState, {type: AuthStateType.LOGGED_IN}>\n          authMethod: AuthMethodOptions\n        } => value.authState.type === AuthStateType.LOGGED_IN && !value.authState.currentUser,\n      ),\n      map((value) => ({token: value.authState.token, authMethod: value.authMethod})),\n      distinctUntilChanged(\n        (prev, curr) => prev.token === curr.token && prev.authMethod === curr.authMethod,\n      ),\n    )\n    .pipe(\n      map(({token, authMethod}) =>\n        clientFactory({\n          apiVersion: DEFAULT_API_VERSION,\n          requestTagPrefix: REQUEST_TAG_PREFIX,\n          token: authMethod === 'cookie' ? undefined : token,\n          ignoreBrowserTokenWarning: true,\n          useProjectHostname,\n          useCdn: false,\n          ...(authMethod === 'cookie' ? {withCredentials: true} : {}),\n          ...(useProjectHostname && projectId ? {projectId} : {}),\n          ...(apiHost && {apiHost}),\n        }),\n      ),\n      switchMap((client) =>\n        client.observable\n          .request<CurrentUser>({\n            url: '/users/me',\n            method: 'GET',\n            tag: 'users.get-current',\n          })\n          .pipe(\n            /**\n             * Catch inside switchMap so the outer subscription survives.\n             * Without this, a 401 terminates the subscription permanently\n             * and subsequent token refreshes via comlink never re-fetch /users/me.\n             * @see SDK-1409\n             */\n            catchError((error) => {\n              logger.error('Failed to fetch current user', {error})\n              state.set('setError', {authState: {type: AuthStateType.ERROR, error}})\n              return EMPTY\n            }),\n          ),\n      ),\n    )\n\n  return currentUser$.subscribe({\n    next: (currentUser) => {\n      logger.info('Current user fetched successfully', {\n        hasEmail: !!currentUser.email,\n      })\n      // userId is PII, so only surface it at debug level\n      logger.debug('Current user details', {userId: currentUser.id})\n      state.set('setCurrentUser', (prev) => ({\n        authState:\n          prev.authState.type === AuthStateType.LOGGED_IN\n            ? {...prev.authState, currentUser}\n            : prev.authState,\n      }))\n    },\n  })\n}\n","import {type ClientError} from '@sanity/client'\nimport {type CurrentUser} from '@sanity/types'\nimport {EMPTY, fromEvent, Observable} from 'rxjs'\n\nimport {AUTH_CODE_PARAM, DEFAULT_BASE} from './authConstants'\nimport {AuthStateType} from './authStateType'\nimport {type LoggedInAuthState} from './authStore'\n\n/**\n * Creates a properly initialized {@link LoggedInAuthState}.\n *\n * For stamped tokens (containing `\"-st\"`), `lastTokenRefresh` is set to\n * `Date.now()` so that the visibility-change handler in\n * {@link refreshStampedToken} does not trigger an unnecessary refresh the\n * first time the tab becomes visible.\n *\n * @param token - The auth token.\n * @param currentUser - The current user, or `null` if not yet fetched.\n * @param existingLastTokenRefresh - An existing timestamp to preserve\n *   (e.g. when updating a token while keeping the previous refresh time).\n * @internal\n */\nexport function createLoggedInAuthState(\n  token: string,\n  currentUser: CurrentUser | null,\n  existingLastTokenRefresh?: number,\n): LoggedInAuthState {\n  const isStampedToken = token.includes('-st')\n  const lastTokenRefresh = existingLastTokenRefresh ?? (isStampedToken ? Date.now() : undefined)\n\n  return {\n    type: AuthStateType.LOGGED_IN,\n    token,\n    currentUser,\n    ...(lastTokenRefresh !== undefined && {lastTokenRefresh}),\n  }\n}\n\nexport function getAuthCode(callbackUrl: string | undefined, locationHref: string): string | null {\n  const loc = new URL(locationHref, DEFAULT_BASE)\n  const callbackLocation = callbackUrl ? new URL(callbackUrl, DEFAULT_BASE) : undefined\n  const callbackLocationMatches = callbackLocation\n    ? loc.pathname.toLowerCase().startsWith(callbackLocation.pathname.toLowerCase())\n    : true\n\n  // First, try getting the auth code (sid) from hash or search params directly\n  let authCode =\n    new URLSearchParams(loc.hash.slice(1)).get(AUTH_CODE_PARAM) ||\n    new URLSearchParams(loc.search).get(AUTH_CODE_PARAM)\n\n  // If not found directly, try extracting it from the _context parameter as a fallback\n  if (!authCode) {\n    const contextParam = new URLSearchParams(loc.search).get('_context')\n    if (contextParam) {\n      try {\n        const parsedContext = JSON.parse(contextParam)\n        if (\n          parsedContext &&\n          typeof parsedContext === 'object' &&\n          typeof parsedContext.sid === 'string' &&\n          parsedContext.sid // Ensure it's not an empty string\n        ) {\n          authCode = parsedContext.sid\n        }\n      } catch {\n        // Silently ignore _context JSON parsing errors; authCode remains null/empty\n      }\n    }\n  }\n\n  return authCode && callbackLocationMatches ? authCode : null\n}\n\nexport function getTokenFromLocation(locationHref: string): string | null {\n  const loc = new URL(locationHref)\n  const token = new URLSearchParams(loc.hash.slice(1)).get('token')\n  return token ? token : null\n}\n\n/**\n * Attempts to retrieve a token from the configured storage.\n * If invalid or not present, returns null.\n */\nexport function getTokenFromStorage(\n  storageArea: Storage | undefined,\n  storageKey: string,\n): string | null {\n  if (!storageArea) return null\n  const item = storageArea.getItem(storageKey)\n  if (item === null) return null\n\n  try {\n    const parsed: unknown = JSON.parse(item)\n    if (\n      typeof parsed !== 'object' ||\n      parsed === null ||\n      !('token' in parsed) ||\n      typeof parsed.token !== 'string'\n    ) {\n      throw new Error('Invalid stored auth data structure')\n    }\n    return parsed.token\n  } catch {\n    storageArea.removeItem(storageKey)\n    return null\n  }\n}\n\n/**\n * Creates an observable stream of storage events. If not in a browser environment,\n * returns an EMPTY observable.\n */\nexport function getStorageEvents(): Observable<StorageEvent> {\n  const isBrowser = typeof window !== 'undefined' && typeof window.addEventListener === 'function'\n\n  if (!isBrowser) {\n    return EMPTY\n  }\n\n  return fromEvent<StorageEvent>(window, 'storage')\n}\n\n/**\n * Returns a default storage instance (localStorage) if available.\n * If not available or an error occurs, returns undefined.\n */\nexport function getDefaultStorage(): Storage | undefined {\n  try {\n    if (typeof localStorage !== 'undefined' && typeof localStorage.getItem === 'function') {\n      return localStorage\n    }\n    return undefined\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * Returns the default location to use.\n * Tries accessing `location.href`, falls back to a default base if not available or on error.\n */\nexport function getDefaultLocation(): string {\n  try {\n    if (typeof location === 'undefined') return DEFAULT_BASE\n    if (typeof location.href === 'string') return location.href\n    return DEFAULT_BASE\n  } catch {\n    return DEFAULT_BASE\n  }\n}\n\n/**\n * Cleans up the URL by removing the `token` from the hash and the `sid` and `url` search params.\n * @internal\n */\nexport function getCleanedUrl(locationUrl: string): string {\n  const loc = new URL(locationUrl)\n  // Remove only the `token` param from the hash while preserving other fragments\n  const rawHash = loc.hash.startsWith('#') ? loc.hash.slice(1) : loc.hash\n  if (rawHash && rawHash.includes('=')) {\n    const hashParams = new URLSearchParams(rawHash)\n    hashParams.delete('token')\n    hashParams.delete('withSid')\n    const nextHash = hashParams.toString()\n    loc.hash = nextHash ? `#${nextHash}` : ''\n  }\n  loc.searchParams.delete('sid')\n  loc.searchParams.delete('url')\n  return loc.toString()\n}\n\n// -----------------------------------------------------------------------------\n// ClientError helpers (shared)\n// -----------------------------------------------------------------------------\n\n/** @internal */\nexport type ApiErrorBody = {\n  error?: {type?: string; description?: string}\n  type?: string\n  description?: string\n  message?: string\n}\n\n/** @internal Extracts the structured API error body from a ClientError, if present. */\nexport function getClientErrorApiBody(error: ClientError): ApiErrorBody | undefined {\n  const body: unknown = (error as ClientError).response?.body\n  return body && typeof body === 'object' ? (body as ApiErrorBody) : undefined\n}\n\n/** @internal Returns the error type string from an API error body, if available. */\nexport function getClientErrorApiType(error: ClientError): string | undefined {\n  const body = getClientErrorApiBody(error)\n  return body?.error?.type ?? body?.type\n}\n\n/** @internal Returns the error description string from an API error body, if available. */\nexport function getClientErrorApiDescription(error: ClientError): string | undefined {\n  const body = getClientErrorApiBody(error)\n  return body?.error?.description ?? body?.description\n}\n\n/** @internal True if the error represents a projectUserNotFoundError. */\nexport function isProjectUserNotFoundClientError(error: ClientError): boolean {\n  return getClientErrorApiType(error) === 'projectUserNotFoundError'\n}\n","import {type Subscription} from 'rxjs'\n\nimport {type StoreContext} from '../store/defineStore'\nimport {DEFAULT_BASE} from './authConstants'\nimport {AuthStateType} from './authStateType'\nimport {type AuthStoreState, type DashboardContext} from './authStore'\nimport {type AuthStrategyOptions, type AuthStrategyResult} from './authStrategy'\nimport {refreshStampedToken} from './refreshStampedToken'\nimport {subscribeToStateAndFetchCurrentUser} from './subscribeToStateAndFetchCurrentUser'\nimport {createLoggedInAuthState, getAuthCode, getTokenFromLocation} from './utils'\n\n/**\n * Parses the dashboard context from a location href's `_context` URL parameter.\n * Strips the `sid` property from the parsed context (it's handled separately).\n *\n * @internal\n */\nfunction parseDashboardContext(locationHref: string): DashboardContext {\n  try {\n    const parsedUrl = new URL(locationHref, DEFAULT_BASE)\n    const contextParam = parsedUrl.searchParams.get('_context')\n    if (contextParam) {\n      const parsedContext = JSON.parse(contextParam)\n\n      if (\n        parsedContext &&\n        typeof parsedContext === 'object' &&\n        !Array.isArray(parsedContext) &&\n        Object.keys(parsedContext).length > 0\n      ) {\n        // Explicitly remove the 'sid' property before assigning\n        delete parsedContext.sid\n        return parsedContext as DashboardContext\n      }\n    }\n  } catch (err) {\n    // eslint-disable-next-line no-console\n    console.error('Failed to parse dashboard context from initial location:', err)\n  }\n  return {} // Empty dashboard context if parsing fails\n}\n\n/**\n * Resolves the initial auth state for Dashboard mode.\n *\n * In dashboard mode the token is provided by the parent frame via Comlink,\n * so the SDK starts in a `LOGGED_OUT` state and waits for the token to arrive.\n * The `_context` URL parameter provides dashboard metadata (orgId, mode, env).\n *\n * A provided token (`auth.token`) or an auth code/callback still takes\n * precedence, even when running inside the dashboard.\n *\n * @internal\n */\nexport function getDashboardInitialState(options: AuthStrategyOptions): AuthStrategyResult {\n  const {authConfig, initialLocationHref} = options\n  const providedToken = authConfig.token\n  const callbackUrl = authConfig.callbackUrl\n  const storageKey = '__sanity_auth_token'\n\n  const dashboardContext = parseDashboardContext(initialLocationHref)\n\n  // Dashboard does NOT use localStorage — token comes from the parent frame\n  const storageArea = undefined\n\n  // Provided token always wins, even in dashboard\n  if (providedToken) {\n    return {\n      authState: createLoggedInAuthState(providedToken, null),\n      storageKey,\n      storageArea,\n      authMethod: undefined,\n      dashboardContext,\n    }\n  }\n\n  // Check for auth code or token-from-location (callback handling)\n  if (getAuthCode(callbackUrl, initialLocationHref) || getTokenFromLocation(initialLocationHref)) {\n    return {\n      authState: {type: AuthStateType.LOGGING_IN, isExchangingToken: false},\n      storageKey,\n      storageArea,\n      authMethod: undefined,\n      dashboardContext,\n    }\n  }\n\n  // Default: logged out, waiting for Comlink to provide token\n  return {\n    authState: {type: AuthStateType.LOGGED_OUT, isDestroyingSession: false},\n    storageKey,\n    storageArea,\n    authMethod: undefined,\n    dashboardContext,\n  }\n}\n\n/**\n * Initialize Dashboard auth subscriptions:\n * - Subscribe to state changes and fetch current user\n * - Start stamped token refresh\n *\n * Note: storage events are NOT subscribed in dashboard mode since\n * the dashboard does not use localStorage for token persistence.\n *\n * @internal\n */\nexport function initializeDashboardAuth(\n  context: StoreContext<AuthStoreState>,\n  tokenRefresherRunning: boolean,\n): {dispose: () => void; tokenRefresherStarted: boolean} {\n  const subscriptions: Subscription[] = []\n  let startedRefresher = false\n\n  subscriptions.push(subscribeToStateAndFetchCurrentUser(context, {useProjectHostname: false}))\n\n  // Dashboard does not subscribe to storage events\n\n  if (!tokenRefresherRunning) {\n    startedRefresher = true\n    subscriptions.push(refreshStampedToken(context))\n  }\n\n  return {\n    dispose: () => {\n      for (const subscription of subscriptions) {\n        subscription.unsubscribe()\n      }\n    },\n    tokenRefresherStarted: startedRefresher,\n  }\n}\n","import {defer, distinctUntilChanged, filter, map, type Subscription} from 'rxjs'\n\nimport {type StoreContext} from '../../store/defineStore'\nimport {DEFAULT_BASE} from '../authConstants'\nimport {AuthStateType} from '../authStateType'\nimport {type AuthStoreState} from '../authStore'\nimport {type AuthStrategyOptions, type AuthStrategyResult} from '../authStrategy'\nimport {subscribeToStateAndFetchCurrentUser} from '../subscribeToStateAndFetchCurrentUser'\nimport {createLoggedInAuthState, getDefaultStorage, getStorageEvents} from '../utils'\nimport {type OAuthTokens} from './types'\n\n/** localStorage (or configured `storageArea`) key for persisted OAuth tokens. */\nexport const OAUTH_TOKENS_KEY = '__sanity_oauth_tokens'\n\n/** The persisted JSON shape of {@link OAuthTokens}, `expiresAt` as an ISO string. */\ninterface SerializedOAuthTokens extends Omit<OAuthTokens, 'expiresAt'> {\n  expiresAt: string\n}\n\n/**\n * Parses persisted token JSON back into {@link OAuthTokens}. Returns `null`\n * when the value is missing or malformed, including an `expiresAt` that does\n * not parse to a valid date (an `Invalid Date` would otherwise read as never\n * expiring, since `NaN <= now` is always `false`).\n *\n * @internal\n */\nexport function deserializeTokens(raw: string | null): OAuthTokens | null {\n  if (!raw) return null\n  try {\n    const parsed: unknown = JSON.parse(raw)\n    if (\n      typeof parsed !== 'object' ||\n      parsed === null ||\n      !('accessToken' in parsed) ||\n      typeof (parsed as SerializedOAuthTokens).accessToken !== 'string' ||\n      !('expiresAt' in parsed) ||\n      typeof (parsed as SerializedOAuthTokens).expiresAt !== 'string'\n    ) {\n      return null\n    }\n    const value = parsed as SerializedOAuthTokens\n    const expiresAt = new Date(value.expiresAt)\n    if (Number.isNaN(expiresAt.getTime())) return null\n    return {\n      accessToken: value.accessToken,\n      tokenType: 'bearer',\n      expiresIn: value.expiresIn,\n      expiresAt,\n      ...(value.refreshToken !== undefined && {refreshToken: value.refreshToken}),\n    }\n  } catch {\n    return null\n  }\n}\n\n/**\n * Resolves the initial auth state for OAuth mode.\n *\n * State discovery order:\n * 1. Persisted tokens in `__sanity_oauth_tokens` → `LOGGED_IN`\n * 2. Callback URL (contains `code` or `error` and matches `redirectUri`)\n *    → `LOGGING_IN`\n * 3. Otherwise → `LOGGED_OUT`\n *\n * @internal\n */\nexport function getOauthInitialState(options: AuthStrategyOptions): AuthStrategyResult {\n  const {authConfig, initialLocationHref} = options\n  const storageKey = OAUTH_TOKENS_KEY\n  const storageArea = authConfig.storageArea ?? getDefaultStorage()\n  const redirectUri = authConfig.oauth?.redirectUri\n\n  // Persisted tokens win\n  const rawTokens = storageArea?.getItem(OAUTH_TOKENS_KEY) ?? null\n  const tokens = deserializeTokens(rawTokens)\n  if (rawTokens && !tokens) {\n    // Corrupt entry: drop it so it cannot keep shadowing a fresh login\n    storageArea?.removeItem(OAUTH_TOKENS_KEY)\n  }\n  if (tokens) {\n    return {\n      authState: createLoggedInAuthState(tokens.accessToken, null),\n      storageKey,\n      storageArea,\n      authMethod: 'localstorage',\n      dashboardContext: {},\n      oauthTokens: tokens,\n    }\n  }\n\n  // Callback URL with code/error whose origin + pathname match our redirect\n  // URI (query and hash are ignored). `state` alone is not a callback: the\n  // server always sends `code` or `error`, and handleOAuthCallback would\n  // otherwise leave the app stuck in LOGGING_IN.\n  const {searchParams} = new URL(initialLocationHref, DEFAULT_BASE)\n  const isCallback = searchParams.has('code') || searchParams.has('error')\n  if (redirectUri && isCallback) {\n    const loc = new URL(initialLocationHref, DEFAULT_BASE)\n    const redirect = new URL(redirectUri, DEFAULT_BASE)\n    if (loc.origin === redirect.origin && loc.pathname === redirect.pathname) {\n      return {\n        authState: {type: AuthStateType.LOGGING_IN, isExchangingToken: false},\n        storageKey,\n        storageArea,\n        authMethod: undefined,\n        dashboardContext: {},\n      }\n    }\n  }\n\n  // No tokens, not a callback\n  return {\n    authState: {type: AuthStateType.LOGGED_OUT, isDestroyingSession: false},\n    storageKey,\n    storageArea,\n    authMethod: undefined,\n    dashboardContext: {},\n  }\n}\n\n/**\n * Subscribes to cross-tab `storage` events for the OAuth tokens key, syncing\n * this tab's auth state when tokens change in another tab.\n *\n * @internal\n */\nexport function subscribeToOAuthStorageEvents({state}: StoreContext<AuthStoreState>): Subscription {\n  const {storageArea} = state.get().options\n\n  const tokens$ = defer(getStorageEvents).pipe(\n    filter((e) => e.storageArea === storageArea && e.key === OAUTH_TOKENS_KEY),\n    map(() => deserializeTokens(storageArea?.getItem(OAUTH_TOKENS_KEY) ?? null)),\n    distinctUntilChanged((a, b) => a?.accessToken === b?.accessToken),\n  )\n\n  return tokens$.subscribe((tokens) => {\n    state.set('updateOAuthTokensFromStorageEvent', {\n      authState: tokens\n        ? createLoggedInAuthState(tokens.accessToken, null)\n        : {type: AuthStateType.LOGGED_OUT, isDestroyingSession: false},\n      oauthTokens: tokens ?? undefined,\n    })\n  })\n}\n\n/**\n * Initialize OAuth auth subscriptions:\n * - Subscribe to state changes and fetch current user\n * - Subscribe to cross-tab storage events for the OAuth tokens key\n *\n * OAuth tokens are refreshed via the `refresh_token` grant (see\n * `refreshOAuthTokens`), so the stamped-token refresher is not started here.\n *\n * @internal\n */\nexport function initializeOauthAuth(context: StoreContext<AuthStoreState>): {\n  dispose: () => void\n  tokenRefresherStarted: boolean\n} {\n  const subscriptions: Subscription[] = []\n\n  subscriptions.push(subscribeToStateAndFetchCurrentUser(context, {useProjectHostname: false}))\n\n  const storageArea = context.state.get().options?.storageArea\n  if (storageArea) {\n    subscriptions.push(subscribeToOAuthStorageEvents(context))\n  }\n\n  return {\n    dispose: () => {\n      for (const subscription of subscriptions) {\n        subscription.unsubscribe()\n      }\n    },\n    tokenRefresherStarted: false,\n  }\n}\n","import {defer, distinctUntilChanged, filter, map, type Subscription} from 'rxjs'\n\nimport {type StoreContext} from '../store/defineStore'\nimport {AuthStateType} from './authStateType'\nimport {type AuthStoreState} from './authStore'\nimport {createLoggedInAuthState, getStorageEvents, getTokenFromStorage} from './utils'\n\nexport const subscribeToStorageEventsAndSetToken = ({\n  state,\n}: StoreContext<AuthStoreState>): Subscription => {\n  const {storageArea, storageKey} = state.get().options\n\n  const tokenFromStorage$ = defer(getStorageEvents).pipe(\n    filter(\n      (e): e is StorageEvent & {newValue: string} =>\n        e.storageArea === storageArea && e.key === storageKey,\n    ),\n    map(() => getTokenFromStorage(storageArea, storageKey)),\n    distinctUntilChanged(),\n  )\n\n  return tokenFromStorage$.subscribe((token) => {\n    state.set('updateTokenFromStorageEvent', {\n      authState: token\n        ? createLoggedInAuthState(token, null)\n        : {type: AuthStateType.LOGGED_OUT, isDestroyingSession: false},\n    })\n  })\n}\n","import {type Subscription} from 'rxjs'\n\nimport {type StoreContext} from '../store/defineStore'\nimport {AuthStateType} from './authStateType'\nimport {type AuthStoreState} from './authStore'\nimport {type AuthStrategyOptions, type AuthStrategyResult} from './authStrategy'\nimport {refreshStampedToken} from './refreshStampedToken'\nimport {subscribeToStateAndFetchCurrentUser} from './subscribeToStateAndFetchCurrentUser'\nimport {subscribeToStorageEventsAndSetToken} from './subscribeToStorageEventsAndSetToken'\nimport {\n  createLoggedInAuthState,\n  getAuthCode,\n  getDefaultStorage,\n  getTokenFromLocation,\n  getTokenFromStorage,\n} from './utils'\n\n/**\n * Resolves the initial auth state for Standalone mode.\n *\n * Token discovery order:\n * 1. Provided token (`auth.token` in config)\n * 2. Auth code or token from location (OAuth callback)\n * 3. localStorage: `__sanity_auth_token`\n * 4. Falls back to `LOGGED_OUT`\n *\n * @internal\n */\nexport function getStandaloneInitialState(options: AuthStrategyOptions): AuthStrategyResult {\n  const {authConfig, initialLocationHref} = options\n  const providedToken = authConfig.token\n  const callbackUrl = authConfig.callbackUrl\n  const storageKey = '__sanity_auth_token'\n  const storageArea = authConfig.storageArea ?? getDefaultStorage()\n\n  // Provided token always wins\n  if (providedToken) {\n    return {\n      authState: createLoggedInAuthState(providedToken, null),\n      storageKey,\n      storageArea,\n      authMethod: undefined,\n      dashboardContext: {},\n    }\n  }\n\n  // Check for auth code or token-from-location (OAuth callback)\n  if (getAuthCode(callbackUrl, initialLocationHref) || getTokenFromLocation(initialLocationHref)) {\n    return {\n      authState: {type: AuthStateType.LOGGING_IN, isExchangingToken: false},\n      storageKey,\n      storageArea,\n      authMethod: undefined,\n      dashboardContext: {},\n    }\n  }\n\n  // Try localStorage\n  const token = getTokenFromStorage(storageArea, storageKey)\n  if (token) {\n    return {\n      authState: createLoggedInAuthState(token, null),\n      storageKey,\n      storageArea,\n      authMethod: 'localstorage',\n      dashboardContext: {},\n    }\n  }\n\n  // No token found\n  return {\n    authState: {type: AuthStateType.LOGGED_OUT, isDestroyingSession: false},\n    storageKey,\n    storageArea,\n    authMethod: undefined,\n    dashboardContext: {},\n  }\n}\n\n/**\n * Initialize Standalone auth subscriptions:\n * - Subscribe to state changes and fetch current user\n * - Subscribe to storage events for token key\n * - Start stamped token refresh\n *\n * @internal\n */\nexport function initializeStandaloneAuth(\n  context: StoreContext<AuthStoreState>,\n  tokenRefresherRunning: boolean,\n): {dispose: () => void; tokenRefresherStarted: boolean} {\n  const subscriptions: Subscription[] = []\n  let startedRefresher = false\n\n  subscriptions.push(subscribeToStateAndFetchCurrentUser(context, {useProjectHostname: false}))\n\n  const storageArea = context.state.get().options?.storageArea\n  if (storageArea) {\n    subscriptions.push(subscribeToStorageEventsAndSetToken(context))\n  }\n\n  if (!tokenRefresherRunning) {\n    startedRefresher = true\n    subscriptions.push(refreshStampedToken(context))\n  }\n\n  return {\n    dispose: () => {\n      for (const subscription of subscriptions) {\n        subscription.unsubscribe()\n      }\n    },\n    tokenRefresherStarted: startedRefresher,\n  }\n}\n","import {type ClientConfig, type SanityClient} from '@sanity/client'\n\nimport {REQUEST_TAG_PREFIX} from './authConstants'\nimport {getTokenFromStorage} from './utils'\n\n/**\n * Cookie auth is a best-effort probe — if the API doesn't respond quickly,\n * the user likely isn't cookie-authenticated and we should move on rather\n * than block the auth flow indefinitely.\n */\nconst COOKIE_AUTH_TIMEOUT_MS = 10_000\n\n/**\n * Attempts to check for cookie auth by making a withCredentials request to the users endpoint.\n * @param projectId - The project ID to check for cookie auth.\n * @param clientFactory - A factory function that creates a Sanity client.\n * @returns True if the user is authenticated, false otherwise.\n * @internal\n */\nexport async function checkForCookieAuth(\n  projectId: string | undefined,\n  clientFactory: (config: ClientConfig) => SanityClient,\n): Promise<boolean> {\n  if (!projectId) return false\n  try {\n    const client = clientFactory({\n      projectId,\n      useCdn: false,\n      requestTagPrefix: REQUEST_TAG_PREFIX,\n      timeout: COOKIE_AUTH_TIMEOUT_MS,\n    })\n    const user = await client.request({\n      url: '/users/me',\n      withCredentials: true,\n      tag: 'users.get-current',\n    })\n    return user != null && typeof user === 'object' && typeof user.id === 'string'\n  } catch {\n    return false\n  }\n}\n\n/**\n * Attempts to retrieve a studio token from local storage.\n * @param storageArea - The storage area to retrieve the token from.\n * @param storageKey - The storage key to retrieve the token from.\n * @returns The studio token or null if it does not exist.\n * @internal\n */\nexport function getStudioTokenFromLocalStorage(\n  storageArea: Storage | undefined,\n  storageKey: string | undefined,\n): string | null {\n  if (!storageArea || !storageKey) return null\n  const token = getTokenFromStorage(storageArea, storageKey)\n  if (token) {\n    return token\n  }\n  return null\n}\n","import {type Subscription} from 'rxjs'\n\nimport {type TokenSource} from '../config/sanityConfig'\nimport {type StoreContext} from '../store/defineStore'\nimport {AuthStateType} from './authStateType'\nimport {type AuthStoreState, type LoggedInAuthState} from './authStore'\nimport {type AuthStrategyOptions, type AuthStrategyResult} from './authStrategy'\nimport {refreshStampedToken} from './refreshStampedToken'\nimport {checkForCookieAuth, getStudioTokenFromLocalStorage} from './studioModeAuth'\nimport {subscribeToStateAndFetchCurrentUser} from './subscribeToStateAndFetchCurrentUser'\nimport {subscribeToStorageEventsAndSetToken} from './subscribeToStorageEventsAndSetToken'\nimport {createLoggedInAuthState, getDefaultStorage} from './utils'\n\n/**\n * Resolves the initial auth state for Studio mode.\n *\n * When a `tokenSource` is provided (via `config.studio.auth.token`), the\n * initial state is `LOGGING_IN` — the actual token arrives asynchronously\n * via the subscription set up in `initializeStudioAuth`.\n *\n * Fallback token discovery order (no tokenSource):\n * 1. Provided token (`auth.token` in config)\n * 2. localStorage: `__studio_auth_token_${projectId}`\n * 3. Falls back to `LOGGED_OUT` (cookie auth is checked async in `initializeStudioAuth`)\n *\n * @internal\n */\nexport function getStudioInitialState(options: AuthStrategyOptions): AuthStrategyResult {\n  const {authConfig, projectId, tokenSource} = options\n  const storageArea = authConfig.storageArea ?? getDefaultStorage()\n  const studioStorageKey = `__studio_auth_token_${projectId ?? ''}`\n\n  // When a reactive token source is available, start in LOGGING_IN state.\n  // The actual token will arrive via subscription in initializeStudioAuth.\n  if (tokenSource) {\n    return {\n      authState: {type: AuthStateType.LOGGING_IN, isExchangingToken: false},\n      storageKey: studioStorageKey,\n      storageArea,\n      authMethod: undefined,\n      dashboardContext: {},\n    }\n  }\n\n  // Fallback: discover token from config or localStorage\n  const providedToken = authConfig.token\n\n  // Check localStorage first — mirrors original authStore behavior where\n  // the localStorage read always runs before the providedToken check.\n  let authMethod: AuthStrategyResult['authMethod'] = undefined\n  const token = getStudioTokenFromLocalStorage(storageArea, studioStorageKey)\n  if (token) {\n    authMethod = 'localstorage'\n  }\n\n  if (providedToken) {\n    return {\n      authState: createLoggedInAuthState(providedToken, null),\n      storageKey: studioStorageKey,\n      storageArea,\n      authMethod,\n      dashboardContext: {},\n    }\n  }\n\n  if (token) {\n    return {\n      authState: createLoggedInAuthState(token, null),\n      storageKey: studioStorageKey,\n      storageArea,\n      authMethod: 'localstorage',\n      dashboardContext: {},\n    }\n  }\n\n  // No token found — start logged out, cookie auth will be checked asynchronously\n  return {\n    authState: {type: AuthStateType.LOGGED_OUT, isDestroyingSession: false},\n    storageKey: studioStorageKey,\n    storageArea,\n    authMethod: undefined,\n    dashboardContext: {},\n  }\n}\n\n/**\n * Initialize Studio auth subscriptions.\n *\n * When a `tokenSource` is available (reactive path), subscribes to it for\n * ongoing token sync. The Studio is the token authority — no independent\n * token refresh or cookie auth probing is needed.\n *\n * Fallback path (no tokenSource):\n * - Subscribe to state changes and fetch current user\n * - Subscribe to storage events for studio token key\n * - Check for cookie auth asynchronously if no token was found\n * - Start stamped token refresh\n *\n * @internal\n */\nexport function initializeStudioAuth(\n  context: StoreContext<AuthStoreState>,\n  tokenRefresherRunning: boolean,\n): {dispose: () => void; tokenRefresherStarted: boolean} {\n  const tokenSource = context.instance.config.studio?.auth?.token\n\n  // Reactive token path — Studio provides the token\n  if (tokenSource) {\n    return initializeWithTokenSource(context, tokenSource)\n  }\n\n  // Fallback path — discover token from localStorage/cookies\n  return initializeWithFallback(context, tokenRefresherRunning)\n}\n\n/**\n * Subscribe to a reactive token source from the Studio workspace.\n *\n * When the token source emits a non-null token, the SDK uses it directly.\n * When it emits `null`, the behavior depends on the `authenticated` flag\n * from the Studio's workspace config:\n *\n * - `authenticated: true` — the Studio has already verified the user is\n *   logged in (e.g. via cookie auth). The SDK treats the null token as\n *   cookie-based auth and stays in the LOGGED_IN state.\n *\n * - `authenticated` absent/false — the user is genuinely not authenticated;\n *   transition to LOGGED_OUT.\n *\n * No async cookie probing is needed here because this code path only runs\n * when a Studio provides SDKStudioContext, and the Studio's Workspace type\n * always includes `authenticated`. The async `checkForCookieAuth` fallback\n * remains in `initializeWithFallback` for the non-Studio path.\n */\nfunction initializeWithTokenSource(\n  context: StoreContext<AuthStoreState>,\n  tokenSource: TokenSource,\n): {dispose: () => void; tokenRefresherStarted: boolean} {\n  const subscriptions: Subscription[] = []\n  const studioAuthenticated = context.instance.config.studio?.authenticated === true\n\n  // Subscribe to the current user fetcher — runs whenever auth state changes\n  subscriptions.push(subscribeToStateAndFetchCurrentUser(context, {useProjectHostname: true}))\n\n  // Subscribe to the Studio's token stream\n  const tokenSub = tokenSource.subscribe({\n    next: (token) => {\n      const {state} = context\n      if (token) {\n        // Studio provided a real token — use it directly\n        state.set('studioTokenSource', (prev) => ({\n          options: {...prev.options, authMethod: undefined},\n          authState: createLoggedInAuthState(token, null),\n        }))\n      } else if (studioAuthenticated) {\n        // The Studio says the user is authenticated — null token means\n        // cookie-based auth is in use. Stay logged in with cookie method.\n        state.set('studioTokenSourceCookieAuth', (prev) => ({\n          options: {...prev.options, authMethod: 'cookie'},\n          authState:\n            prev.authState.type === AuthStateType.LOGGED_IN\n              ? prev.authState\n              : createLoggedInAuthState('', null),\n        }))\n      } else {\n        // No token and Studio doesn't confirm authentication — logged out\n        state.set('studioTokenSourceLoggedOut', (prev) => ({\n          options: {...prev.options, authMethod: undefined},\n          authState: {type: AuthStateType.LOGGED_OUT, isDestroyingSession: false},\n        }))\n      }\n    },\n  })\n\n  return {\n    dispose: () => {\n      tokenSub.unsubscribe()\n      for (const subscription of subscriptions) {\n        subscription.unsubscribe()\n      }\n    },\n    // Studio handles token refresh — do not start the SDK's refresher\n    tokenRefresherStarted: false,\n  }\n}\n\n/**\n * Fallback initialization when no reactive token source is available.\n * Uses localStorage/cookie discovery (existing behavior).\n */\nfunction initializeWithFallback(\n  context: StoreContext<AuthStoreState>,\n  tokenRefresherRunning: boolean,\n): {dispose: () => void; tokenRefresherStarted: boolean} {\n  const subscriptions: Subscription[] = []\n  let startedRefresher = false\n\n  subscriptions.push(subscribeToStateAndFetchCurrentUser(context, {useProjectHostname: true}))\n\n  const storageArea = context.state.get().options?.storageArea\n  if (storageArea) {\n    subscriptions.push(subscribeToStorageEventsAndSetToken(context))\n  }\n\n  // If no token found during getInitialState, try cookie auth asynchronously\n  try {\n    const {instance, state} = context\n    const token: string | null =\n      state.get().authState?.type === AuthStateType.LOGGED_IN\n        ? (state.get().authState as LoggedInAuthState).token\n        : null\n\n    if (!token) {\n      const projectIdValue = instance.config.projectId\n      const clientFactory = state.get().options.clientFactory\n      checkForCookieAuth(projectIdValue, clientFactory).then((isCookieAuthEnabled) => {\n        if (!isCookieAuthEnabled) return\n        state.set('enableCookieAuth', (prev) => ({\n          options: {...prev.options, authMethod: 'cookie'},\n          authState:\n            prev.authState.type === AuthStateType.LOGGED_IN\n              ? prev.authState\n              : createLoggedInAuthState('', null),\n        }))\n      })\n    }\n  } catch {\n    // best-effort cookie detection\n  }\n\n  if (!tokenRefresherRunning) {\n    startedRefresher = true\n    subscriptions.push(refreshStampedToken(context))\n  }\n\n  return {\n    dispose: () => {\n      for (const subscription of subscriptions) {\n        subscription.unsubscribe()\n      }\n    },\n    tokenRefresherStarted: startedRefresher,\n  }\n}\n","import {type ClientConfig, createClient, type SanityClient} from '@sanity/client'\nimport {type CurrentUser} from '@sanity/types'\n\nimport {type AuthConfig, type AuthProvider} from '../config/authConfig'\nimport {bindActionGlobally} from '../store/createActionBinder'\nimport {createStateSourceAction} from '../store/createStateSourceAction'\nimport {defineStore} from '../store/defineStore'\nimport {getStagingApiHost} from '../utils/getStagingApiHost'\nimport {getAuthLogger} from './authLogger'\nimport {resolveAuthMode} from './authMode'\nimport {AuthStateType} from './authStateType'\nimport {type AuthStrategyOptions} from './authStrategy'\nimport {getDashboardInitialState, initializeDashboardAuth} from './dashboardAuth'\nimport {getOauthInitialState, initializeOauthAuth} from './oauth/oauthAuth'\nimport {type OAuthTokens} from './oauth/types'\nimport {getStandaloneInitialState, initializeStandaloneAuth} from './standaloneAuth'\nimport {getStudioInitialState, initializeStudioAuth} from './studioAuth'\nimport {createLoggedInAuthState, getCleanedUrl, getDefaultLocation} from './utils'\n\n// ---------------------------------------------------------------------------\n// Public types\n// ---------------------------------------------------------------------------\n\n/**\n * Represents the various states the authentication can be in.\n *\n * @public\n */\nexport type AuthState = LoggedInAuthState | LoggedOutAuthState | LoggingInAuthState | ErrorAuthState\n\n/**\n * Logged-in state from the auth state.\n * @public\n */\nexport type LoggedInAuthState = {\n  type: AuthStateType.LOGGED_IN\n  token: string\n  currentUser: CurrentUser | null\n  lastTokenRefresh?: number\n}\n\n/**\n * Logged-out state from the auth state.\n * @public\n */\nexport type LoggedOutAuthState = {type: AuthStateType.LOGGED_OUT; isDestroyingSession: boolean}\n\n/**\n * Logging-in state from the auth state.\n * @public\n */\nexport type LoggingInAuthState = {type: AuthStateType.LOGGING_IN; isExchangingToken: boolean}\n\n/**\n * Error state from the auth state.\n * @public\n */\nexport type ErrorAuthState = {type: AuthStateType.ERROR; error: unknown}\n\n/**\n * Represents the various states the authentication can be in.\n *\n * @public\n */\nexport interface DashboardContext {\n  mode?: string\n  env?: string\n  orgId?: string\n}\n\n/**\n * The method of authentication used.\n * @internal\n */\nexport type AuthMethodOptions = 'localstorage' | 'cookie' | undefined\n\nlet tokenRefresherRunning = false\n\n/**\n * @public\n */\nexport interface AuthStoreState {\n  authState: AuthState\n  providers?: AuthProvider[]\n  options: {\n    initialLocationHref: string\n    clientFactory: (config: ClientConfig) => SanityClient\n    customProviders: AuthConfig['providers']\n    storageKey: string\n    storageArea: Storage | undefined\n    apiHost: string | undefined\n    loginUrl: string\n    callbackUrl: string | undefined\n    providedToken: string | undefined\n    authMethod: AuthMethodOptions\n    oauth: AuthConfig['oauth']\n  }\n  dashboardContext?: DashboardContext\n  oauthTokens?: OAuthTokens\n}\n\n// ---------------------------------------------------------------------------\n// Store definition — thin orchestrator\n// ---------------------------------------------------------------------------\n\nexport const authStore = defineStore<AuthStoreState>({\n  name: 'Auth',\n\n  getInitialState(instance) {\n    const logger = getAuthLogger(instance)\n\n    logger.debug('Initializing auth store', {\n      hasProvidedToken: !!instance.config.auth?.token,\n      hasCustomProviders: !!(\n        instance.config.auth?.providers && instance.config.auth.providers.length > 0\n      ),\n    })\n\n    const {\n      apiHost: configApiHost,\n      callbackUrl,\n      providers: customProviders,\n      token: providedToken,\n      clientFactory = createClient,\n      initialLocationHref = getDefaultLocation(),\n    } = instance.config.auth ?? {}\n\n    const apiHost = configApiHost ?? getStagingApiHost()\n    const authConfig = instance.config.auth ?? {}\n\n    // Build login URL (used by standalone mode, but always computed for the\n    // public `getLoginUrlState` accessor)\n    let loginDomain = 'https://www.sanity.io'\n    try {\n      if (apiHost && new URL(apiHost).hostname.endsWith('.sanity.work')) {\n        loginDomain = 'https://www.sanity.work'\n      }\n    } catch {\n      /* empty */\n    }\n    const loginUrl = new URL('/login', loginDomain)\n    loginUrl.searchParams.set('origin', getCleanedUrl(initialLocationHref))\n    loginUrl.searchParams.set('type', 'stampedToken') // Token must be stamped to have an sid passed back\n    loginUrl.searchParams.set('withSid', 'true')\n\n    // Resolve auth mode and delegate to the appropriate strategy\n    const mode = resolveAuthMode(instance.config, initialLocationHref)\n\n    const strategyOptions: AuthStrategyOptions = {\n      authConfig,\n      projectId: instance.config.projectId,\n      initialLocationHref,\n      clientFactory,\n      tokenSource: instance.config.studio?.auth?.token,\n    }\n\n    let result\n    switch (mode) {\n      case 'studio':\n        result = getStudioInitialState(strategyOptions)\n        break\n      case 'oauth':\n        result = getOauthInitialState(strategyOptions)\n        break\n      case 'dashboard':\n        result = getDashboardInitialState(strategyOptions)\n        break\n      case 'standalone':\n        result = getStandaloneInitialState(strategyOptions)\n        break\n    }\n\n    logger.debug('Auth state initialized', {\n      authStateType: result.authState.type,\n      mode,\n      authMethod: result.authMethod,\n    })\n\n    return {\n      authState: result.authState,\n      dashboardContext: result.dashboardContext,\n      oauthTokens: result.oauthTokens,\n      options: {\n        apiHost,\n        loginUrl: loginUrl.toString(),\n        callbackUrl,\n        customProviders,\n        providedToken,\n        clientFactory,\n        initialLocationHref,\n        storageKey: result.storageKey,\n        storageArea: result.storageArea,\n        authMethod: result.authMethod,\n        // Only expose oauth options when the oauth strategy is actually in use,\n        // so mode-gated actions (logout, handleAuthCallback) stay consistent\n        // with the resolved mode (e.g. `studio` takes precedence over `oauth`).\n        oauth: mode === 'oauth' ? authConfig.oauth : undefined,\n      },\n    }\n  },\n\n  initialize(context) {\n    const logger = getAuthLogger(context.instance)\n\n    const initialLocationHref =\n      context.state.get().options?.initialLocationHref ?? getDefaultLocation()\n    const mode = resolveAuthMode(context.instance.config, initialLocationHref)\n\n    logger.debug('Setting up auth subscriptions', {mode})\n\n    let initResult\n    switch (mode) {\n      case 'studio':\n        initResult = initializeStudioAuth(context, tokenRefresherRunning)\n        break\n      case 'oauth':\n        initResult = initializeOauthAuth(context)\n        break\n      case 'dashboard':\n        initResult = initializeDashboardAuth(context, tokenRefresherRunning)\n        break\n      case 'standalone':\n        initResult = initializeStandaloneAuth(context, tokenRefresherRunning)\n        break\n    }\n\n    if (initResult.tokenRefresherStarted) {\n      tokenRefresherRunning = true\n    }\n\n    return () => {\n      logger.debug('Cleaning up auth subscriptions')\n      initResult.dispose()\n    }\n  },\n})\n\n// ---------------------------------------------------------------------------\n// Public bound actions\n// ---------------------------------------------------------------------------\n\n/**\n * @public\n */\nexport const getCurrentUserState = bindActionGlobally(\n  authStore,\n  createStateSourceAction(({state: {authState}}) =>\n    authState.type === AuthStateType.LOGGED_IN ? authState.currentUser : null,\n  ),\n)\n\n/**\n * @public\n */\nexport const getTokenState = bindActionGlobally(\n  authStore,\n  createStateSourceAction(({state: {authState}}) =>\n    authState.type === AuthStateType.LOGGED_IN ? authState.token : null,\n  ),\n)\n\n/**\n * @internal\n */\nexport const getAuthMethodState = bindActionGlobally(\n  authStore,\n  createStateSourceAction(({state: {options}}) => options.authMethod),\n)\n\n/**\n * @public\n */\nexport const getLoginUrlState = bindActionGlobally(\n  authStore,\n  createStateSourceAction(({state: {options}}) => options.loginUrl),\n)\n\n/**\n * @public\n */\nexport const getAuthState = bindActionGlobally(\n  authStore,\n  createStateSourceAction(({state: {authState}}) => authState),\n)\n\n/**\n * @public\n */\nexport const getDashboardOrganizationId = bindActionGlobally(\n  authStore,\n  createStateSourceAction(({state: {dashboardContext}}) => dashboardContext?.orgId),\n)\n\n/**\n * Returns a state source indicating if the SDK is running within a dashboard context.\n * @public\n */\nexport const getIsInDashboardState = bindActionGlobally(\n  authStore,\n  createStateSourceAction(\n    ({state: {dashboardContext}}) =>\n      // Check if dashboardContext exists and is not empty\n      !!dashboardContext && Object.keys(dashboardContext).length > 0,\n  ),\n)\n\n/**\n * Action to explicitly set the authentication token.\n * Used internally by the Comlink token refresh.\n * @internal\n */\nexport const setAuthToken = bindActionGlobally(\n  authStore,\n  ({state, instance}, token: string | null) => {\n    const logger = getAuthLogger(instance)\n\n    const currentAuthState = state.get().authState\n    if (token) {\n      // Update state only if the new token is different or currently logged out\n      if (currentAuthState.type !== AuthStateType.LOGGED_IN || currentAuthState.token !== token) {\n        logger.info('Setting auth token')\n        const currentUser =\n          currentAuthState.type === AuthStateType.LOGGED_IN ? currentAuthState.currentUser : null\n        const preservedLastTokenRefresh =\n          currentAuthState.type === AuthStateType.LOGGED_IN\n            ? currentAuthState.lastTokenRefresh\n            : undefined\n        state.set('setToken', {\n          authState: createLoggedInAuthState(token, currentUser, preservedLastTokenRefresh),\n        })\n      }\n    } else {\n      // Handle setting token to null (logging out)\n      if (currentAuthState.type !== AuthStateType.LOGGED_OUT) {\n        logger.info('Clearing auth token')\n        state.set('setToken', {\n          authState: {type: AuthStateType.LOGGED_OUT, isDestroyingSession: false},\n        })\n      }\n    }\n  },\n)\n","import {type ClientConfig, createClient, type SanityClient} from '@sanity/client'\n\nimport {getAuthMethodState, getTokenState} from '../auth/authStore'\nimport {\n  type DocumentResource,\n  isCanvasResource,\n  isDatasetResource,\n  isMediaLibraryResource,\n} from '../config/sanityConfig'\nimport {bindActionGlobally} from '../store/createActionBinder'\nimport {createStateSourceAction} from '../store/createStateSourceAction'\nimport {defineStore, type StoreContext} from '../store/defineStore'\nimport {getStagingApiHost} from '../utils/getStagingApiHost'\nimport {pickProperties} from '../utils/object'\n\nconst DEFAULT_API_VERSION = '2024-11-12'\nconst DEFAULT_REQUEST_TAG_PREFIX = 'sanity.sdk'\n\ntype AllowedClientConfigKey =\n  | 'useCdn'\n  | 'token'\n  | 'perspective'\n  | 'apiHost'\n  | 'proxy'\n  | 'withCredentials'\n  | 'timeout'\n  | 'maxRetries'\n  | 'dataset'\n  | 'projectId'\n  | 'requestTagPrefix'\n  | 'useProjectHostname'\n\nconst allowedKeys = Object.keys({\n  apiHost: null,\n  useCdn: null,\n  token: null,\n  perspective: null,\n  proxy: null,\n  withCredentials: null,\n  timeout: null,\n  maxRetries: null,\n  dataset: null,\n  projectId: null,\n  scope: null,\n  apiVersion: null,\n  requestTagPrefix: null,\n  useProjectHostname: null,\n  resource: null,\n} satisfies Record<keyof ClientOptions, null>) as (keyof ClientOptions)[]\n\nconst DEFAULT_CLIENT_CONFIG: ClientConfig = {\n  apiVersion: DEFAULT_API_VERSION,\n  useCdn: false,\n  ignoreBrowserTokenWarning: true,\n  allowReconfigure: false,\n  requestTagPrefix: DEFAULT_REQUEST_TAG_PREFIX,\n}\n\n/**\n * States tracked by the client store\n * @public\n */\nexport interface ClientStoreState {\n  token: string | null\n  clients: {[TKey in string]?: SanityClient}\n  authMethod?: 'localstorage' | 'cookie'\n}\n\n/**\n * Options used when retrieving a client instance from the client store.\n *\n * This interface extends the base {@link ClientConfig} and adds:\n *\n * - **apiVersion:** A required string indicating the API version for the client.\n * - **scope:** An optional flag to choose between the project-specific client\n *   ('project') and the global client ('global'). When set to `'global'`, the\n *   global client is used.\n *\n * These options are utilized by `getClient` and `getClientState` to configure and\n * return appropriate client instances that automatically handle authentication\n * updates and configuration changes.\n *\n * @public\n */\nexport interface ClientOptions extends Pick<ClientConfig, AllowedClientConfigKey> {\n  /**\n   * An optional flag to choose between the default client (typically project-level)\n   * and the global client ('global'). When set to `'global'`, the global client\n   * is used.\n   */\n  scope?: 'default' | 'global'\n  /**\n   * A required string indicating the API version for the client.\n   */\n  apiVersion: string\n\n  /**\n   * @internal\n   * The SDK resource to use for the client -- this will get transformed into a ClientConfig resource.\n   */\n  resource?: DocumentResource\n}\n\nconst clientStore = defineStore<ClientStoreState>({\n  name: 'clientStore',\n\n  getInitialState: (instance) => ({\n    clients: {},\n    token: getTokenState(instance).getCurrent(),\n  }),\n\n  initialize(context) {\n    const subscription = listenToToken(context)\n    const authMethodSubscription = listenToAuthMethod(context)\n    return () => {\n      subscription.unsubscribe()\n      authMethodSubscription.unsubscribe()\n    }\n  },\n})\n\n/**\n * Updates the client store state when a token is received.\n * @internal\n */\nconst listenToToken = ({instance, state}: StoreContext<ClientStoreState>) => {\n  return getTokenState(instance).observable.subscribe((token) => {\n    state.set('setTokenAndResetClients', {token, clients: {}})\n  })\n}\n\nconst listenToAuthMethod = ({instance, state}: StoreContext<ClientStoreState>) => {\n  return getAuthMethodState(instance).observable.subscribe((authMethod) => {\n    state.set('setAuthMethod', {authMethod})\n  })\n}\n\ntype ClientInstanceCacheKeyInput = ClientConfig &\n  Partial<Pick<ClientOptions, 'scope'>> & {\n    apiVersion: string\n  }\n\nconst getClientConfigKey = (options: ClientInstanceCacheKeyInput) =>\n  JSON.stringify(pickProperties(options, allowedKeys))\n\n/**\n * Retrieves a Sanity client instance configured with the provided options.\n *\n * This function returns a client instance configured for the project or as a\n * global client based on the options provided. It ensures efficient reuse of\n * client instances by returning the same instance for the same options.\n * For automatic handling of authentication token updates, consider using\n * `getClientState`.\n *\n * @public\n */\nexport const getClient = bindActionGlobally(\n  clientStore,\n  ({state, instance}, options: ClientOptions) => {\n    if (!options || typeof options !== 'object') {\n      throw new Error(\n        'getClient() requires a configuration object with at least an \"apiVersion\" property. ' +\n          'Example: getClient(instance, { apiVersion: \"2024-11-12\" })',\n      )\n    }\n\n    // Check for disallowed keys\n    const providedKeys = Object.keys(options) as (keyof ClientOptions)[]\n    const disallowedKeys = providedKeys.filter((key) => !allowedKeys.includes(key))\n\n    if (disallowedKeys.length > 0) {\n      const listFormatter = new Intl.ListFormat('en', {style: 'long', type: 'conjunction'})\n      throw new Error(\n        `The client options provided contains unsupported properties: ${listFormatter.format(disallowedKeys)}. ` +\n          `Allowed keys are: ${listFormatter.format(allowedKeys)}.`,\n      )\n    }\n\n    const tokenFromState = state.get().token\n    const {clients, authMethod} = state.get()\n    let projectId = options.projectId ?? instance.config.projectId\n    let dataset = options.dataset ?? instance.config.dataset\n\n    let resource: ClientConfig['resource'] | undefined\n\n    if (options.resource) {\n      if (isMediaLibraryResource(options.resource)) {\n        resource = {type: 'media-library', id: options.resource.mediaLibraryId}\n      } else if (isCanvasResource(options.resource)) {\n        resource = {type: 'canvas', id: options.resource.canvasId}\n      } else if (isDatasetResource(options.resource)) {\n        // use project-based routes for datasets to avoid existing CORS and Studio auth cookie issues\n        projectId = options.resource.projectId\n        dataset = options.resource.dataset\n      }\n    }\n\n    const apiHost = options.apiHost ?? instance.config.auth?.apiHost ?? getStagingApiHost()\n\n    const effectiveOptions: ClientConfig & {apiVersion: string} = {\n      ...DEFAULT_CLIENT_CONFIG,\n      ...((options.scope === 'global' || !projectId || resource) && {useProjectHostname: false}),\n      token: authMethod === 'cookie' ? undefined : (tokenFromState ?? undefined),\n      ...options,\n      ...(projectId && {projectId}),\n      ...(dataset && {dataset}),\n      ...(resource ? {resource} : {resource: undefined}),\n      ...(apiHost && {apiHost}),\n    }\n\n    // When a resource is provided, don't use projectId/dataset - the client should be \"projectless\"\n    // The client code itself will ignore the non-resource config, so we do this to prevent confusing the user.\n    // (ref: https://github.com/sanity-io/client/blob/5c23f81f5ab93a53f5b22b39845c867988508d84/src/data/dataMethods.ts#L691)\n    if (resource) {\n      delete effectiveOptions.projectId\n      delete effectiveOptions.dataset\n    }\n\n    if (effectiveOptions.token === null || typeof effectiveOptions.token === 'undefined') {\n      delete effectiveOptions.token\n      if (authMethod === 'cookie') {\n        effectiveOptions.withCredentials = true\n      }\n    } else {\n      delete effectiveOptions.withCredentials\n    }\n\n    const key = getClientConfigKey(effectiveOptions)\n\n    if (clients[key]) return clients[key]\n\n    const client = createClient(effectiveOptions)\n    state.set('addClient', (prev) => ({clients: {...prev.clients, [key]: client}}))\n\n    return client\n  },\n)\n\n/**\n * Returns a state source for the Sanity client instance.\n *\n * This function provides a subscribable state source that emits updated client\n * instances whenever relevant configurations change (such as authentication tokens).\n * Use this when you need to react to client configuration changes in your application.\n *\n * @public\n */\nexport const getClientState = bindActionGlobally(\n  clientStore,\n  createStateSourceAction(({instance}, options: ClientOptions) => getClient(instance, options)),\n)\n"],"mappings":"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"}

package/dist/{createSanityInstance-BQIqyGLX.d.ts → createSanityInstance--Lrldto8.d.ts}

@@ -76,9 +76,12 @@ interface AuthConfig {
      */
     redirectUri: string;
     /**
-     * Organisation id used for RFC 8707 resource scoping.
+     * Organisation id used for RFC 8707 resource scoping. Optional: when
+     * omitted, the `resource` parameter is left off the authorize and token
+     * requests, so the issued tokens are not restricted to a single
+     * organisation.
      */
-    organizationId: string;
+    organizationId?: string;
   };
 }
 /**
@@ -290,4 +293,4 @@ interface SanityInstance {
  */
 declare function createSanityInstance(config?: SanityConfig): SanityInstance;
 export { isCanvasResource as _, DatasetResource as a, AuthConfig as b, DocumentTypeHandle as c, ProjectHandle as d, ReleaseHandle as f, TokenSource as g, StudioConfig as h, DatasetHandle as i, MediaLibraryResource as l, SanityConfig as m, createSanityInstance as n, DocumentHandle as o, ReleasePerspective as p, CanvasResource as r, DocumentResource as s, SanityInstance as t, PerspectiveHandle as u, isDatasetResource as v, AuthProvider as x, isMediaLibraryResource as y };
-//# sourceMappingURL=createSanityInstance-BQIqyGLX.d.ts.map
+//# sourceMappingURL=createSanityInstance--Lrldto8.d.ts.map

package/dist/createSanityInstance--Lrldto8.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSanityInstance--Lrldto8.d.ts","names":[],"sources":["../src/config/authConfig.ts","../src/config/sanityConfig.ts","../src/store/createSanityInstance.ts"],"mappings":";;;;;UAMiB;;;;EAIf;;;;EAKA;;;;EAKA;;;;EAKA;;;;;;;UAQe;;;;;EAKf;;;;;EAMA,iBAAiB,QAAQ,iBAAiB;;;;;;EAO1C,YAAY,mBAAmB,MAAM,mBAAmB,iBAAiB,QAAQ;;;;;EAMjF;;;;;EAMA,cAAc;;;;;;EAOd;;;;;;EAOA;EAEA;;;;IAIE;;;;;IAMA;;;;;;;IAQA;;;;;;;;;;;UCrFa;;EAEf,UAAU;IAAW,OAAO;;IAAkC;;;;;;;;;;UAU/C;;;;;;EAMf;;EAEA;;;;;;;;IAQE,QAAQ;;;;;;;UAQK,cAAc;EAC7B,YAAY;;;;;KAMF;EACV;EACA,uBAAuB;;;;;UAMR;EACf,cAAc,oBAAoB;;;;;UAMnB,cAAc,kCAAkC,4CACvD,cAAc,aAAa;EACnC,UAAU;;;;;;;EAOV,WAAW;;;;;;;;UASI,mBACf,uCACA,kCACA,4CACQ,cAAc,UAAU;EAChC;EACA,cAAc;;;;;;EAMd;;;;;;;;UASe,eACf,uCACA,kCACA,4CACQ,mBAAmB,eAAe,UAAU;EACpD;;;;;;;;;;UAWe,sBAAsB;EACrC;;;;;;UAOe,qBAAqB,eAAe;;;;EAInD,OAAO;;;;;;;;;EASP,SAAS;;;;;;;;KASC,mBAAmB,kBAAkB,uBAAuB;;;;KAK5D;EAAmB;EAAmB;;;;;KAKtC;EAAwB;;;;;KAKxB;EAAkB;;;;;iBAKd,kBAAkB,UAAU,mBAAmB,YAAY;;;;iBAO3D,uBACd,UAAU,mBACT,YAAY;;;;iBAOC,iBAAiB,UAAU,mBAAmB,YAAY;;;;;;UCtLzD;;;;;WAKN;;;;WAKA,QAAQ;;;;;EAMjB;;;;;EAMA;;;;;;EAOA,UAAU;;;;;;;;;iBAUI,qBAAqB,SAAQ,eAAoB"}

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import { _ as isCanvasResource, a as DatasetResource, b as AuthConfig, c as DocumentTypeHandle, d as ProjectHandle, f as ReleaseHandle, g as TokenSource, h as StudioConfig, i as DatasetHandle, l as MediaLibraryResource, m as SanityConfig, n as createSanityInstance, o as DocumentHandle, p as ReleasePerspective, r as CanvasResource, s as DocumentResource, t as SanityInstance, u as PerspectiveHandle, v as isDatasetResource, x as AuthProvider, y as isMediaLibraryResource } from "./createSanityInstance-BQIqyGLX.js";
-import { $ as Project, $n as createRelease, $r as ClientOptions, $t as FavoriteStatusResponse, A as stringifyPath, An as patchOperations, At as SanityUser, B as getPerspectiveState, Bn as DocumentAction, Br as createComment, Bt as OrganizationMember, C as SanityDocument, Ci as getTokenState, Cn as resolveDocument, Cr as createDatasetHandle, Ct as TransportEvent, D as joinPaths, Di as AccessResourceType, Dn as PermissionDeniedReason, Dr as CommentsOptions, Dt as Membership, E as getPathDepth, Ei as AuthStateType, En as DocumentPermissionsResult, Er as createProjectHandle, Et as GetUsersOptions, F as getUsersState, Fn as CreateDocumentAction, Fr as CreateCommentOptions, Ft as Organizations, Gn as PublishReleaseAction, Gr as Comment, Gt as InstallationActiveConfig, H as getActiveReleasesState, Hn as EditDocumentOptions, Hr as replyToComment, Ht as organization, I as loadMoreUsers, In as CreateReleaseAction, Ir as RemoveCommentOptions, It as OrganizationsOptions, J as resolveQuery, Jn as UnarchiveReleaseAction, Jr as CommentReaction, Jt as InstallationsOptions, K as getQueryState, Kn as ReleaseAction, Kr as CommentLocalState, Kt as InstallationBase, L as resolveUser, Ln as DeleteDocumentAction, Lr as ReplyToCommentOptions, Lt as organizations, M as isImportError, Mn as JsonMatch, Mt as UserProfile, N as getCorsErrorProjectId, Nn as Action, Nr as resolveCommentThreads, Nt as UsersGroupState, O as jsonMatch, Oi as checkPermissions, On as DocumentSet, Or as ResolveCommentsOptions, Ot as ResolveUserOptions, P as getUserState, Pn as ArchiveReleaseAction, Pr as resolveComments, Pt as UsersStoreState, Q as getProjectionState, Qn as createDocument, Qr as CommentThread, Qt as FavoriteDocumentContext, R as resolveUsers, Ri as Selector, Rn as DeleteReleaseAction, Rr as SetCommentStatusOptions, Rt as Organization, S as Role, Si as getLoginUrlState, Sn as getPermissionsState, St as StateEvent, T as getIndexForKey, Ti as OAuthTokens, Tn as subscribeDocumentEvents, Tr as createDocumentTypeHandle, Tt as GetUserOptions, U as getAllReleasesState, Un as EditReleaseAction, Ur as setCommentStatus, Ut as Installation, V as ReleaseState, Vn as EditDocumentAction, Vr as removeComment, Vt as OrganizationOptions, W as QueryOptions, Wn as PublishDocumentAction, Wr as updateComment, Wt as InstallationAccess, X as projects, Xn as UnscheduleReleaseAction, Xr as CommentTextSelection, Xt as installation, Y as ProjectsOptions, Yn as UnpublishDocumentAction, Yr as CommentStatus, Yt as InstallationsResponse, Z as resolveProjection, Zn as archiveRelease, Zr as CommentTextSelectionItem, Zt as installations, _ as applications, _i as LoggingInAuthState, _n as TransactionAcceptedEvent, _r as LogContext, _t as PresencePerspectiveOptions, a as ApplicationInclude, ai as refreshOAuthTokens, an as ApplyDocumentActionsOptions, ar as publishDocument, at as project, b as CurrentUser, bi as getDashboardOrganizationId, bn as getDocumentState, br as Logger, bt as ReportPresenceOptions, c as ApplicationStudioConfig, ci as logout, cn as DocumentCreatedEvent, cr as unarchiveRelease, ct as PreviewValue, d as ApplicationsOptions, di as OrgVerificationResult, dn as DocumentEditedEvent, dr as ResolveDocument, dt as getPresence, ei as ClientStoreState, en as SetFavoriteInput, er as deleteDocument, et as ProjectBase, f as ApplicationsResponse, fi as AuthState, fn as DocumentEvent, fr as ResolveProjectionResult, ft as reportPresence, g as application, gi as LoggedOutAuthState, gn as DocumentUnpublishedEvent, gr as InstanceContext, gt as PresenceLocation, h as UpdateApplicationInput, hi as LoggedInAuthState, hn as DocumentTransactionSubmissionResult, hr as configureLogging, ht as DocumentPresenceOptions, i as ApplicationDeployment, ii as handleOAuthCallback, in as ActionsResult, ir as editRelease, it as ProjectOptions, j as CORE_SDK_VERSION, jn as processMutations, jr as getCommentsState, jt as SanityUserResponse, k as slicePath, kn as ProcessMutationsOptions, kr as getCommentThreadsState, kt as ResolveUsersOptions, l as ApplicationVisibility, li as handleAuthCallback, ln as DocumentDeletedEvent, lr as unpublishDocument, lt as ProjectionValuePending, m as DeletedResult, mi as ErrorAuthState, mn as DocumentRemotePatchesEvent, mr as datasets, mt as DocumentPresence, n as ApplicationAccess, ni as getClientState, nn as setFavorite, nr as discardDocument, nt as ProjectMemberRole, o as ApplicationInterface, oi as revokeOAuthTokens, on as applyDocumentActions, or as publishRelease, ot as PreviewMedia, p as DeleteApplicationInput, pi as AuthStoreState, pn as DocumentPublishedEvent, pr as ResolveQueryResult, pt as DisconnectEvent, qn as ScheduleReleaseAction, qr as CommentMessage, qt as InstallationInclude, r as ApplicationBase, ri as getOAuthTokensState, rn as getReleaseDocumentId, rr as editDocument, rt as ProjectMetadata, s as ApplicationInterfacePlacementMetadata, si as startOAuthAuthorization, sn as ActionErrorEvent, sr as scheduleRelease, st as PreviewQueryResult, t as Application, ti as getClient, tn as favorites, tr as deleteRelease, tt as ProjectMember, u as ApplicationWorkspace, ui as observeOrganizationVerificationState, un as DocumentDiscardedEvent, ur as unscheduleRelease, ut as getDocumentPresence, v as deleteApplication, vi as getAuthState, vn as TransactionRevertedEvent, vr as LogLevel, vt as PresenceSelection, w as SanityProject, wi as setAuthToken, wn as resolvePermissions, wr as createDocumentHandle, wt as UserPresence, x as ReleaseDocument, xi as getIsInDashboardState, xn as getDocumentSyncStatus, xr as LoggerConfig, xt as RollCallEvent, y as updateApplication, yi as getCurrentUserState, yn as DocumentOptions, yr as LogNamespace, yt as PresenceSelectionPoint, z as defineProjection, zi as StateSource, zn as DiscardDocumentAction, zr as UpdateCommentOptions, zt as OrganizationBase } from "./applications-pRS8tuC2.js";
+import { _ as isCanvasResource, a as DatasetResource, b as AuthConfig, c as DocumentTypeHandle, d as ProjectHandle, f as ReleaseHandle, g as TokenSource, h as StudioConfig, i as DatasetHandle, l as MediaLibraryResource, m as SanityConfig, n as createSanityInstance, o as DocumentHandle, p as ReleasePerspective, r as CanvasResource, s as DocumentResource, t as SanityInstance, u as PerspectiveHandle, v as isDatasetResource, x as AuthProvider, y as isMediaLibraryResource } from "./createSanityInstance--Lrldto8.js";
+import { $ as Project, $n as createRelease, $r as ClientOptions, $t as FavoriteStatusResponse, A as stringifyPath, An as patchOperations, At as SanityUser, B as getPerspectiveState, Bn as DocumentAction, Br as createComment, Bt as OrganizationMember, C as SanityDocument, Ci as getTokenState, Cn as resolveDocument, Cr as createDatasetHandle, Ct as TransportEvent, D as joinPaths, Di as AccessResourceType, Dn as PermissionDeniedReason, Dr as CommentsOptions, Dt as Membership, E as getPathDepth, Ei as AuthStateType, En as DocumentPermissionsResult, Er as createProjectHandle, Et as GetUsersOptions, F as getUsersState, Fn as CreateDocumentAction, Fr as CreateCommentOptions, Ft as Organizations, Gn as PublishReleaseAction, Gr as Comment, Gt as InstallationActiveConfig, H as getActiveReleasesState, Hn as EditDocumentOptions, Hr as replyToComment, Ht as organization, I as loadMoreUsers, In as CreateReleaseAction, Ir as RemoveCommentOptions, It as OrganizationsOptions, J as resolveQuery, Jn as UnarchiveReleaseAction, Jr as CommentReaction, Jt as InstallationsOptions, K as getQueryState, Kn as ReleaseAction, Kr as CommentLocalState, Kt as InstallationBase, L as resolveUser, Ln as DeleteDocumentAction, Lr as ReplyToCommentOptions, Lt as organizations, M as isImportError, Mn as JsonMatch, Mt as UserProfile, N as getCorsErrorProjectId, Nn as Action, Nr as resolveCommentThreads, Nt as UsersGroupState, O as jsonMatch, Oi as checkPermissions, On as DocumentSet, Or as ResolveCommentsOptions, Ot as ResolveUserOptions, P as getUserState, Pn as ArchiveReleaseAction, Pr as resolveComments, Pt as UsersStoreState, Q as getProjectionState, Qn as createDocument, Qr as CommentThread, Qt as FavoriteDocumentContext, R as resolveUsers, Ri as Selector, Rn as DeleteReleaseAction, Rr as SetCommentStatusOptions, Rt as Organization, S as Role, Si as getLoginUrlState, Sn as getPermissionsState, St as StateEvent, T as getIndexForKey, Ti as OAuthTokens, Tn as subscribeDocumentEvents, Tr as createDocumentTypeHandle, Tt as GetUserOptions, U as getAllReleasesState, Un as EditReleaseAction, Ur as setCommentStatus, Ut as Installation, V as ReleaseState, Vn as EditDocumentAction, Vr as removeComment, Vt as OrganizationOptions, W as QueryOptions, Wn as PublishDocumentAction, Wr as updateComment, Wt as InstallationAccess, X as projects, Xn as UnscheduleReleaseAction, Xr as CommentTextSelection, Xt as installation, Y as ProjectsOptions, Yn as UnpublishDocumentAction, Yr as CommentStatus, Yt as InstallationsResponse, Z as resolveProjection, Zn as archiveRelease, Zr as CommentTextSelectionItem, Zt as installations, _ as applications, _i as LoggingInAuthState, _n as TransactionAcceptedEvent, _r as LogContext, _t as PresencePerspectiveOptions, a as ApplicationInclude, ai as refreshOAuthTokens, an as ApplyDocumentActionsOptions, ar as publishDocument, at as project, b as CurrentUser, bi as getDashboardOrganizationId, bn as getDocumentState, br as Logger, bt as ReportPresenceOptions, c as ApplicationStudioConfig, ci as logout, cn as DocumentCreatedEvent, cr as unarchiveRelease, ct as PreviewValue, d as ApplicationsOptions, di as OrgVerificationResult, dn as DocumentEditedEvent, dr as ResolveDocument, dt as getPresence, ei as ClientStoreState, en as SetFavoriteInput, er as deleteDocument, et as ProjectBase, f as ApplicationsResponse, fi as AuthState, fn as DocumentEvent, fr as ResolveProjectionResult, ft as reportPresence, g as application, gi as LoggedOutAuthState, gn as DocumentUnpublishedEvent, gr as InstanceContext, gt as PresenceLocation, h as UpdateApplicationInput, hi as LoggedInAuthState, hn as DocumentTransactionSubmissionResult, hr as configureLogging, ht as DocumentPresenceOptions, i as ApplicationDeployment, ii as handleOAuthCallback, in as ActionsResult, ir as editRelease, it as ProjectOptions, j as CORE_SDK_VERSION, jn as processMutations, jr as getCommentsState, jt as SanityUserResponse, k as slicePath, kn as ProcessMutationsOptions, kr as getCommentThreadsState, kt as ResolveUsersOptions, l as ApplicationVisibility, li as handleAuthCallback, ln as DocumentDeletedEvent, lr as unpublishDocument, lt as ProjectionValuePending, m as DeletedResult, mi as ErrorAuthState, mn as DocumentRemotePatchesEvent, mr as datasets, mt as DocumentPresence, n as ApplicationAccess, ni as getClientState, nn as setFavorite, nr as discardDocument, nt as ProjectMemberRole, o as ApplicationInterface, oi as revokeOAuthTokens, on as applyDocumentActions, or as publishRelease, ot as PreviewMedia, p as DeleteApplicationInput, pi as AuthStoreState, pn as DocumentPublishedEvent, pr as ResolveQueryResult, pt as DisconnectEvent, qn as ScheduleReleaseAction, qr as CommentMessage, qt as InstallationInclude, r as ApplicationBase, ri as getOAuthTokensState, rn as getReleaseDocumentId, rr as editDocument, rt as ProjectMetadata, s as ApplicationInterfacePlacementMetadata, si as startOAuthAuthorization, sn as ActionErrorEvent, sr as scheduleRelease, st as PreviewQueryResult, t as Application, ti as getClient, tn as favorites, tr as deleteRelease, tt as ProjectMember, u as ApplicationWorkspace, ui as observeOrganizationVerificationState, un as DocumentDiscardedEvent, ur as unscheduleRelease, ut as getDocumentPresence, v as deleteApplication, vi as getAuthState, vn as TransactionRevertedEvent, vr as LogLevel, vt as PresenceSelection, w as SanityProject, wi as setAuthToken, wn as resolvePermissions, wr as createDocumentHandle, wt as UserPresence, x as ReleaseDocument, xi as getIsInDashboardState, xn as getDocumentSyncStatus, xr as LoggerConfig, xt as RollCallEvent, y as updateApplication, yi as getCurrentUserState, yn as DocumentOptions, yr as LogNamespace, yt as PresenceSelectionPoint, z as defineProjection, zi as StateSource, zn as DiscardDocumentAction, zr as UpdateCommentOptions, zt as OrganizationBase } from "./applications-903KQTrD.js";
 export { type AccessResourceType, type Action, type ActionErrorEvent, type ActionsResult, type Application, type ApplicationAccess, type ApplicationBase, type ApplicationDeployment, type ApplicationInclude, type ApplicationInterface, type ApplicationInterfacePlacementMetadata, type ApplicationStudioConfig, type ApplicationVisibility, type ApplicationWorkspace, type ApplicationsOptions, type ApplicationsResponse, type ApplyDocumentActionsOptions, type ArchiveReleaseAction, type AuthConfig, type AuthProvider, type AuthState, AuthStateType, type AuthStoreState, CORE_SDK_VERSION, type CanvasResource, type ClientOptions, type ClientStoreState as ClientState, type Comment, type CommentLocalState, type CommentMessage, type CommentReaction, type CommentStatus, type CommentTextSelection, type CommentTextSelectionItem, type CommentThread, type CommentsOptions, type CreateCommentOptions, type CreateDocumentAction, type CreateReleaseAction, type CurrentUser, type DatasetHandle, type DatasetResource, type DeleteApplicationInput, type DeleteDocumentAction, type DeleteReleaseAction, type DeletedResult, type DiscardDocumentAction, type DisconnectEvent, type DocumentAction, type DocumentCreatedEvent, type DocumentDeletedEvent, type DocumentDiscardedEvent, type DocumentEditedEvent, type DocumentEvent, type DocumentHandle, type DocumentOptions, type DocumentPermissionsResult, type DocumentPresence, type DocumentPresenceOptions, type DocumentPublishedEvent, type DocumentRemotePatchesEvent, type DocumentResource, type DocumentSet, type DocumentTransactionSubmissionResult, type DocumentTypeHandle, type DocumentUnpublishedEvent, type EditDocumentAction, type EditDocumentOptions, type EditReleaseAction, type ErrorAuthState, type FavoriteDocumentContext, type FavoriteStatusResponse, type GetUserOptions, type GetUsersOptions, type Installation, type InstallationAccess, type InstallationActiveConfig, type InstallationBase, type InstallationInclude, type InstallationsOptions, type InstallationsResponse, type InstanceContext, type JsonMatch, type LogContext, type LogLevel, type LogNamespace, type LoggedInAuthState, type LoggedOutAuthState, type Logger, type LoggerConfig, type LoggingInAuthState, type MediaLibraryResource, type Membership, type OAuthTokens, type OrgVerificationResult, type Organization, type OrganizationBase, type OrganizationMember, type OrganizationOptions, type Organizations, type OrganizationsOptions, type PermissionDeniedReason, type PerspectiveHandle, type PresenceLocation, type PresencePerspectiveOptions, type PresenceSelection, type PresenceSelectionPoint, type PreviewMedia, type PreviewQueryResult, type PreviewValue, type ProcessMutationsOptions, type Project, type ProjectBase, type ProjectHandle, type ProjectMember, type ProjectMemberRole, type ProjectMetadata, type ProjectOptions, type ProjectionValuePending, type ProjectsOptions, type PublishDocumentAction, type PublishReleaseAction, type QueryOptions, type ReleaseAction, type ReleaseDocument, type ReleaseHandle, type ReleasePerspective, type ReleaseState, type RemoveCommentOptions, type ReplyToCommentOptions, type ReportPresenceOptions, type ResolveCommentsOptions, type ResolveDocument, type ResolveProjectionResult, type ResolveQueryResult, type ResolveUserOptions, type ResolveUsersOptions, type Role, type RollCallEvent, type SanityConfig, type SanityDocument, type SanityInstance, SanityProject, type SanityUser, type SanityUserResponse, type ScheduleReleaseAction, type Selector, type SetCommentStatusOptions, type SetFavoriteInput, type StateEvent, type StateSource, type StudioConfig, type TokenSource, type TransactionAcceptedEvent, type TransactionRevertedEvent, type TransportEvent, type UnarchiveReleaseAction, type UnpublishDocumentAction, type UnscheduleReleaseAction, type UpdateApplicationInput, type UpdateCommentOptions, type UserPresence, type UserProfile, type UsersGroupState, type UsersStoreState, application, applications, applyDocumentActions, archiveRelease, checkPermissions, configureLogging, createComment, createDatasetHandle, createDocument, createDocumentHandle, createDocumentTypeHandle, createProjectHandle, createRelease, createSanityInstance, datasets, defineProjection, deleteApplication, deleteDocument, deleteRelease, discardDocument, editDocument, editRelease, favorites, getActiveReleasesState, getAllReleasesState, getAuthState, getClient, getClientState, getCommentThreadsState, getCommentsState, getCorsErrorProjectId, getCurrentUserState, getDashboardOrganizationId, getDocumentPresence, getDocumentState, getDocumentSyncStatus, getIndexForKey, getIsInDashboardState, getLoginUrlState, getOAuthTokensState, getPathDepth, getPermissionsState, getPerspectiveState, getPresence, getProjectionState, getQueryState, getReleaseDocumentId, getTokenState, getUserState, getUsersState, handleAuthCallback, handleOAuthCallback, installation, installations, isCanvasResource, isDatasetResource, isImportError, isMediaLibraryResource, joinPaths, jsonMatch, loadMoreUsers, logout, observeOrganizationVerificationState, organization, organizations, patchOperations, processMutations, project, projects, publishDocument, publishRelease, refreshOAuthTokens, removeComment, replyToComment, reportPresence, resolveCommentThreads, resolveComments, resolveDocument, resolvePermissions, resolveProjection, resolveQuery, resolveUser, resolveUsers, revokeOAuthTokens, scheduleRelease, setAuthToken, setCommentStatus, setFavorite, slicePath, startOAuthAuthorization, stringifyPath, subscribeDocumentEvents, unarchiveRelease, unpublishDocument, unscheduleRelease, updateApplication, updateComment };