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

package/dist/queryStore-DPf9sN3V.js

@@ -0,0 +1,1346 @@
+import { a as defineStore, c as isDatasetResource, i as bindActionGlobally, n as bindActionByResource, o as isReleasePerspective, t as createStateSourceAction } from "./createStateSourceAction-BOKtqFNm.js";
+import { r as omitProperty } from "./object-CxXlSVg7.js";
+import { n as getClient, r as getClientState } from "./clientStore-BtE2-q2i.js";
+import { n as setCleanupTimeout, t as setCleanupInterval } from "./setCleanupTimeout-BiM6q1KF.js";
+import { ConnectionFailedError, CorsOriginError, DisconnectError } from "@sanity/client";
+import { BehaviorSubject, EMPTY, NEVER, Observable, Subscription, catchError, combineLatest, defer, distinctUntilChanged, filter, first, firstValueFrom, groupBy, map, mergeMap, of, pairwise, race, retry, share, startWith, switchMap, take, tap } from "rxjs";
+import "@sanity/types";
+import { DocumentId, getPublishedId } from "@sanity/id-utils";
+import { stringifyPath } from "@sanity/json-match";
+import "groq";
+import { createSelector } from "reselect";
+function insecureRandomId() {
+	return Array.from({ length: 16 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
+}
+const definitions = /* @__PURE__ */ new Map(), inflight = /* @__PURE__ */ new Map(), gcTimers = /* @__PURE__ */ new Map(), intervalTimers = /* @__PURE__ */ new Map(), snapshotCache = /* @__PURE__ */ new WeakMap(), PENDING_SNAPSHOT = {
+	status: "pending",
+	data: void 0,
+	error: void 0,
+	isFetching: !1,
+	dataUpdatedAt: void 0
+}, entryKey = (fetcherName, rawKey) => `${fetcherName}:${rawKey}`, computeTags = (def, data, params) => typeof def.tags == "function" ? def.tags(data, ...params) : def.tags ?? [], isUpdaterFn = (updater) => typeof updater == "function", applyUpdater = (updater, current) => isUpdaterFn(updater) ? updater(current) : updater, needsFetch = (entry, def) => entry.isFetching ? !1 : entry.status !== "success" || entry.forcedStale || Date.now() - (entry.dataUpdatedAt ?? 0) >= (def.staleTime ?? 3e4), asTyped = (entry) => entry, toSnapshot = (entry) => {
+	if (!entry) return PENDING_SNAPSHOT;
+	let cached = snapshotCache.get(entry);
+	if (cached) return cached;
+	let snapshot;
+	return snapshot = entry.status === "success" ? {
+		status: "success",
+		data: entry.data,
+		error: entry.error,
+		isFetching: entry.isFetching,
+		dataUpdatedAt: entry.dataUpdatedAt
+	} : entry.status === "error" ? {
+		status: "error",
+		data: void 0,
+		error: entry.error,
+		isFetching: entry.isFetching,
+		dataUpdatedAt: void 0
+	} : {
+		status: "pending",
+		data: void 0,
+		error: void 0,
+		isFetching: entry.isFetching,
+		dataUpdatedAt: void 0
+	}, snapshotCache.set(entry, snapshot), snapshot;
+}, cacheStore = defineStore({
+	name: "FetcherCache",
+	getInitialState: () => ({ entries: {} }),
+	initialize: () => () => {
+		for (let timer of gcTimers.values()) clearTimeout(timer);
+		for (let timer of intervalTimers.values()) clearInterval(timer);
+		for (let fetch of inflight.values()) fetch.sub.unsubscribe();
+		gcTimers.clear(), intervalTimers.clear(), inflight.clear();
+	}
+}), updateEntry = (state, key, actionName, updater) => {
+	state.set(actionName, (prev) => {
+		let next = updater(prev.entries[key]);
+		if (next === prev.entries[key]) return prev;
+		let entries = { ...prev.entries };
+		return next === void 0 ? delete entries[key] : entries[key] = next, { entries };
+	});
+}, baseEntry = (def, key, instance, params) => {
+	let seeded = def.initialData?.(instance, ...params);
+	return seeded ? {
+		fetcherName: def.name,
+		key,
+		params,
+		instance,
+		status: "success",
+		data: seeded.data,
+		error: void 0,
+		dataUpdatedAt: seeded.dataUpdatedAt,
+		isFetching: !1,
+		version: 0,
+		forcedStale: !1,
+		tags: computeTags(def, seeded.data, params),
+		subscriptions: 0
+	} : {
+		fetcherName: def.name,
+		key,
+		params,
+		instance,
+		status: "pending",
+		data: void 0,
+		error: void 0,
+		dataUpdatedAt: void 0,
+		isFetching: !1,
+		version: 0,
+		forcedStale: !1,
+		tags: [],
+		subscriptions: 0
+	};
+}, startFetch = (state, def, instance, params, force) => {
+	let key = entryKey(def.name, def.getKey(instance, ...params)), existing = inflight.get(key);
+	if (existing && !force) return existing.promise;
+	existing && (existing.sub.unsubscribe(), inflight.delete(key)), updateEntry(state, key, "fetchStart", (prev) => ({
+		...prev ?? baseEntry(def, key, instance, params),
+		isFetching: !0
+	}));
+	let startVersion = state.get().entries[key]?.version ?? 0, resolve, reject, promise = new Promise((res, rej) => {
+		resolve = res, reject = rej;
+	});
+	existing && promise.then(existing.resolve, existing.reject);
+	let sub = new Subscription();
+	return inflight.set(key, {
+		sub,
+		promise,
+		resolve,
+		reject,
+		startVersion
+	}), sub.add(def.fetch(instance)(...params).subscribe({
+		next: (data) => {
+			let current = state.get().entries[key];
+			if (current && current.version !== startVersion) {
+				inflight.delete(key), current.isFetching && updateEntry(state, key, "fetchDiscard", (prev) => prev && {
+					...prev,
+					isFetching: !1
+				}), resolve(current.data), sub.unsubscribe();
+				return;
+			}
+			updateEntry(state, key, "fetchSuccess", (prev) => ({
+				...prev ?? baseEntry(def, key, instance, params),
+				status: "success",
+				data,
+				error: void 0,
+				dataUpdatedAt: Date.now(),
+				isFetching: !1,
+				forcedStale: !1,
+				tags: computeTags(def, data, params)
+			})), resolve(data);
+		},
+		error: (error) => {
+			updateEntry(state, key, "fetchError", (prev) => prev && (prev.status === "success" ? {
+				...prev,
+				error,
+				isFetching: !1
+			} : {
+				...prev,
+				status: "error",
+				error,
+				isFetching: !1
+			})), inflight.delete(key), reject(error);
+		},
+		complete: () => {
+			inflight.delete(key), state.get().entries[key]?.isFetching && updateEntry(state, key, "fetchSettle", (prev) => prev && {
+				...prev,
+				isFetching: !1
+			});
+		}
+	})), promise;
+}, detach = (promise) => {
+	promise.catch(() => {});
+}, markStale = (state, key) => updateEntry(state, key, "markStale", (prev) => prev && {
+	...prev,
+	forcedStale: !0
+}), startInterval = (state, def, instance, params, key) => {
+	if (!def.refetchInterval || intervalTimers.has(key)) return;
+	let timer = setCleanupInterval(() => {
+		if (typeof document < "u" && document.hidden) return;
+		let entry = state.get().entries[key];
+		entry && entry.subscriptions > 0 && detach(startFetch(state, def, instance, params, !0));
+	}, def.refetchInterval);
+	intervalTimers.set(key, timer);
+}, scheduleGc = (state, def, key) => {
+	if (gcTimers.has(key)) return;
+	let entry = state.get().entries[key];
+	if (!entry || entry.subscriptions > 0) return;
+	let timer = setCleanupTimeout(() => {
+		gcTimers.delete(key);
+		let fetch = inflight.get(key);
+		fetch && (fetch.sub.unsubscribe(), inflight.delete(key)), updateEntry(state, key, "gc", () => void 0);
+	}, def.gcTime ?? 3e5);
+	gcTimers.set(key, timer);
+}, invalidateByTags = bindActionGlobally(cacheStore, ({ state }, targets) => {
+	let refetches = [];
+	for (let [key, entry] of Object.entries(state.get().entries)) {
+		if (!entry.tags.some((tag) => targets.some((target) => tag.type === target.type && (target.id === void 0 || tag.id === target.id))) || (markStale(state, key), entry.subscriptions <= 0)) continue;
+		let def = definitions.get(entry.fetcherName);
+		def && refetches.push(startFetch(state, def, entry.instance, entry.params, !0).catch(() => void 0));
+	}
+	return Promise.all(refetches).then(() => void 0);
+});
+/**
+* Registers a fetcher definition against the shared cache and returns its typed
+* handle.
+*
+* @internal
+*/
+function defineFetcher(definition) {
+	let def = definition;
+	definitions.set(definition.name, def);
+	let getState = bindActionGlobally(cacheStore, createStateSourceAction({
+		selector: ({ state, instance }, ...params) => {
+			let key = entryKey(def.name, def.getKey(instance, ...params)), entry = state.entries[key];
+			return toSnapshot(entry && asTyped(entry));
+		},
+		onSubscribe: ({ state, instance }, ...params) => {
+			let key = entryKey(def.name, def.getKey(instance, ...params)), pendingGc = gcTimers.get(key);
+			return pendingGc && (clearTimeout(pendingGc), gcTimers.delete(key)), updateEntry(state, key, "subscribe", (prev) => ({
+				...prev ?? baseEntry(def, key, instance, params),
+				instance,
+				subscriptions: (prev?.subscriptions ?? 0) + 1
+			})), startInterval(state, def, instance, params, key), queueMicrotask(() => {
+				let entry = state.get().entries[key];
+				entry && entry.subscriptions > 0 && needsFetch(entry, def) && detach(startFetch(state, def, instance, params, !1));
+			}), () => {
+				updateEntry(state, key, "unsubscribe", (prev) => prev && {
+					...prev,
+					subscriptions: Math.max(0, prev.subscriptions - 1)
+				});
+				let entry = state.get().entries[key];
+				if (!entry || entry.subscriptions > 0) return;
+				let interval = intervalTimers.get(key);
+				interval && (clearInterval(interval), intervalTimers.delete(key)), scheduleGc(state, def, key);
+			};
+		}
+	})), resolveState = (instance, ...params) => firstValueFrom(getState(instance, ...params).observable.pipe(filter((snapshot) => snapshot.status !== "pending"), map((snapshot) => {
+		if (snapshot.status === "error") throw snapshot.error;
+		return snapshot.data;
+	})));
+	return {
+		getState,
+		resolveState,
+		invalidate: bindActionGlobally(cacheStore, ({ state, instance }, ...params) => {
+			let key = entryKey(def.name, def.getKey(instance, ...params));
+			markStale(state, key);
+			let entry = state.get().entries[key];
+			entry && entry.subscriptions > 0 && detach(startFetch(state, def, instance, params, !0));
+		}),
+		invalidateAll: bindActionGlobally(cacheStore, ({ state }) => {
+			let prefix = `${def.name}:`;
+			for (let [key, entry] of Object.entries(state.get().entries)) key.startsWith(prefix) && (markStale(state, key), entry.subscriptions > 0 && detach(startFetch(state, def, entry.instance, entry.params, !0)));
+		}),
+		refetch: bindActionGlobally(cacheStore, ({ state, instance }, ...params) => {
+			let key = entryKey(def.name, def.getKey(instance, ...params)), promise = startFetch(state, def, instance, params, !0);
+			return scheduleGc(state, def, key), promise;
+		}),
+		setData: bindActionGlobally(cacheStore, ({ state, instance }, params, updater) => {
+			let key = entryKey(def.name, def.getKey(instance, ...params)), previous;
+			return updateEntry(state, key, "setData", (prev) => {
+				previous = prev;
+				let from = asTyped(prev ?? baseEntry(def, key, instance, params)), nextData = applyUpdater(updater, from.data);
+				return {
+					...from,
+					status: "success",
+					data: nextData,
+					dataUpdatedAt: from.dataUpdatedAt ?? Date.now(),
+					version: from.version + 1,
+					tags: computeTags(def, nextData, params)
+				};
+			}), scheduleGc(state, def, key), { undo: () => updateEntry(state, key, "undoSetData", () => previous) };
+		})
+	};
+}
+/**
+* Creates a bound mutation from its definition. The returned action resolves at
+* server settlement — not after invalidation refetches, which run as background
+* reconciliation (see {@link MutationResult.invalidated}).
+*
+* @internal
+*/
+function defineMutation(definition) {
+	return (instance, input) => {
+		let undos = [], write = (fetcher, params, updater) => {
+			undos.push(fetcher.setData(instance, params, updater).undo);
+		};
+		return definition.onMutate?.(write, input), firstValueFrom(definition.mutationFn(instance)(input)).then((result) => {
+			definition.onSuccess?.(write, result, input);
+			let targets = typeof definition.invalidates == "function" ? definition.invalidates(result, input) : definition.invalidates ?? [];
+			return {
+				data: result,
+				invalidated: targets.length ? invalidateByTags(instance, targets) : Promise.resolve()
+			};
+		}, (error) => {
+			for (let i = undos.length - 1; i >= 0; i--) undos[i]();
+			throw error;
+		});
+	};
+}
+/** Data API version used for reading and writing comments in the addon dataset. */
+const COMMENTS_API_VERSION = "v2025-05-06", ADDON_DATASET_API_VERSION = "v2025-02-19", COMMENTS_STATE_CLEAR_DELAY = 5e3, LISTEN_OPTIONS = {
+	events: [
+		"welcome",
+		"mutation",
+		"reconnect"
+	],
+	includeResult: !0,
+	includeAllVersions: !0,
+	visibility: "query",
+	tag: "comments.listen"
+}, BASE_FILTERS = ["_type == \"comment\"", "target.document._ref == $documentId"];
+/**
+* Which comments belong to a document, matching the Studio's filter.
+*
+* A release's comments are kept apart from the default ones: asking for a
+* release returns only that release's comments, and asking without one returns
+* only comments with no version at all.
+*/
+function buildCommentsFilter(documentVersionId) {
+	return [...BASE_FILTERS, documentVersionId ? "target.documentVersionId == $documentVersionId" : "!defined(target.documentVersionId)"].join(" && ");
+}
+/** The snapshot query. Newest comment first, as the Studio orders it. */
+function buildCommentsQuery(documentVersionId) {
+	return `*[${buildCommentsFilter(documentVersionId)}] {
+  _createdAt,
+  _id,
+  _rev,
+  authorId,
+  contentSnapshot,
+  context,
+  lastEditedAt,
+  message,
+  parentCommentId,
+  reactions,
+  status,
+  target,
+  threadId
+} | order(_createdAt desc)`;
+}
+/**
+* The listener query. Unprojected on purpose: mutation events carry the whole
+* comment, so there is nothing to trim.
+*/
+function buildCommentsListenQuery(documentVersionId) {
+	return `*[${buildCommentsFilter(documentVersionId)}]`;
+}
+/**
+* Comments need a project and a dataset. There is nowhere to put them for a
+* media library or a canvas, and no Studio to interoperate with either.
+*
+* @internal
+*/
+function assertDatasetResource(resource) {
+	if (!isDatasetResource(resource)) throw Error(`Comments are only supported for dataset resources, received: ${JSON.stringify(resource)}`);
+	return resource;
+}
+function isMissingOrForbidden(error) {
+	if (typeof error != "object" || !error || !("statusCode" in error)) return !1;
+	let { statusCode } = error;
+	return statusCode === 403 || statusCode === 404;
+}
+function requestAddonDataset(client, { projectId, dataset }) {
+	return client.observable.request({
+		uri: `/projects/${projectId}/datasets?datasetProfile=comments&addonFor=${dataset}`,
+		tag: "comments.addon-dataset.list"
+	}).pipe(map((datasets) => datasets?.[0]?.name));
+}
+function discover(instance, resource) {
+	return getClientState(instance, {
+		apiVersion: ADDON_DATASET_API_VERSION,
+		projectId: resource.projectId,
+		useProjectHostname: !0
+	}).observable.pipe(switchMap((client) => requestAddonDataset(client, resource).pipe(catchError((error) => isMissingOrForbidden(error) ? of(void 0) : EMPTY))));
+}
+async function discoverOnce(instance, resource) {
+	let client = await firstValueFrom(getClientState(instance, {
+		apiVersion: ADDON_DATASET_API_VERSION,
+		projectId: resource.projectId,
+		useProjectHostname: !0
+	}).observable.pipe(take(1)));
+	try {
+		return await firstValueFrom(requestAddonDataset(client, resource));
+	} catch (error) {
+		if (isMissingOrForbidden(error)) return;
+		throw error;
+	}
+}
+const addonDatasetStore = defineStore({
+	name: "CommentsAddonDataset",
+	getInitialState: () => ({ status: "unknown" }),
+	initialize: ({ instance, state, key }) => {
+		let subscription = discover(instance, assertDatasetResource(key.resource)).subscribe((datasetName) => state.set("setAddonDataset", datasetName ? {
+			status: "resolved",
+			datasetName
+		} : { status: "missing" }));
+		return () => subscription.unsubscribe();
+	}
+}), getAddonDatasetState = bindActionByResource(addonDatasetStore, createStateSourceAction(({ state }) => {
+	if (state.status !== "unknown") return state.datasetName ?? null;
+})), provisionAddonDataset = bindActionByResource(addonDatasetStore, ({ instance, state, key }) => {
+	let current = state.get();
+	if (current.datasetName) return Promise.resolve(current.datasetName);
+	if (current.provisioning) return current.provisioning;
+	let resource = assertDatasetResource(key.resource), provisioning = (async () => {
+		let existing = await discoverOnce(instance, resource);
+		if (existing) return existing;
+		let response = await getClient(instance, {
+			apiVersion: ADDON_DATASET_API_VERSION,
+			projectId: resource.projectId,
+			useProjectHostname: !0
+		}).request({
+			uri: `/comments/${resource.dataset}/setup`,
+			method: "POST",
+			tag: "comments.addon-dataset.setup"
+		});
+		if (!response?.datasetName) throw Error("Creating the comments addon dataset returned no dataset name.");
+		return response.datasetName;
+	})().then((datasetName) => (state.set("setAddonDataset", {
+		status: "resolved",
+		datasetName,
+		provisioning: void 0
+	}), datasetName)).catch((error) => {
+		throw state.set("clearProvisioning", { provisioning: void 0 }), error;
+	});
+	return state.set("startProvisioning", { provisioning }), provisioning;
+}), observeAddonDatasetClient = bindActionByResource(addonDatasetStore, ({ instance, key }) => {
+	let { projectId } = assertDatasetResource(key.resource);
+	return getAddonDatasetState(instance, { resource: key.resource }).observable.pipe(distinctUntilChanged(), filter((datasetName) => datasetName !== void 0), switchMap((datasetName) => typeof datasetName == "string" ? getClientState(instance, {
+		apiVersion: COMMENTS_API_VERSION,
+		projectId,
+		dataset: datasetName
+	}).observable : of(null)));
+}), RESERVED_SEGMENT = /\.(true|false|null)(?=$|[.[])/g, QUOTED_OR_PLAIN = /"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|[^"']+/g;
+function quoteReservedFieldSegments(path) {
+	return path.replace(QUOTED_OR_PLAIN, (chunk) => chunk.startsWith("\"") || chunk.startsWith("'") ? chunk : chunk.replace(RESERVED_SEGMENT, "[\"$1\"]"));
+}
+/**
+* Normalises a field path to the string form comments are stored in.
+*
+* Comments keep `target.path.field` as a string rather than a path array,
+* because that is what the Studio writes and reading it back has to match
+* exactly. A string given here is parsed and re-stringified, so both a path
+* array and a hand-written string come out in the same canonical form.
+*
+* `undefined` and `[]` both produce `''`. Callers writing a comment reject that
+* rather than passing it on, since a comment has to point at a field.
+*
+* @example
+* ```ts
+* toCommentFieldPath(['body', {_key: 'intro'}, 'content'])
+* // 'body[_key=="intro"].content'
+* toCommentFieldPath(undefined)
+* // ''
+* ```
+*
+* @internal
+*/
+function toCommentFieldPath(path) {
+	return quoteReservedFieldSegments(stringifyPath(path));
+}
+/**
+* Groups a flat comment list into threads.
+*
+* A thread's parent is the comment with no `parentCommentId`; replies point at
+* the parent's `id`. Replies whose parent is missing from the input are
+* dropped, which is what happens when a parent is deleted but its replies have
+* not disappeared yet.
+*
+* Threads come back in the order their parents appear in `comments`, so passing
+* the store's newest-first list gives newest-thread-first. Replies within a
+* thread are always oldest first, since that is reading order.
+*
+* @internal
+*/
+function buildCommentThreads(comments) {
+	let repliesByParent = /* @__PURE__ */ new Map();
+	for (let comment of comments) {
+		if (!comment.parentCommentId) continue;
+		let existing = repliesByParent.get(comment.parentCommentId);
+		existing ? existing.push(comment) : repliesByParent.set(comment.parentCommentId, [comment]);
+	}
+	let threads = [];
+	for (let parentComment of comments) {
+		if (parentComment.parentCommentId) continue;
+		let replies = (repliesByParent.get(parentComment.id) ?? []).sort((a, b) => a.createdAt.localeCompare(b.createdAt)), lastReply = replies[replies.length - 1];
+		threads.push({
+			threadId: parentComment.threadId,
+			fieldPath: parentComment.fieldPath,
+			parentComment,
+			replies,
+			commentsCount: replies.length + 1,
+			status: parentComment.status,
+			lastActivityAt: lastReply ? lastReply.createdAt : parentComment.createdAt
+		});
+	}
+	return threads;
+}
+/**
+* Turns a stored comment into the shape consumers see.
+*
+* This is the whole seam between the storage format and the public API. When
+* comments move to the organization-level store, the three fields that differ
+* are handled here and nothing downstream changes:
+*
+* - the author moves from `authorId` to `_system.createdBy`
+* - `target.document` becomes a global document reference, so `documentId` is
+*   parsed out of a `resourceType:resourceId:documentId` string rather than
+*   read off `_ref`
+* - `_type` goes from `comment` to `sanity.comment`, and stops being exposed
+*
+* @internal
+*/
+function normalizeComment(stored) {
+	let { target } = stored;
+	return {
+		id: stored._id,
+		createdAt: stored._createdAt,
+		...stored.authorId ? { authorId: stored.authorId } : {},
+		message: stored.message,
+		threadId: stored.threadId,
+		...stored.parentCommentId ? { parentCommentId: stored.parentCommentId } : {},
+		status: stored.status,
+		...stored.lastEditedAt ? { lastEditedAt: stored.lastEditedAt } : {},
+		documentId: target.document._ref,
+		documentType: target.documentType,
+		fieldPath: target.path?.field ?? "",
+		...target.path?.selection ? { selection: target.path.selection } : {},
+		...stored.contentSnapshot === void 0 ? {} : { contentSnapshot: stored.contentSnapshot },
+		reactions: (stored.reactions ?? []).map(({ shortName, userId, addedAt }) => ({
+			shortName,
+			userId,
+			addedAt
+		})),
+		...stored._state ? { state: stored._state } : {}
+	};
+}
+function toCommentsEvent(event) {
+	if (event.type === "mutation") {
+		if (event.transition === "disappear") return {
+			type: "disappear",
+			commentId: event.documentId
+		};
+		if (event.result) return event.transition === "appear" ? {
+			type: "appear",
+			comment: event.result
+		} : {
+			type: "update",
+			comment: event.result,
+			transactionId: event.transactionId
+		};
+	}
+}
+/**
+* Watches one document's comments: a snapshot on connect, then live changes.
+*
+* The Studio awaits its snapshot inside the event handler, which loses any
+* mutation that arrives while the fetch is in flight, because the older
+* snapshot overwrites it. Here the mutations that arrive during a fetch are
+* held and replayed straight after the snapshot, so nothing is dropped.
+*
+* A reconnect produces a fresh `welcome`, which cancels any fetch still running
+* and starts a new one. Reconnects emit nothing themselves: dropping the list
+* while reconnecting would only make readers suspend again for data we still
+* have.
+*
+* @internal
+*/
+function observeComments(options) {
+	let { client, documentId, documentVersionId } = options, params = {
+		documentId,
+		...documentVersionId ? { documentVersionId } : {}
+	}, events$ = client.observable.listen(buildCommentsListenQuery(documentVersionId), params, LISTEN_OPTIONS).pipe(share()), mutations$ = events$.pipe(map(toCommentsEvent), filter((event) => event !== void 0));
+	return events$.pipe(filter((event) => event.type === "welcome"), switchMap(() => new Observable((observer) => {
+		let buffered = [], snapshotReceived = !1, mutationSubscription = mutations$.subscribe({
+			next: (event) => {
+				snapshotReceived ? observer.next(event) : buffered.push(event);
+			},
+			error: (error) => observer.error(error)
+		}), snapshotSubscription = client.observable.fetch(buildCommentsQuery(documentVersionId), params, { tag: "comments.list" }).pipe(take(1)).subscribe({
+			next: (comments) => {
+				observer.next({
+					type: "snapshot",
+					comments
+				}), snapshotReceived = !0;
+				for (let event of buffered) observer.next(event);
+				buffered.length = 0;
+			},
+			error: (error) => {
+				observer.next({
+					type: "error",
+					error
+				}), observer.complete();
+			}
+		});
+		return () => {
+			mutationSubscription.unsubscribe(), snapshotSubscription.unsubscribe(), buffered.length = 0;
+		};
+	})));
+}
+function getCommentsKey({ documentId, documentVersionId }) {
+	return JSON.stringify([documentId, documentVersionId ?? null]);
+}
+function parseCommentsKey(key) {
+	let [documentId, documentVersionId] = JSON.parse(key);
+	return {
+		documentId,
+		...documentVersionId ? { documentVersionId } : {}
+	};
+}
+const addSubscriber$1 = (key, subscriptionId) => (prev) => {
+	let entry = prev.entries[key], subscribers = [...entry?.subscribers ?? [], subscriptionId];
+	return {
+		...prev,
+		entries: {
+			...prev.entries,
+			[key]: {
+				...entry,
+				subscribers
+			}
+		}
+	};
+}, removeSubscriber$1 = (key, subscriptionId) => (prev) => {
+	let entry = prev.entries[key];
+	if (!entry) return prev;
+	let subscribers = entry.subscribers.filter((id) => id !== subscriptionId);
+	if (!subscribers.length) {
+		let pendingCreates = { ...prev.pendingCreates }, pendingTransactions = { ...prev.pendingTransactions };
+		for (let commentId of Object.keys(entry.comments ?? {})) delete pendingCreates[commentId], delete pendingTransactions[commentId];
+		return {
+			...prev,
+			entries: omitProperty(prev.entries, key),
+			pendingCreates,
+			pendingTransactions
+		};
+	}
+	return {
+		...prev,
+		entries: {
+			...prev.entries,
+			[key]: {
+				...entry,
+				subscribers
+			}
+		}
+	};
+}, setComments = (key, comments) => (prev) => {
+	let entry = prev.entries[key];
+	if (!entry) return prev;
+	let byId = Object.fromEntries(comments.map((comment) => [comment._id, comment])), pendingCreates = { ...prev.pendingCreates };
+	for (let [commentId, localComment] of Object.entries(entry.comments ?? {})) Object.hasOwn(byId, commentId) ? delete pendingCreates[commentId] : (Object.hasOwn(pendingCreates, commentId) || localComment._state) && (byId[commentId] = localComment);
+	return {
+		...prev,
+		entries: {
+			...prev.entries,
+			[key]: {
+				...entry,
+				comments: byId,
+				error: void 0
+			}
+		},
+		pendingCreates
+	};
+}, setCommentsError = (key, error) => (prev) => {
+	let entry = prev.entries[key];
+	return entry ? {
+		...prev,
+		entries: {
+			...prev.entries,
+			[key]: {
+				...entry,
+				error
+			}
+		}
+	} : prev;
+}, receiveComment = (key, comment) => (prev) => {
+	let entry = prev.entries[key], pendingCreates = omitProperty(prev.pendingCreates, comment._id);
+	return entry ? {
+		...prev,
+		pendingCreates,
+		entries: {
+			...prev.entries,
+			[key]: {
+				...entry,
+				comments: {
+					...entry.comments,
+					[comment._id]: comment
+				}
+			}
+		}
+	} : {
+		...prev,
+		pendingCreates
+	};
+};
+/** A create that already failed once is being retried, not written fresh. */
+function isRetryingCreate(existing) {
+	let state = existing?._state?.type;
+	return state === "createError" || state === "createRetrying";
+}
+function mergeOptimisticComment(existing, comment) {
+	return {
+		...existing,
+		...comment,
+		_createdAt: comment._createdAt ?? existing?._createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+		_rev: comment._rev ?? existing?._rev ?? "",
+		...isRetryingCreate(existing) ? { _state: { type: "createRetrying" } } : {}
+	};
+}
+const addComment = (key, comment) => (prev) => {
+	let entry = prev.entries[key];
+	if (!entry) return prev;
+	let existing = entry.comments && Object.hasOwn(entry.comments, comment._id) ? entry.comments[comment._id] : void 0;
+	return {
+		...prev,
+		pendingCreates: {
+			...prev.pendingCreates,
+			[comment._id]: !0
+		},
+		entries: {
+			...prev.entries,
+			[key]: {
+				...entry,
+				comments: {
+					...entry.comments,
+					[comment._id]: mergeOptimisticComment(existing, comment)
+				}
+			}
+		}
+	};
+}, applyCommentUpdate = (commentId, patch) => (prev) => {
+	let entries = { ...prev.entries }, changed = !1;
+	for (let [key, entry] of Object.entries(prev.entries)) {
+		let comment = entry?.comments?.[commentId];
+		!entry || !comment || (changed = !0, entries[key] = {
+			...entry,
+			comments: {
+				...entry.comments,
+				[commentId]: {
+					...comment,
+					...patch
+				}
+			}
+		});
+	}
+	return changed ? {
+		...prev,
+		entries
+	} : prev;
+}, removeCommentById = (commentId) => (prev) => {
+	let entries = { ...prev.entries }, removedIds = /* @__PURE__ */ new Set(), changed = !1;
+	for (let [key, entry] of Object.entries(prev.entries)) {
+		if (!entry?.comments) continue;
+		let remaining = Object.fromEntries(Object.entries(entry.comments).filter(([id, comment]) => {
+			let keep = id !== commentId && comment.parentCommentId !== commentId;
+			return keep || removedIds.add(id), keep;
+		}));
+		Object.keys(remaining).length !== Object.keys(entry.comments).length && (changed = !0, entries[key] = {
+			...entry,
+			comments: remaining
+		});
+	}
+	if (!changed) return prev;
+	let pendingCreates = { ...prev.pendingCreates }, pendingTransactions = { ...prev.pendingTransactions };
+	for (let id of removedIds) delete pendingCreates[id], delete pendingTransactions[id];
+	return {
+		...prev,
+		entries,
+		pendingCreates,
+		pendingTransactions
+	};
+}, setPendingTransaction = (commentId, transactionId) => (prev) => ({
+	...prev,
+	pendingTransactions: {
+		...prev.pendingTransactions,
+		[commentId]: transactionId
+	}
+}), clearPendingTransaction = (commentId) => (prev) => ({
+	...prev,
+	pendingTransactions: omitProperty(prev.pendingTransactions, commentId)
+}), setCommentCreateError = (commentId, error) => (prev) => {
+	if (!Object.hasOwn(prev.pendingCreates, commentId)) return prev;
+	let next = applyCommentUpdate(commentId, { _state: {
+		type: "createError",
+		error
+	} })(prev);
+	return {
+		...next,
+		pendingCreates: omitProperty(next.pendingCreates, commentId)
+	};
+}, rollbackCommentUpdate = (commentId, transactionId, previous) => (prev) => {
+	if (!Object.hasOwn(prev.pendingTransactions, commentId) || prev.pendingTransactions[commentId] !== transactionId) return prev;
+	let entries = Object.fromEntries(Object.entries(prev.entries).map(([key, entry]) => entry?.comments?.[commentId] ? [key, {
+		...entry,
+		comments: {
+			...entry.comments,
+			[commentId]: previous
+		}
+	}] : [key, entry]));
+	return {
+		...prev,
+		entries,
+		pendingTransactions: omitProperty(prev.pendingTransactions, commentId)
+	};
+}, restoreComments = (removed) => (prev) => {
+	let entries = { ...prev.entries }, changed = !1;
+	for (let { key, comments } of removed) {
+		let entry = entries[key];
+		if (!entry) continue;
+		let missing = comments.filter((comment) => !Object.hasOwn(entry.comments ?? {}, comment._id));
+		missing.length && (changed = !0, entries[key] = {
+			...entry,
+			comments: Object.fromEntries([...Object.entries(entry.comments ?? {}), ...missing.map((comment) => [comment._id, comment])])
+		});
+	}
+	return changed ? {
+		...prev,
+		entries
+	} : prev;
+};
+/**
+* A stable string standing for one set of read options.
+*
+* Only React needs this: it holds one state source steady across renders and
+* defers swapping to a new one while the previous list is still on screen.
+* `fieldPath` is normalised on the way in, so a path array and the equivalent
+* string address the same list.
+*
+* @internal
+*/
+function getCommentsOptionsKey(options) {
+	return JSON.stringify({
+		documentId: options.documentId,
+		documentType: options.documentType,
+		projectId: options.projectId,
+		dataset: options.dataset,
+		resource: options.resource,
+		perspective: options.perspective,
+		fieldPath: options.fieldPath === void 0 ? void 0 : toCommentFieldPath(options.fieldPath),
+		status: options.status
+	});
+}
+/** @internal */
+function parseCommentsOptionsKey(key) {
+	return JSON.parse(key);
+}
+/**
+* Which comment list an option set addresses.
+*
+* Comments hang off the published id, so a draft and its published document
+* share one list. A release keeps its own.
+*/
+function toCommentsKeyParts(instance, options) {
+	let perspective = options.perspective ?? instance.config.perspective;
+	return {
+		documentId: getPublishedId(DocumentId(options.documentId)),
+		...isReleasePerspective(perspective) ? { documentVersionId: perspective.releaseName } : {}
+	};
+}
+function applyEvent(state, key, event) {
+	switch (event.type) {
+		case "snapshot":
+			state.set("setComments", setComments(key, event.comments));
+			return;
+		case "appear":
+			state.set("receiveComment", receiveComment(key, event.comment));
+			return;
+		case "disappear":
+			state.set("removeComment", removeCommentById(event.commentId));
+			return;
+		case "error":
+			state.set("setCommentsError", setCommentsError(key, event.error));
+			return;
+		case "update": {
+			let pending = state.get().pendingTransactions[event.comment._id];
+			if (pending && pending !== event.transactionId) return;
+			state.set("receiveComment", receiveComment(key, event.comment)), pending && state.set("clearPendingTransaction", clearPendingTransaction(event.comment._id));
+		}
+	}
+}
+const watchSubscribedDocuments = ({ state, instance, key }) => {
+	let client$ = observeAddonDatasetClient(instance, { resource: key.resource });
+	return state.observable.pipe(map((current) => new Set(Object.keys(current.entries))), distinctUntilChanged((a, b) => a.size === b.size && Array.from(b).every((entry) => a.has(entry))), startWith(/* @__PURE__ */ new Set()), pairwise(), mergeMap(([previous, current]) => [...Array.from(current).filter((entry) => !previous.has(entry)).map((entry) => ({
+		key: entry,
+		added: !0
+	})), ...Array.from(previous).filter((entry) => !current.has(entry)).map((entry) => ({
+		key: entry,
+		added: !1
+	}))]), groupBy((event) => event.key), mergeMap((group$) => group$.pipe(switchMap((event) => {
+		if (!event.added) return EMPTY;
+		let { documentId, documentVersionId } = parseCommentsKey(group$.key);
+		return client$.pipe(switchMap((client) => client ? observeComments({
+			client,
+			documentId,
+			documentVersionId
+		}).pipe(tap((commentsEvent) => applyEvent(state, group$.key, commentsEvent)), catchError((error) => (state.set("setCommentsError", setCommentsError(group$.key, error)), EMPTY))) : (state.set("setComments", setComments(group$.key, [])), EMPTY)));
+	})))).subscribe({ error: (error) => state.set("setError", { error }) });
+}, commentsStore = defineStore({
+	name: "Comments",
+	getInitialState: () => ({
+		entries: {},
+		pendingCreates: {},
+		pendingTransactions: {}
+	}),
+	initialize: (context) => {
+		let subscription = watchSubscribedDocuments(context);
+		return () => subscription.unsubscribe();
+	}
+}), normalizedCache = /* @__PURE__ */ new WeakMap(), filteredCache = /* @__PURE__ */ new WeakMap(), threadCache = /* @__PURE__ */ new WeakMap();
+/**
+* The stored map turned into what consumers see, newest first.
+*
+* Cached alongside the filters below rather than done per read, so the
+* normalised objects keep their identity for as long as the stored map does.
+*/
+function normalizeAll(commentsById) {
+	let cached = normalizedCache.get(commentsById);
+	if (cached) return cached;
+	let normalized = Object.values(commentsById).map(normalizeComment).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+	return normalizedCache.set(commentsById, normalized), normalized;
+}
+function filterComments(all, fieldPath, status) {
+	let byFilter = filteredCache.get(all);
+	byFilter || (byFilter = /* @__PURE__ */ new Map(), filteredCache.set(all, byFilter));
+	let cacheKey = `${fieldPath ?? "\0"}|${status ?? ""}`, cached = byFilter.get(cacheKey);
+	if (cached) return cached;
+	let filtered = all.filter((comment) => status && comment.status !== status ? !1 : fieldPath === void 0 || comment.fieldPath === fieldPath);
+	return byFilter.set(cacheKey, filtered), filtered;
+}
+function selectComments({ state, instance }, options) {
+	if (state.error) throw state.error;
+	let entry = state.entries[getCommentsKey(toCommentsKeyParts(instance, options))];
+	if (entry?.error) throw entry.error;
+	if (entry?.comments) return filterComments(normalizeAll(entry.comments), options.fieldPath === void 0 ? void 0 : toCommentFieldPath(options.fieldPath), options.status);
+}
+function selectCommentThreads(context, options) {
+	let comments = selectComments(context, {
+		...options,
+		fieldPath: void 0,
+		status: void 0
+	});
+	if (comments === void 0) return;
+	let byFilter = threadCache.get(comments);
+	byFilter || (byFilter = /* @__PURE__ */ new Map(), threadCache.set(comments, byFilter));
+	let fieldPath = options.fieldPath === void 0 ? void 0 : toCommentFieldPath(options.fieldPath), cacheKey = `${fieldPath ?? "\0"}|${options.status ?? ""}`, cached = byFilter.get(cacheKey);
+	if (cached) return cached;
+	let threads = buildCommentThreads(comments).filter((thread) => options.status && thread.parentComment.status !== options.status ? !1 : fieldPath === void 0 || thread.fieldPath === fieldPath);
+	return byFilter.set(cacheKey, threads), threads;
+}
+/**
+* Every comment on a document, newest first.
+*
+* `undefined` until the first snapshot arrives. Replies are included; use
+* {@link getCommentThreadsState} to read them grouped.
+*
+* @beta
+*/
+const getCommentsState = bindActionByResource(commentsStore, createStateSourceAction({
+	selector: selectComments,
+	onSubscribe: ({ state, instance }, options) => {
+		let key = getCommentsKey(toCommentsKeyParts(instance, options)), subscriptionId = insecureRandomId();
+		return state.set("addSubscriber", addSubscriber$1(key, subscriptionId)), () => {
+			setCleanupTimeout(() => state.set("removeSubscriber", removeSubscriber$1(key, subscriptionId)), COMMENTS_STATE_CLEAR_DELAY);
+		};
+	}
+})), getCommentThreadsState = bindActionByResource(commentsStore, createStateSourceAction({
+	selector: selectCommentThreads,
+	onSubscribe: ({ state, instance }, options) => {
+		let key = getCommentsKey(toCommentsKeyParts(instance, options)), subscriptionId = insecureRandomId();
+		return state.set("addSubscriber", addSubscriber$1(key, subscriptionId)), () => {
+			setCleanupTimeout(() => state.set("removeSubscriber", removeSubscriber$1(key, subscriptionId)), COMMENTS_STATE_CLEAR_DELAY);
+		};
+	}
+})), resolveComments = bindActionByResource(commentsStore, ({ state, instance }, { signal, ...options }) => resolveList(state, instance, options, signal, getCommentsState)), resolveCommentThreads = bindActionByResource(commentsStore, ({ state, instance }, { signal, ...options }) => resolveList(state, instance, options, signal, getCommentThreadsState));
+function resolveList(state, instance, options, signal, getState) {
+	let key = getCommentsKey(toCommentsKeyParts(instance, options)), { getCurrent } = getState(instance, options), subscriptionId = insecureRandomId();
+	state.set("addSubscriber", addSubscriber$1(key, subscriptionId));
+	let release = () => state.set("removeSubscriber", removeSubscriber$1(key, subscriptionId)), aborted$ = signal ? new Observable((observer) => {
+		let listener = () => {
+			release(), observer.error(new DOMException("The operation was aborted.", "AbortError"));
+		};
+		return signal.addEventListener("abort", listener), () => signal.removeEventListener("abort", listener);
+	}) : NEVER, resolved$ = state.observable.pipe(map(() => getCurrent()), first((value) => value !== void 0)), promise = firstValueFrom(race([resolved$, aborted$])), releaseLater = () => setCleanupTimeout(release, COMMENTS_STATE_CLEAR_DELAY);
+	return promise.then(releaseLater, releaseLater), promise;
+}
+const PROJECT_API_VERSION = "2025-07-18", USERS_STATE_CLEAR_DELAY = 5e3, getUsersKey = (instance, { resourceType, organizationId, batchSize = 100, projectId = instance.config.projectId, userId } = {}) => JSON.stringify({
+	resourceType,
+	organizationId,
+	batchSize,
+	projectId,
+	userId
+}), parseUsersKey = (key) => JSON.parse(key), addSubscription = (subscriptionId, key) => (prev) => {
+	let group = prev.users[key], subscriptions = [...group?.subscriptions ?? [], subscriptionId];
+	return {
+		...prev,
+		users: {
+			...prev.users,
+			[key]: {
+				...group,
+				subscriptions
+			}
+		}
+	};
+}, removeSubscription = (subscriptionId, key) => (prev) => {
+	let group = prev.users[key];
+	if (!group) return prev;
+	let subscriptions = group.subscriptions.filter((id) => id !== subscriptionId);
+	return subscriptions.length ? {
+		...prev,
+		users: {
+			...prev.users,
+			[key]: {
+				...group,
+				subscriptions
+			}
+		}
+	} : {
+		...prev,
+		users: omitProperty(prev.users, key)
+	};
+}, setUsersData = (key, { data, nextCursor, totalCount }) => (prev) => {
+	let group = prev.users[key];
+	if (!group) return prev;
+	let users = [...group.users ?? [], ...data];
+	return {
+		...prev,
+		users: {
+			...prev.users,
+			[key]: {
+				...group,
+				users,
+				totalCount,
+				nextCursor
+			}
+		}
+	};
+}, updateLastLoadMoreRequest = (timestamp, key) => (prev) => {
+	let group = prev.users[key];
+	return group ? {
+		...prev,
+		users: {
+			...prev.users,
+			[key]: {
+				...group,
+				lastLoadMoreRequest: timestamp
+			}
+		}
+	} : prev;
+}, setUsersError = (key, error) => (prev) => {
+	let group = prev.users[key];
+	return group ? {
+		...prev,
+		users: {
+			...prev.users,
+			[key]: {
+				...group,
+				error
+			}
+		}
+	} : prev;
+}, cancelRequest = (key) => (prev) => {
+	let group = prev.users[key];
+	return !group || group.subscriptions.length ? prev : {
+		...prev,
+		users: omitProperty(prev.users, key)
+	};
+}, initializeRequest = (key) => (prev) => prev.users[key] ? prev : {
+	...prev,
+	users: {
+		...prev.users,
+		[key]: { subscriptions: [] }
+	}
+};
+/**
+* Emits Live Content API messages for a dataset so consumers can invalidate
+* fetched data via sync tags.
+*
+* All consumers observe the same underlying EventSource connection:
+* `@sanity/client` caches the live-events stream per URL and connection
+* options, and every subscription made through this function uses the same
+* API version and request tag.
+*
+* @internal
+*/
+function observeLiveEvents(instance, { resource, onCorsError }) {
+	return getClientState(instance, {
+		apiVersion: "v2025-05-06",
+		resource
+	}).observable.pipe(switchMap((client) => defer(() => client.live.events({
+		includeDrafts: !!client.config().token,
+		tag: "live-events"
+	})).pipe(catchError((error) => {
+		if (error instanceof CorsOriginError) return onCorsError(error), EMPTY;
+		if (error instanceof DisconnectError || error instanceof ConnectionFailedError && typeof error.status == "number" && error.status >= 400 && error.status < 500) return EMPTY;
+		throw error;
+	}), retry({ delay: 1e3 }))), filter((e) => e.type === "message"));
+}
+/**
+* Emits every release document (including archived and published), refetching
+* whenever a Live Content API event matches the query's sync tags.
+*
+* This fetches directly through the client store — deliberately not via the
+* query store — because release data is itself an input to query perspective
+* resolution (`getPerspectiveState`); fetching through the query store would
+* make the two stores mutually dependent.
+*
+* @internal
+*/
+function observeReleases(instance, { resource, onCorsError }) {
+	return getClientState(instance, {
+		apiVersion: "v2025-05-06",
+		resource
+	}).observable.pipe(switchMap((client) => {
+		let syncTags$ = new BehaviorSubject(void 0);
+		return combineLatest([observeLiveEvents(instance, {
+			resource,
+			onCorsError
+		}).pipe(startWith(void 0)), syncTags$]).pipe(filter(([message, syncTags]) => message === void 0 || message.tags.some((tag) => syncTags?.includes(tag))), map(([message]) => message?.id), distinctUntilChanged()).pipe(switchMap((lastLiveEventId) => client.observable.fetch("releases::all()", {}, {
+			perspective: "raw",
+			filterResponse: !1,
+			returnQuery: !1,
+			lastLiveEventId,
+			tag: "releases"
+		})), tap((response) => {
+			syncTags$.next(response.syncTags);
+		}), map((response) => response.result));
+	}), startWith(void 0));
+}
+function sortReleases(releases = []) {
+	return [...releases].sort((a, b) => {
+		let aType = a.metadata?.releaseType, bType = b.metadata?.releaseType;
+		if (aType === "undecided" && bType !== "undecided") return -1;
+		if (aType !== "undecided" && bType === "undecided") return 1;
+		if (aType === "undecided" && bType === "undecided") return new Date(b._createdAt).getTime() - new Date(a._createdAt).getTime();
+		if (aType === "scheduled" && bType === "scheduled") {
+			let aPublishAt = a.publishAt || a.metadata?.intendedPublishAt;
+			if (!aPublishAt) return 1;
+			let bPublishAt = b.publishAt || b.metadata?.intendedPublishAt;
+			return bPublishAt ? new Date(bPublishAt).getTime() - new Date(aPublishAt).getTime() : -1;
+		}
+		return aType === "asap" && bType !== "asap" ? 1 : aType !== "asap" && bType === "asap" ? -1 : aType === "asap" && bType === "asap" ? new Date(b._createdAt).getTime() - new Date(a._createdAt).getTime() : 0;
+	});
+}
+const ARCHIVED_RELEASE_STATES = ["archived", "published"], STABLE_EMPTY_RELEASES = [], releasesStore = defineStore({
+	name: "Releases",
+	getInitialState: () => ({
+		activeReleases: void 0,
+		allReleases: void 0
+	}),
+	initialize: (context) => {
+		let subscription = subscribeToReleases(context);
+		return () => subscription.unsubscribe();
+	}
+}), _getActiveReleasesState = bindActionByResource(releasesStore, createStateSourceAction({ selector: ({ state }) => {
+	if (state.error) throw state.error;
+	return state.activeReleases;
+} })), getActiveReleasesState = (instance, options) => _getActiveReleasesState(instance, options ?? {}), _getAllReleasesState = bindActionByResource(releasesStore, createStateSourceAction({ selector: ({ state }) => {
+	if (state.error) throw state.error;
+	return state.allReleases;
+} })), getAllReleasesState = (instance, options) => _getAllReleasesState(instance, options ?? {}), subscribeToReleases = ({ instance, state, key: { resource } }) => observeReleases(instance, {
+	resource,
+	onCorsError: (error) => state.set("setError", { error })
+}).pipe(map((releases) => {
+	let sorted = sortReleases(releases ?? STABLE_EMPTY_RELEASES).reverse();
+	state.set("setReleases", {
+		allReleases: sorted,
+		activeReleases: sorted.filter((release) => !ARCHIVED_RELEASE_STATES.includes(release.state))
+	});
+})).subscribe({ error: (error) => state.set("setError", { error }) }), optionsCache = /* @__PURE__ */ new Map(), selectInstancePerspective = (context, _) => context.instance.config.perspective, selectActiveReleases = (context) => context.state.activeReleases, selectOptions = (_context, options) => options, memoizedOptionsSelector = createSelector([selectActiveReleases, selectOptions], (activeReleases, options) => {
+	if (!options || !activeReleases) return options;
+	let releaseIds = activeReleases.map((release) => release._id).join(","), nestedCache = optionsCache.get(releaseIds);
+	nestedCache || (nestedCache = /* @__PURE__ */ new Map(), optionsCache.set(releaseIds, nestedCache));
+	let optionsKey = JSON.stringify(options), cachedOptions = nestedCache.get(optionsKey);
+	return cachedOptions || (cachedOptions = options, nestedCache.set(optionsKey, cachedOptions)), cachedOptions;
+}), _getPerspectiveStateSelector = createStateSourceAction({ selector: createSelector([
+	selectInstancePerspective,
+	selectActiveReleases,
+	memoizedOptionsSelector
+], (instancePerspective, activeReleases, memoizedOptions) => {
+	let perspective = memoizedOptions?.perspective ?? instancePerspective ?? "drafts";
+	if (!isReleasePerspective(perspective)) return perspective;
+	if (!activeReleases || activeReleases.length === 0) return;
+	let releaseNames = sortReleases(activeReleases).map((release) => release.name), index = releaseNames.findIndex((name) => name === perspective.releaseName);
+	if (index < 0) throw Error(`Release "${perspective.releaseName}" not found in active releases`);
+	return ["drafts", ...releaseNames.slice(0, index + 1)].filter((name) => !perspective.excludedPerspectives?.includes(name)).reverse();
+}) }), _boundGetPerspectiveState = bindActionByResource(releasesStore, _getPerspectiveStateSelector), getPerspectiveState = (instance, ...rest) => _boundGetPerspectiveState(instance, ...rest.length ? rest : [{}]), QUERY_STATE_CLEAR_DELAY = 1e3, setQueryError = (key, error) => (prev) => {
+	let prevQuery = prev.queries[key];
+	return prevQuery ? {
+		...prev,
+		queries: {
+			...prev.queries,
+			[key]: {
+				...prevQuery,
+				error
+			}
+		}
+	} : prev;
+}, setQueryData = (key, result, syncTags) => (prev) => {
+	let prevQuery = prev.queries[key];
+	return prevQuery ? {
+		...prev,
+		queries: {
+			...prev.queries,
+			[key]: {
+				...prevQuery,
+				result: result ?? null,
+				syncTags
+			}
+		}
+	} : prev;
+}, setLastLiveEventId = (key, lastLiveEventId) => (prev) => {
+	let prevQuery = prev.queries[key];
+	return prevQuery ? {
+		...prev,
+		queries: {
+			...prev.queries,
+			[key]: {
+				...prevQuery,
+				lastLiveEventId
+			}
+		}
+	} : prev;
+}, addSubscriber = (key, subscriptionId) => (prev) => {
+	let prevQuery = prev.queries[key], subscribers = [...prevQuery?.subscribers ?? [], subscriptionId];
+	return {
+		...prev,
+		queries: {
+			...prev.queries,
+			[key]: {
+				...prevQuery,
+				subscribers
+			}
+		}
+	};
+}, removeSubscriber = (key, subscriptionId) => (prev) => {
+	let prevQuery = prev.queries[key];
+	if (!prevQuery) return prev;
+	let subscribers = prevQuery.subscribers.filter((id) => id !== subscriptionId);
+	return subscribers.length ? {
+		...prev,
+		queries: {
+			...prev.queries,
+			[key]: {
+				...prevQuery,
+				subscribers
+			}
+		}
+	} : {
+		...prev,
+		queries: omitProperty(prev.queries, key)
+	};
+}, EMPTY_ARRAY = [], getQueryKey = (instance, options) => JSON.stringify(normalizeOptionsWithPerspective(instance, options)), parseQueryKey = (key) => JSON.parse(key);
+/**
+* Ensures the query key includes an effective perspective so that
+* implicit differences (e.g. different instance.config.perspective)
+* don't collide in the dataset-scoped store.
+*
+* Since perspectives are unique, we can depend on the release stacks
+* to be correct when we retrieve the results.
+*
+*/
+function normalizeOptionsWithPerspective(instance, options) {
+	if (options.perspective !== void 0) return options;
+	let instancePerspective = instance.config.perspective;
+	return {
+		...options,
+		perspective: instancePerspective === void 0 ? "drafts" : instancePerspective
+	};
+}
+const queryStore = defineStore({
+	name: "QueryStore",
+	getInitialState: () => ({ queries: {} }),
+	initialize(context) {
+		let subscriptions = [listenForNewSubscribersAndFetch(context), listenToLiveClientAndSetLastLiveEventIds(context)];
+		return () => {
+			for (let subscription of subscriptions) subscription.unsubscribe();
+		};
+	}
+}), errorHandler = (state) => (error) => state.set("setError", { error }), listenForNewSubscribersAndFetch = ({ state, instance }) => state.observable.pipe(map((s) => new Set(Object.keys(s.queries))), distinctUntilChanged((curr, next) => curr.size === next.size && Array.from(next).every((i) => curr.has(i))), startWith(/* @__PURE__ */ new Set()), pairwise(), mergeMap(([curr, next]) => {
+	let added = Array.from(next).filter((i) => !curr.has(i)), removed = Array.from(curr).filter((i) => !next.has(i));
+	return [...added.map((key) => ({
+		key,
+		added: !0
+	})), ...removed.map((key) => ({
+		key,
+		added: !1
+	}))];
+}), groupBy((i) => i.key), mergeMap((group$) => group$.pipe(switchMap((e) => {
+	if (!e.added) return EMPTY;
+	let lastLiveEventId$ = state.observable.pipe(map((s) => s.queries[group$.key]?.lastLiveEventId), distinctUntilChanged()), { query, params, projectId, dataset, tag, resource, perspective: perspectiveFromOptions, ...restOptions } = parseQueryKey(group$.key), perspective$ = isReleasePerspective(perspectiveFromOptions) ? getPerspectiveState(instance, {
+		perspective: perspectiveFromOptions,
+		resource
+	}).observable.pipe(filter(Boolean)) : of(perspectiveFromOptions ?? "drafts"), client$ = getClientState(instance, {
+		apiVersion: "v2025-05-06",
+		projectId,
+		dataset,
+		resource
+	}).observable;
+	return combineLatest({
+		lastLiveEventId: lastLiveEventId$,
+		client: client$,
+		perspective: perspective$
+	}).pipe(switchMap(({ lastLiveEventId, client, perspective }) => client.observable.fetch(query, params, {
+		...restOptions,
+		perspective,
+		filterResponse: !1,
+		returnQuery: !1,
+		lastLiveEventId,
+		tag
+	})), tap(({ result, syncTags }) => {
+		state.set("setQueryData", setQueryData(group$.key, result, syncTags));
+	}), catchError((error) => (state.set("setQueryError", setQueryError(group$.key, error)), EMPTY)));
+})))).subscribe({ error: errorHandler(state) }), listenToLiveClientAndSetLastLiveEventIds = ({ state, instance, key: { resource } }) => {
+	let liveMessages$ = observeLiveEvents(instance, {
+		resource,
+		onCorsError: (error) => state.set("setError", { error })
+	}).pipe(share());
+	return state.observable.pipe(mergeMap((s) => Object.entries(s.queries)), groupBy(([key]) => key), mergeMap((group$) => {
+		let syncTags$ = group$.pipe(map(([, queryState]) => queryState), map((i) => i?.syncTags ?? EMPTY_ARRAY), distinctUntilChanged());
+		return combineLatest([liveMessages$, syncTags$]).pipe(filter(([message, syncTags]) => message.tags.some((tag) => syncTags.includes(tag))), tap(([message]) => {
+			state.set("setLastLiveEventId", setLastLiveEventId(group$.key, message.id));
+		}));
+	})).subscribe({ error: errorHandler(state) });
+};
+/** @beta */
+function getQueryState(...args) {
+	return _getQueryState(...args);
+}
+const _getQueryState = bindActionByResource(queryStore, createStateSourceAction({
+	selector: ({ state, instance }, options) => {
+		if (state.error) throw state.error;
+		let key = getQueryKey(instance, options), queryState = state.queries[key];
+		if (queryState?.error) throw queryState.error;
+		return queryState?.result;
+	},
+	onSubscribe: ({ state, instance }, options) => {
+		let subscriptionId = insecureRandomId(), key = getQueryKey(instance, options);
+		return state.set("addSubscriber", addSubscriber(key, subscriptionId)), () => {
+			setCleanupTimeout(() => state.set("removeSubscriber", removeSubscriber(key, subscriptionId)), QUERY_STATE_CLEAR_DELAY);
+		};
+	}
+}));
+/** @beta */
+function resolveQuery(...args) {
+	return _resolveQuery(...args);
+}
+const _resolveQuery = bindActionByResource(queryStore, ({ state, instance }, { signal, ...options }) => {
+	let normalized = normalizeOptionsWithPerspective(instance, options), { getCurrent } = getQueryState(instance, normalized), key = getQueryKey(instance, normalized), subscriptionId = insecureRandomId();
+	state.set("addSubscriber", addSubscriber(key, subscriptionId));
+	let aborted$ = signal ? new Observable((observer) => {
+		let cleanup = () => {
+			signal.removeEventListener("abort", listener);
+		}, listener = () => {
+			observer.error(new DOMException("The operation was aborted.", "AbortError")), observer.complete(), cleanup();
+		};
+		return signal.addEventListener("abort", listener), cleanup;
+	}).pipe(catchError((error) => {
+		throw error instanceof Error && error.name === "AbortError" && state.set("removeSubscriber", removeSubscriber(key, subscriptionId)), error;
+	})) : NEVER, resolved$ = state.observable.pipe(map(getCurrent), first((i) => i !== void 0)), promise = firstValueFrom(race([resolved$, aborted$])), releaseSubscriber = () => {
+		setCleanupTimeout(() => {
+			state.set("removeSubscriber", removeSubscriber(key, subscriptionId));
+		}, QUERY_STATE_CLEAR_DELAY);
+	};
+	return promise.then(releaseSubscriber, releaseSubscriber), promise;
+});
+export { getCommentsKey as A, getAddonDatasetState as B, parseCommentsOptionsKey as C, addComment as D, toCommentsKeyParts as E, setCommentCreateError as F, insecureRandomId as G, COMMENTS_API_VERSION as H, setPendingTransaction as I, normalizeComment as L, removeCommentById as M, restoreComments as N, applyCommentUpdate as O, rollbackCommentUpdate as P, toCommentFieldPath as R, getCommentsState as S, resolveComments as T, defineFetcher as U, provisionAddonDataset as V, defineMutation as W, PROJECT_API_VERSION as _, getPerspectiveState as a, getCommentThreadsState as b, addSubscription as c, initializeRequest as d, parseUsersKey as f, updateLastLoadMoreRequest as g, setUsersError as h, resolveQuery as i, receiveComment as j, clearPendingTransaction as k, cancelRequest as l, setUsersData as m, getQueryState as n, getActiveReleasesState as o, removeSubscription as p, parseQueryKey as r, getAllReleasesState as s, getQueryKey as t, getUsersKey as u, USERS_STATE_CLEAR_DELAY as v, resolveCommentThreads as w, getCommentsOptionsKey as x, commentsStore as y, assertDatasetResource as z };
+
+//# sourceMappingURL=queryStore-DPf9sN3V.js.map