@sanity/sdk 2.19.0 → 2.20.0

package/dist/createGroqSearchFilter-B0NdA-EP.js

@@ -0,0 +1,1222 @@
+import { A as defineStore, D as bindActionByResource, E as createStateSourceAction, P as isDatasetResource, j as isReleasePerspective } from "./authStore-CWTAuieY.js";
+import { a as isObject, n as getClient, o as omitProperty, r as getClientState } from "./clientStore-CMzJ7XhZ.js";
+import { ConnectionFailedError, CorsOriginError, DisconnectError } from "@sanity/client";
+import { BehaviorSubject, EMPTY, NEVER, Observable, 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 { createSelector } from "reselect";
+import { DocumentId, getPublishedId } from "@sanity/id-utils";
+import { stringifyPath } from "@sanity/json-match";
+import "groq";
+import { createImageUrlBuilder } from "@sanity/image-url";
+function insecureRandomId() {
+	return Array.from({ length: 16 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
+}
+/**
+* Like `setTimeout`, but calls `.unref()` on the timer when running in Node.js.
+*
+* In Node.js, active timers prevent the process from exiting. Cleanup timers
+* (e.g. deferred subscription removal) should not keep the process alive -
+* `.unref()` lets the process exit naturally while still firing the timer if
+* the process happens to still be running.
+*
+* In browsers, `setTimeout` returns a number and has no `.unref()` method,
+* so this is a no-op there.
+*/
+function setCleanupTimeout(fn, delay) {
+	let timer = setTimeout(fn, delay), t = timer;
+	return typeof t == "object" && t && "unref" in t && typeof t.unref == "function" && t.unref(), timer;
+}
+/** 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 = (options) => JSON.stringify(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(normalizeOptionsWithPerspective(instance, options)), queryState = state.queries[key];
+		if (queryState?.error) throw queryState.error;
+		return queryState?.result;
+	},
+	onSubscribe: ({ state, instance }, options) => {
+		let subscriptionId = insecureRandomId(), key = getQueryKey(normalizeOptionsWithPerspective(instance, options));
+		return state.set("addSubscriber", addSubscriber(key, subscriptionId)), () => {
+			setCleanupTimeout(() => state.set("removeSubscriber", removeSubscriber(key, subscriptionId)), QUERY_STATE_CLEAR_DELAY);
+		};
+	}
+}));
+/** @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(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;
+}), TITLE_CANDIDATES = [
+	"title",
+	"name",
+	"label",
+	"heading",
+	"header",
+	"caption"
+], SUBTITLE_CANDIDATES = [
+	"description",
+	"subtitle",
+	...TITLE_CANDIDATES
+], PREVIEW_PROJECTION = `{
+  // Get all potential title fields
+  "titleCandidates": {
+    ${TITLE_CANDIDATES.map((field) => `"${field}": ${field}`).join(",\n      ")}
+  },
+  // Get all potential subtitle fields
+  "subtitleCandidates": {
+    ${SUBTITLE_CANDIDATES.map((field) => `"${field}": ${field}`).join(",\n      ")}
+  },
+  "media": coalesce(
+    select(
+      defined(asset) => {"type": "image-asset", "_ref": asset._ref},
+      defined(image.asset) => {"type": "image-asset", "_ref": image.asset._ref},
+      defined(mainImage.asset) => {"type": "image-asset", "_ref": mainImage.asset._ref},
+      null
+    )
+  ),
+  _type,
+  _id,
+  _updatedAt
+}`;
+/**
+* Checks if the provided value has `_ref` property that is a string and starts with `image-`
+*/
+function hasImageRef(value) {
+	return isObject(value) && "_ref" in value && typeof value._ref == "string";
+}
+/**
+* Normalizes a media asset to a preview value.
+* Adds a url to a media asset reference using `@sanity/image-url`.
+*
+* @internal
+*/
+function normalizeMedia(media, client) {
+	if (!media || !hasImageRef(media)) return null;
+	let url = createImageUrlBuilder(client).image({ _ref: media._ref }).url();
+	return {
+		type: "image-asset",
+		_ref: media._ref,
+		url
+	};
+}
+/**
+* Finds a single field value from a set of candidates based on a priority list of field names.
+* Returns the first non-empty string value found from the candidates matching the priority list order.
+*
+* @internal
+*/
+function findFirstDefined(fieldsToSearch, candidates, exclude) {
+	if (candidates) for (let field of fieldsToSearch) {
+		let value = candidates[field];
+		if (typeof value == "string" && value.trim() !== "" && value !== exclude) return value;
+	}
+}
+/**
+* Transforms a projection result (with titleCandidates, subtitleCandidates, media)
+* into a PreviewValue (with title, subtitle, media).
+*
+* @param projectionResult - The raw projection result from GROQ
+* @param instance - The Sanity instance to use for client configuration
+* @param resource - Data resource for the preview
+* @internal
+*/
+function transformProjectionToPreview(instance, projectionResult, resource) {
+	let title = findFirstDefined(TITLE_CANDIDATES, projectionResult.titleCandidates), subtitle = findFirstDefined(SUBTITLE_CANDIDATES, projectionResult.subtitleCandidates, title), client = getClient(instance, {
+		apiVersion: "v2025-05-06",
+		resource
+	});
+	return {
+		title: String(title || `${projectionResult._type}: ${projectionResult._id}`),
+		subtitle: subtitle || void 0,
+		media: normalizeMedia(projectionResult.media, client),
+		...projectionResult._status && { _status: projectionResult._status }
+	};
+}
+const TOKEN_REGEX = /(?:[^\s"]+|"[^"]*")+/g;
+/**
+* @internal
+* Checks if a token starts with the negation character.
+*/
+function isNegationToken(token) {
+	return token !== void 0 && token.trim().startsWith("-");
+}
+/**
+* @internal
+* Checks if a token ends with the wildcard character.
+*/
+function isPrefixToken(token) {
+	return token !== void 0 && token.trim().endsWith("*");
+}
+/**
+* @internal
+* Checks if a token is enclosed in double quotes.
+*/
+function isExactMatchToken(token) {
+	return !!token && token.length >= 2 && token.startsWith("\"") && token.endsWith("\"");
+}
+/**
+* Creates a GROQ search filter string (`[@] match text::query("...")`)
+* from a raw search query string.
+*
+* It applies wildcard ('*') logic to the last eligible token and escapes
+* double quotes within the search term.
+*
+* If the input query is empty or only whitespace, it returns an empty string.
+*
+* @param query - The raw input search string.
+* @returns The GROQ search filter string, or an empty string.
+* @internal
+*/
+function createGroqSearchFilter(query) {
+	let trimmedQuery = query.trim();
+	if (!trimmedQuery) return "";
+	let tokens = trimmedQuery.match(TOKEN_REGEX) ?? [], reversedIndex = [...tokens].reverse().findIndex((token) => !isNegationToken(token) && !isExactMatchToken(token)), finalIncrementalTokenIndex = reversedIndex === -1 ? -1 : tokens.length - 1 - reversedIndex, finalIncrementalToken = tokens[finalIncrementalTokenIndex], processedTokens = [...tokens];
+	return finalIncrementalToken !== void 0 && !isPrefixToken(finalIncrementalToken) && processedTokens.splice(finalIncrementalTokenIndex, 1, `${finalIncrementalToken}*`), `[@] match text::query("${processedTokens.join(" ").replace(/"/g, "\\\"")}")`;
+}
+export { addComment as A, normalizeComment as B, getCommentThreadsState as C, resolveCommentThreads as D, parseCommentsOptionsKey as E, removeCommentById as F, COMMENTS_API_VERSION as G, assertDatasetResource as H, restoreComments as I, setCleanupTimeout as K, rollbackCommentUpdate as L, clearPendingTransaction as M, getCommentsKey as N, resolveComments as O, receiveComment as P, setCommentCreateError as R, commentsStore as S, getCommentsState as T, getAddonDatasetState as U, toCommentFieldPath as V, provisionAddonDataset as W, setUsersData as _, getQueryState as a, PROJECT_API_VERSION as b, getPerspectiveState as c, addSubscription as d, cancelRequest as f, removeSubscription as g, parseUsersKey as h, getQueryKey as i, applyCommentUpdate as j, toCommentsKeyParts as k, getActiveReleasesState as l, initializeRequest as m, transformProjectionToPreview as n, parseQueryKey as o, getUsersKey as p, insecureRandomId as q, PREVIEW_PROJECTION as r, resolveQuery as s, createGroqSearchFilter as t, getAllReleasesState as u, setUsersError as v, getCommentsOptionsKey as w, USERS_STATE_CLEAR_DELAY as x, updateLastLoadMoreRequest as y, setPendingTransaction as z };
+
+//# sourceMappingURL=createGroqSearchFilter-B0NdA-EP.js.map