@sanity/sdk 3.1.0 → 3.3.0-rc.0

package/dist/object-CxXlSVg7.js

@@ -0,0 +1,83 @@
+/**
+* Returns true when the input is a non-null object.
+*
+* @internal
+*/
+function isObject(value) {
+	return typeof value == "object" && !!value;
+}
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key), isPlainObject = (value) => {
+	if (!isObject(value)) return !1;
+	let prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+/**
+* Creates a shallow copy without the provided property.
+*
+* @internal
+*/
+function omitProperty(value, key) {
+	if (!value) return {};
+	let { [key]: _omitted, ...rest } = value;
+	return rest;
+}
+/**
+* Creates a shallow copy containing only the provided properties.
+*
+* @internal
+*/
+function pickProperties(value, keys) {
+	let result = {};
+	for (let key of keys) hasOwn(value, key) && (result[key] = value[key]);
+	return result;
+}
+const areSetsEqual = (left, right) => {
+	if (left.size !== right.size) return !1;
+	let unmatched = [...right];
+	outer: for (let leftValue of left) {
+		for (let index = 0; index < unmatched.length; index++) if (isDeepEqual(leftValue, unmatched[index])) {
+			unmatched.splice(index, 1);
+			continue outer;
+		}
+		return !1;
+	}
+	return unmatched.length === 0;
+}, areMapsEqual = (left, right) => {
+	if (left.size !== right.size) return !1;
+	let unmatched = [...right.entries()];
+	outer: for (let [leftKey, leftValue] of left) {
+		for (let index = 0; index < unmatched.length; index++) {
+			let [rightKey, rightValue] = unmatched[index];
+			if (isDeepEqual(leftKey, rightKey) && isDeepEqual(leftValue, rightValue)) {
+				unmatched.splice(index, 1);
+				continue outer;
+			}
+		}
+		return !1;
+	}
+	return unmatched.length === 0;
+};
+/**
+* Compares values deeply across the plain object, array, map, and set shapes used by the SDK.
+* This helper is intended for acyclic SDK data structures and does not guard against circular
+* references.
+*
+* @internal
+*/
+function isDeepEqual(left, right) {
+	if (Object.is(left, right)) return !0;
+	if (!isObject(left) || !isObject(right)) return !1;
+	if (left instanceof Date && right instanceof Date) return left.getTime() === right.getTime();
+	if (left instanceof RegExp && right instanceof RegExp) return left.source === right.source && left.flags === right.flags;
+	if (left instanceof Set && right instanceof Set) return areSetsEqual(left, right);
+	if (left instanceof Map && right instanceof Map) return areMapsEqual(left, right);
+	if (Array.isArray(left) || Array.isArray(right)) return !Array.isArray(left) || !Array.isArray(right) || left.length !== right.length ? !1 : left.every((value, index) => isDeepEqual(value, right[index]));
+	if (!isPlainObject(left) || !isPlainObject(right)) return !1;
+	let leftKeys = Object.keys(left), rightKeys = Object.keys(right);
+	if (leftKeys.length !== rightKeys.length) return !1;
+	for (let key of leftKeys) if (!hasOwn(right, key) || !isDeepEqual(left[key], right[key])) return !1;
+	return !0;
+}
+export { pickProperties as i, isObject as n, omitProperty as r, isDeepEqual as t };
+
+//# sourceMappingURL=object-CxXlSVg7.js.map

package/dist/object-CxXlSVg7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-CxXlSVg7.js","names":[],"sources":["../src/utils/object.ts"],"sourcesContent":["/**\n * Returns true when the input is a non-null object.\n *\n * @internal\n */\nexport function isObject(value: unknown): value is object {\n  return typeof value === 'object' && value !== null\n}\n\nconst hasOwn = (value: object, key: PropertyKey) => Object.prototype.hasOwnProperty.call(value, key)\n\nconst isPlainObject = (value: unknown): value is Record<string, unknown> => {\n  if (!isObject(value)) return false\n\n  const prototype = Object.getPrototypeOf(value)\n  return prototype === Object.prototype || prototype === null\n}\n\n/**\n * Creates a shallow copy without the provided property.\n *\n * @internal\n */\nexport function omitProperty<T extends object, K extends keyof T>(\n  value: T | null | undefined,\n  key: K,\n): Omit<T, K> {\n  if (!value) return {} as Omit<T, K>\n\n  const {[key]: _omitted, ...rest} = value\n  return rest\n}\n\n/**\n * Creates a shallow copy containing only the provided properties.\n *\n * @internal\n */\nexport function pickProperties<T extends object, K extends keyof T>(\n  value: T,\n  keys: readonly K[],\n): Pick<T, K> {\n  const result = {} as Pick<T, K>\n\n  for (const key of keys) {\n    if (hasOwn(value, key)) {\n      result[key] = value[key]\n    }\n  }\n\n  return result\n}\n\nconst areSetsEqual = (left: Set<unknown>, right: Set<unknown>): boolean => {\n  if (left.size !== right.size) return false\n\n  const unmatched = [...right]\n\n  outer: for (const leftValue of left) {\n    for (let index = 0; index < unmatched.length; index++) {\n      if (isDeepEqual(leftValue, unmatched[index])) {\n        unmatched.splice(index, 1)\n        continue outer\n      }\n    }\n\n    return false\n  }\n\n  return unmatched.length === 0\n}\n\nconst areMapsEqual = (left: Map<unknown, unknown>, right: Map<unknown, unknown>): boolean => {\n  if (left.size !== right.size) return false\n\n  const unmatched = [...right.entries()]\n\n  outer: for (const [leftKey, leftValue] of left) {\n    for (let index = 0; index < unmatched.length; index++) {\n      const [rightKey, rightValue] = unmatched[index]\n\n      if (isDeepEqual(leftKey, rightKey) && isDeepEqual(leftValue, rightValue)) {\n        unmatched.splice(index, 1)\n        continue outer\n      }\n    }\n\n    return false\n  }\n\n  return unmatched.length === 0\n}\n\n/**\n * Compares values deeply across the plain object, array, map, and set shapes used by the SDK.\n * This helper is intended for acyclic SDK data structures and does not guard against circular\n * references.\n *\n * @internal\n */\nexport function isDeepEqual<T>(left: T, right: T): boolean {\n  if (Object.is(left, right)) return true\n\n  if (!isObject(left) || !isObject(right)) return false\n\n  if (left instanceof Date && right instanceof Date) {\n    return left.getTime() === right.getTime()\n  }\n\n  if (left instanceof RegExp && right instanceof RegExp) {\n    return left.source === right.source && left.flags === right.flags\n  }\n\n  if (left instanceof Set && right instanceof Set) {\n    return areSetsEqual(left, right)\n  }\n\n  if (left instanceof Map && right instanceof Map) {\n    return areMapsEqual(left, right)\n  }\n\n  if (Array.isArray(left) || Array.isArray(right)) {\n    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false\n\n    return left.every((value, index) => isDeepEqual(value, right[index]))\n  }\n\n  if (!isPlainObject(left) || !isPlainObject(right)) return false\n\n  const leftKeys = Object.keys(left)\n  const rightKeys = Object.keys(right)\n\n  if (leftKeys.length !== rightKeys.length) return false\n\n  for (const key of leftKeys) {\n    if (!hasOwn(right, key) || !isDeepEqual(left[key], right[key])) {\n      return false\n    }\n  }\n\n  return true\n}\n"],"mappings":";;;;;AAKA,SAAgB,SAAS,OAAiC;CACxD,OAAO,OAAO,SAAU,cAAY;AACtC;AAEA,MAAM,UAAU,OAAe,QAAqB,OAAO,UAAU,eAAe,KAAK,OAAO,GAAG,GAE7F,iBAAiB,UAAqD;CAC1E,IAAI,CAAC,SAAS,KAAK,GAAG,OAAO;CAE7B,IAAM,YAAY,OAAO,eAAe,KAAK;CAC7C,OAAO,cAAc,OAAO,aAAa,cAAc;AACzD;;;;;;AAOA,SAAgB,aACd,OACA,KACY;CACZ,IAAI,CAAC,OAAO,OAAO,CAAC;CAEpB,IAAM,GAAE,MAAM,UAAU,GAAG,SAAQ;CACnC,OAAO;AACT;;;;;;AAOA,SAAgB,eACd,OACA,MACY;CACZ,IAAM,SAAS,CAAC;CAEhB,KAAK,IAAM,OAAO,MAChB,AAAI,OAAO,OAAO,GAAG,MACnB,OAAO,OAAO,MAAM;CAIxB,OAAO;AACT;AAEA,MAAM,gBAAgB,MAAoB,UAAiC;CACzE,IAAI,KAAK,SAAS,MAAM,MAAM,OAAO;CAErC,IAAM,YAAY,CAAC,GAAG,KAAK;CAE3B,OAAO,KAAK,IAAM,aAAa,MAAM;EACnC,KAAK,IAAI,QAAQ,GAAG,QAAQ,UAAU,QAAQ,SAC5C,IAAI,YAAY,WAAW,UAAU,MAAM,GAAG;GAC5C,UAAU,OAAO,OAAO,CAAC;GACzB,SAAS;EACX;EAGF,OAAO;CACT;CAEA,OAAO,UAAU,WAAW;AAC9B,GAEM,gBAAgB,MAA6B,UAA0C;CAC3F,IAAI,KAAK,SAAS,MAAM,MAAM,OAAO;CAErC,IAAM,YAAY,CAAC,GAAG,MAAM,QAAQ,CAAC;CAErC,OAAO,KAAK,IAAM,CAAC,SAAS,cAAc,MAAM;EAC9C,KAAK,IAAI,QAAQ,GAAG,QAAQ,UAAU,QAAQ,SAAS;GACrD,IAAM,CAAC,UAAU,cAAc,UAAU;GAEzC,IAAI,YAAY,SAAS,QAAQ,KAAK,YAAY,WAAW,UAAU,GAAG;IACxE,UAAU,OAAO,OAAO,CAAC;IACzB,SAAS;GACX;EACF;EAEA,OAAO;CACT;CAEA,OAAO,UAAU,WAAW;AAC9B;;;;;;;;AASA,SAAgB,YAAe,MAAS,OAAmB;CACzD,IAAI,OAAO,GAAG,MAAM,KAAK,GAAG,OAAO;CAEnC,IAAI,CAAC,SAAS,IAAI,KAAK,CAAC,SAAS,KAAK,GAAG,OAAO;CAEhD,IAAI,gBAAgB,QAAQ,iBAAiB,MAC3C,OAAO,KAAK,QAAQ,MAAM,MAAM,QAAQ;CAG1C,IAAI,gBAAgB,UAAU,iBAAiB,QAC7C,OAAO,KAAK,WAAW,MAAM,UAAU,KAAK,UAAU,MAAM;CAG9D,IAAI,gBAAgB,OAAO,iBAAiB,KAC1C,OAAO,aAAa,MAAM,KAAK;CAGjC,IAAI,gBAAgB,OAAO,iBAAiB,KAC1C,OAAO,aAAa,MAAM,KAAK;CAGjC,IAAI,MAAM,QAAQ,IAAI,KAAK,MAAM,QAAQ,KAAK,GAG5C,OAFI,CAAC,MAAM,QAAQ,IAAI,KAAK,CAAC,MAAM,QAAQ,KAAK,KAAK,KAAK,WAAW,MAAM,SAAe,KAEnF,KAAK,OAAO,OAAO,UAAU,YAAY,OAAO,MAAM,MAAM,CAAC;CAGtE,IAAI,CAAC,cAAc,IAAI,KAAK,CAAC,cAAc,KAAK,GAAG,OAAO;CAE1D,IAAM,WAAW,OAAO,KAAK,IAAI,GAC3B,YAAY,OAAO,KAAK,KAAK;CAEnC,IAAI,SAAS,WAAW,UAAU,QAAQ,OAAO;CAEjD,KAAK,IAAM,OAAO,UAChB,IAAI,CAAC,OAAO,OAAO,GAAG,KAAK,CAAC,YAAY,KAAK,MAAM,MAAM,IAAI,GAC3D,OAAO;CAIX,OAAO;AACT"}

package/dist/topicStore-Ct7IFNtY.js

@@ -0,0 +1,565 @@
+import { a as createActionBinder, o as defineStore, t as createStateSourceAction } from "./createStateSourceAction-DdAhEfnZ.js";
+import { n as setCleanupTimeout } from "./setCleanupTimeout-BiM6q1KF.js";
+import { t as _defineProperty } from "./defineProperty-Bho9Ngsi.js";
+import { BehaviorSubject, ReplaySubject, Subject, concat, defer, filter, firstValueFrom, from, map, takeUntil } from "rxjs";
+import "@sanity/types";
+const stateTopic = (seed) => ({
+	kind: "state",
+	seed
+}), dashboardEvent = {
+	kind: "event",
+	ownership: { type: "same_app" }
+}, DASHBOARD_TOPIC_MANIFEST = {
+	"applications.config": stateTopic(void 0),
+	"applications.foreground": stateTopic(void 0),
+	"applications.list": stateTopic(void 0),
+	"auth.token": stateTopic(void 0),
+	"auth.token.refresh": dashboardEvent,
+	"navigation.location": stateTopic(void 0),
+	"navigation.location.update": dashboardEvent,
+	"organizations.current": stateTopic(void 0),
+	"panels.mode": stateTopic({
+		ok: !0,
+		value: null
+	}),
+	"panels.mode.set": dashboardEvent,
+	"preferences.color-scheme": stateTopic(void 0),
+	"preferences.dock-locked": stateTopic(void 0),
+	"users.current": stateTopic(void 0)
+}, topicMigrations = {};
+/**
+* An error raised by the message bus protocol.
+* @public
+*/
+var MessageBusError = class extends Error {
+	/** Creates a message bus protocol error. */
+	constructor(code, message, options) {
+		super(message ?? code, options), _defineProperty(this, "code", void 0), this.name = "MessageBusError", this.code = code;
+	}
+};
+const MESSAGE_BUS_KEY = Symbol.for("sanity.os.bus"), MESSAGE_BUS_PROTOCOL_KEY = Symbol.for("sanity.os.protocol"), MESSAGE_BUS_REGISTRY_KEY = Symbol.for("sanity.os.registry"), MESSAGE_BUS_PENDING_REPLY_KEY = Symbol.for("sanity.os.request"), DEFAULT_TIMEOUT_MS = 5e3, NO_VALUE = Symbol.for("sanity.os.no-value");
+function resolveStateSubject(registry, connection, type) {
+	if (connection.abort.signal.aborted) throw new MessageBusError("ABORTED");
+	let subject = connection.stateSubjects.get(type);
+	if (!subject) {
+		let topic = registry.topics.get(type);
+		topic || console.warn(`[sanity-sdk:message-bus] state topic "${type}" is not declared`);
+		let seed = topic?.kind === "state" ? topic.seed : void 0;
+		subject = new BehaviorSubject(seed === void 0 ? NO_VALUE : seed), connection.stateSubjects.set(type, subject);
+	}
+	return subject;
+}
+function toStateSource(values, getCurrent) {
+	let source = values;
+	source.getCurrent = getCurrent;
+	let firstValue;
+	return Object.defineProperty(source, "firstValue", { get: () => firstValue ??= firstValueFrom(values) }), source;
+}
+function assertCompatibleTopicManifest(registry, manifest) {
+	for (let [type, entry] of Object.entries(manifest)) {
+		let existing = registry.topics.get(type);
+		if (existing && existing.kind !== entry.kind) throw new MessageBusError("PROTOCOL_MISMATCH", `topic "${type}" is declared "${entry.kind}" but the installed bus knows it as "${existing.kind}"`);
+		if (existing?.kind === "event" && entry.kind === "event" && existing.ownership.type !== entry.ownership.type) throw new MessageBusError("OWNERSHIP_MISMATCH", `topic "${type}" has conflicting ownership`);
+	}
+}
+function mergeTopicManifest(registry, manifest) {
+	assertCompatibleTopicManifest(registry, manifest);
+	for (let [type, entry] of Object.entries(manifest)) registry.topics.set(type, entry);
+}
+function resolveEventSubject(registry, type) {
+	let subject = registry.eventSubjects.get(type);
+	return subject || (subject = new Subject(), registry.eventSubjects.set(type, subject)), subject;
+}
+function settleReply(reply, outcome) {
+	reply.settled || (reply.settled = !0, reply.settlePromise ? reply.settlePromise(outcome) : reply.outcomeBeforeAwait = outcome);
+}
+function createEventMessage(appId, moduleId, type, payload, pendingReply) {
+	let message = {
+		type,
+		payload,
+		meta: {
+			appId,
+			moduleId,
+			timestamp: Date.now()
+		},
+		reply: (value) => {
+			if (pendingReply.settled) {
+				console.warn(`[sanity-sdk:message-bus] reply ignored for "${type}": no waiting caller or already replied`);
+				return;
+			}
+			settleReply(pendingReply, {
+				ok: !0,
+				value
+			});
+		},
+		get signal() {
+			return pendingReply.responderSignal;
+		}
+	};
+	return message[MESSAGE_BUS_PENDING_REPLY_KEY] = pendingReply, message;
+}
+function createReplyPromise(pendingReply, options) {
+	return new Promise((resolve, reject) => {
+		let settlePromise = (outcome) => outcome.ok ? resolve(outcome.value) : reject(outcome.error);
+		if (pendingReply.outcomeBeforeAwait) {
+			pendingReply.responderAbort.abort(), settlePromise(pendingReply.outcomeBeforeAwait);
+			return;
+		}
+		if (!options.hadResponderAtEmission) {
+			reject(new MessageBusError("NO_RESPONDER"));
+			return;
+		}
+		let timeoutMs = options.timeout === void 0 ? DEFAULT_TIMEOUT_MS : options.timeout, timer, onAbort = () => settleReply(pendingReply, {
+			ok: !1,
+			error: new MessageBusError("ABORTED")
+		});
+		pendingReply.settlePromise = (outcome) => {
+			timer !== void 0 && clearTimeout(timer), options.signal?.removeEventListener("abort", onAbort), pendingReply.responderAbort.abort(), settlePromise(outcome);
+		}, timeoutMs !== null && (timer = setTimeout(() => settleReply(pendingReply, {
+			ok: !1,
+			error: new MessageBusError("TIMEOUT")
+		}), timeoutMs)), options.signal && (options.signal.aborted ? onAbort() : options.signal.addEventListener("abort", onAbort, { once: !0 }));
+	});
+}
+function createLazyReply(awaitReply) {
+	return {
+		then: (onFulfilled, onRejected) => awaitReply().then(onFulfilled, onRejected),
+		catch: (onRejected) => awaitReply().then(void 0, onRejected),
+		finally: (onFinally) => awaitReply().finally(onFinally)
+	};
+}
+function emitEvent(registry, type, payload, options, appId, moduleId) {
+	let hadResponderAtEmission = (registry.responderCounts.get(type) ?? 0) > 0, responderAbort = new AbortController(), pendingReply = {
+		responderAbort,
+		responderSignal: scopeSignal(options?.signal, responderAbort.signal),
+		settled: !1
+	};
+	resolveEventSubject(registry, type).next(createEventMessage(appId, moduleId, type, payload, pendingReply));
+	let awaitReply = () => pendingReply.replyPromise ??= createReplyPromise(pendingReply, {
+		...options,
+		hadResponderAtEmission
+	});
+	return createLazyReply(awaitReply);
+}
+const isStateTopic = (registry, type) => registry.topics.get(type)?.kind === "state", canRespond = (registry, ownership, appId) => ownership.type === "any_app" || appId === registry.appId;
+function emit(registry, type, payload, options, appId, moduleId, connectionSignal) {
+	if (isStateTopic(registry, type)) throw new MessageBusError("OWNERSHIP_MISMATCH", `Cannot emit state topic "${type}" from app "${appId}". The host writes state to each connection through its client handle. Read it with query() or subscribe().`);
+	return emitEvent(registry, type, payload, {
+		...options,
+		signal: scopeSignal(options?.signal, registry.resetAbort.signal, connectionSignal)
+	}, appId, moduleId);
+}
+function emitState(registry, connection, type, value) {
+	let subject = resolveStateSubject(registry, connection, type);
+	Object.is(subject.getValue(), value) || subject.next(value);
+}
+function query(source, type, options, connectionSignal, resetSignal) {
+	let current = source.getCurrent();
+	if (current !== void 0) return Promise.resolve(current);
+	let signal = scopeSignal(options?.signal, resetSignal, connectionSignal);
+	if (signal.aborted) return Promise.reject(new MessageBusError("ABORTED"));
+	let timeoutMs = options?.timeout === void 0 ? DEFAULT_TIMEOUT_MS : options.timeout;
+	return new Promise((resolve, reject) => {
+		let timer = timeoutMs === null ? void 0 : setTimeout(() => reject(new MessageBusError("TIMEOUT", `query("${type}") timed out`)), timeoutMs), clear = () => {
+			timer !== void 0 && clearTimeout(timer);
+		}, onAbort = () => {
+			clear(), reject(new MessageBusError("ABORTED"));
+		};
+		signal?.addEventListener("abort", onAbort, { once: !0 }), source.firstValue.then((value) => {
+			clear(), signal?.removeEventListener("abort", onAbort), resolve(value);
+		}, (error) => {
+			clear(), signal?.removeEventListener("abort", onAbort), reject(error);
+		});
+	});
+}
+function unsubscribeOnAbort(subscription, signal) {
+	if (signal) {
+		if (signal.aborted) {
+			subscription.unsubscribe();
+			return;
+		}
+		signal.addEventListener("abort", () => subscription.unsubscribe(), { once: !0 });
+	}
+}
+function scopeSignal(signal, ...lifecycles) {
+	return signal ? AbortSignal.any([signal, ...lifecycles]) : AbortSignal.any(lifecycles);
+}
+function invokeResponder(handler, message) {
+	let pendingReply = message[MESSAGE_BUS_PENDING_REPLY_KEY], fail = (error) => {
+		pendingReply && settleReply(pendingReply, {
+			ok: !1,
+			error: new MessageBusError("HANDLER_THREW", void 0, { cause: error })
+		});
+	};
+	try {
+		let result = handler(message);
+		result instanceof Promise && result.catch(fail);
+	} catch (error) {
+		fail(error);
+	}
+}
+function respond(registry, type, handler, options, appId, connectionSignal) {
+	let topic = registry.topics.get(type);
+	if (topic?.kind === "event" && !canRespond(registry, topic.ownership, appId)) throw new MessageBusError("OWNERSHIP_MISMATCH", `Cannot register a handler for event topic "${type}" from app "${appId}". Only the app that owns this topic can respond to it. Other apps can send it with emit().`);
+	registry.responderCounts.set(type, (registry.responderCounts.get(type) ?? 0) + 1);
+	let subscription = resolveEventSubject(registry, type).subscribe((message) => invokeResponder(handler, message));
+	subscription.add(() => {
+		let count = registry.responderCounts.get(type) ?? 0;
+		count > 0 && registry.responderCounts.set(type, count - 1);
+	}), unsubscribeOnAbort(subscription, scopeSignal(options?.signal, registry.resetAbort.signal, connectionSignal));
+}
+const bundledMigrations = () => new Map(Object.entries(topicMigrations));
+/**
+* Creates an isolated message bus without installing it globally and returns the host's
+* connection to it.
+* @internal
+*/
+function createIsolatedMessageBus(appId, config = {}) {
+	appId || throwMissingAppId();
+	let registry = {
+		appId,
+		topics: /* @__PURE__ */ new Map(),
+		connections: /* @__PURE__ */ new Set(),
+		connected$: new Subject(),
+		eventSubjects: /* @__PURE__ */ new Map(),
+		responderCounts: /* @__PURE__ */ new Map(),
+		migrations: config.migrations ?? bundledMigrations(),
+		resetAbort: new AbortController(),
+		generation: 0
+	};
+	return mergeTopicManifest(registry, DASHBOARD_TOPIC_MANIFEST), createConnection(registry, {
+		appId,
+		migrations: config.migrations
+	});
+}
+const identityMigration = {
+	up: (value) => value,
+	down: (value) => value
+};
+function effectiveTopicVersions(migrations) {
+	let versions = /* @__PURE__ */ new Map();
+	for (let [topic, steps] of migrations) {
+		let version = 1;
+		for (let step of steps) step.to > version && (version = step.to);
+		versions.set(topic, version);
+	}
+	return versions;
+}
+function migrationTransformAt(steps, version, select) {
+	let step = steps?.find((candidate) => candidate.from === version);
+	return (step ? select(step) : void 0) ?? identityMigration;
+}
+function migrateVersionedValue(steps, value, from, to, select) {
+	if (from === to) return value;
+	let current = value;
+	if (from < to) for (let version = from; version < to; version++) current = migrationTransformAt(steps, version, select).up(current);
+	else for (let version = from; version > to; version--) current = migrationTransformAt(steps, version - 1, select).down(current);
+	return current;
+}
+function createTopicCompatibility(installedMigrations, applicationMigrations) {
+	let installedVersions = effectiveTopicVersions(installedMigrations), applicationVersions = effectiveTopicVersions(applicationMigrations), applicationVersion = (type) => applicationVersions.get(type) ?? 1, installedVersion = (type) => installedVersions.get(type) ?? 1, migrationChainFor = (type) => (applicationVersion(type) > installedVersion(type) ? applicationMigrations : installedMigrations).get(type), createVersionAdapter = (select) => ({
+		toInstalled: (type, value) => migrateVersionedValue(migrationChainFor(type), value, applicationVersion(type), installedVersion(type), select),
+		toApplication: (type, value) => migrateVersionedValue(migrationChainFor(type), value, installedVersion(type), applicationVersion(type), select)
+	}), stateValueAndEventPayload = createVersionAdapter((step) => step), eventReply = createVersionAdapter((step) => step.reply);
+	return {
+		toInstalledEmission: stateValueAndEventPayload.toInstalled,
+		toApplicationStateValue: stateValueAndEventPayload.toApplication,
+		toApplicationEventPayload: stateValueAndEventPayload.toApplication,
+		toInstalledEventReply: eventReply.toInstalled,
+		toApplicationEventReply: eventReply.toApplication
+	};
+}
+function projectCurrent(input, project) {
+	let lastInput, lastOutput, cached = !1;
+	return () => {
+		let current = input();
+		if (current !== void 0) return (!cached || current !== lastInput) && (lastInput = current, lastOutput = project(current), cached = !0), lastOutput;
+	};
+}
+function createStateSource(subject, project, completeOn) {
+	let getCurrent = () => {
+		let current = subject.getValue();
+		return current === NO_VALUE ? void 0 : current;
+	};
+	return toStateSource(subject.pipe(filter((value) => value !== NO_VALUE), map(project), takeUntil(completeOn)), projectCurrent(getCurrent, project));
+}
+function migrateEventMessage(message, payload, reply) {
+	return {
+		type: message.type,
+		payload: payload(message.payload),
+		meta: message.meta,
+		reply: (value) => message.reply(reply(value)),
+		get signal() {
+			return message.signal;
+		}
+	};
+}
+function migrateEventReply(result, project) {
+	let projected;
+	return createLazyReply(() => projected ??= Promise.resolve(result).then(project));
+}
+function createRejectedConnection(connectionError) {
+	let throwConnectionError = () => {
+		throw connectionError();
+	};
+	return {
+		emit: throwConnectionError,
+		query: () => Promise.reject(connectionError()),
+		subscribe: throwConnectionError,
+		disconnect: () => {}
+	};
+}
+/**
+* Connects an application to an isolated message bus.
+* @internal
+*/
+function connectApplicationToMessageBus(installedMessageBus, config) {
+	config.appId || throwMissingAppId();
+	let { appId } = config, installedProtocol = installedMessageBus[MESSAGE_BUS_PROTOCOL_KEY];
+	if (installedProtocol !== 1) return console.error(`[sanity-sdk:message-bus] protocol mismatch for "${appId}": installed ${String(installedProtocol)}, this copy speaks 1`), createRejectedConnection(() => new MessageBusError("PROTOCOL_MISMATCH", `installed message bus speaks protocol ${String(installedProtocol)}, this copy speaks 1`));
+	let registry = installedMessageBus[MESSAGE_BUS_REGISTRY_KEY];
+	if (!registry) return console.error(`[sanity-sdk:message-bus] incompatible message bus for "${appId}"`), createRejectedConnection(() => new MessageBusError("PROTOCOL_MISMATCH", "installed message bus does not expose a compatible registry"));
+	try {
+		mergeTopicManifest(registry, DASHBOARD_TOPIC_MANIFEST);
+	} catch (error) {
+		return console.error(`[sanity-sdk:message-bus] topic manifest conflict for "${appId}"`, { error }), createRejectedConnection(() => error);
+	}
+	return createConnection(registry, config);
+}
+function createClient(registry, record, compatibility) {
+	return {
+		appId: record.appId,
+		moduleId: record.moduleId,
+		closed: record.abort.signal,
+		emit: (type, value) => {
+			if (record.abort.signal.aborted) {
+				console.warn(`[sanity-sdk:message-bus] "${type}" not written: connection "${record.moduleId}" has closed`);
+				return;
+			}
+			emitState(registry, record, type, compatibility.toInstalledEmission(type, value));
+		}
+	};
+}
+function createConnectionsSource(registry, self, compatibility, completeOn) {
+	let clients = /* @__PURE__ */ new WeakMap(), clientFor = (record) => {
+		let client = clients.get(record);
+		return client || (client = createClient(registry, record, compatibility), clients.set(record, client)), client;
+	};
+	return defer(() => concat(from([...registry.connections]), registry.connected$)).pipe(filter((record) => record !== self), map(clientFor), takeUntil(completeOn));
+}
+function createConnection(registry, config) {
+	let { appId } = config, moduleId = config.moduleId ?? appId, connectionAbort = new AbortController(), connectionSignal = connectionAbort.signal, connectionAborted$ = new ReplaySubject(1);
+	connectionSignal.addEventListener("abort", () => connectionAborted$.next(), { once: !0 });
+	let record = {
+		appId,
+		moduleId,
+		stateSubjects: /* @__PURE__ */ new Map(),
+		abort: connectionAbort
+	}, compatibility = createTopicCompatibility(registry.migrations, config.migrations ?? bundledMigrations()), isState = (type) => isStateTopic(registry, type), applicationStreams = /* @__PURE__ */ new Map(), streamGeneration = registry.generation, cachedStream = (type, create) => {
+		streamGeneration !== registry.generation && (applicationStreams.clear(), streamGeneration = registry.generation);
+		let stream = applicationStreams.get(type);
+		return stream || (stream = create(), applicationStreams.set(type, stream)), stream;
+	}, stateSource = (type) => cachedStream(type, () => createStateSource(resolveStateSubject(registry, record, type), (value) => compatibility.toApplicationStateValue(type, value), connectionAborted$)), eventStream = (type) => cachedStream(type, () => resolveEventSubject(registry, type).pipe(map((message) => compatibility.toApplicationEventPayload(type, message.payload)), takeUntil(connectionAborted$))), throwIfDisconnected = () => {
+		if (connectionSignal.aborted) throw new MessageBusError("ABORTED");
+	}, connection = {
+		emit: (type, payload, options) => (throwIfDisconnected(), migrateEventReply(emit(registry, type, compatibility.toInstalledEmission(type, payload), options, appId, moduleId, connectionSignal), (value) => compatibility.toApplicationEventReply(type, value))),
+		query: (type, options) => connectionSignal.aborted ? Promise.reject(new MessageBusError("ABORTED")) : query(stateSource(type), type, options, connectionSignal, registry.resetAbort.signal),
+		subscribe: (type, handler, options) => {
+			if (throwIfDisconnected(), isState(type)) {
+				let source = stateSource(type);
+				if (!handler) return source;
+				unsubscribeOnAbort(source.subscribe(handler), scopeSignal(options?.signal, registry.resetAbort.signal, connectionSignal));
+				return;
+			}
+			if (!handler) return eventStream(type);
+			respond(registry, type, (message) => handler(migrateEventMessage(message, (value) => compatibility.toApplicationEventPayload(type, value), (value) => compatibility.toInstalledEventReply(type, value))), options, appId, connectionSignal);
+		},
+		disconnect: () => {
+			if (!connectionSignal.aborted) {
+				connectionAbort.abort();
+				for (let subject of record.stateSubjects.values()) subject.complete();
+				record.stateSubjects.clear(), registry.connections.delete(record);
+			}
+		}
+	};
+	appId === registry.appId && Object.assign(connection, { connections: createConnectionsSource(registry, record, compatibility, connectionAborted$) });
+	let instance = connection;
+	return instance[MESSAGE_BUS_REGISTRY_KEY] = registry, instance[MESSAGE_BUS_PROTOCOL_KEY] = 1, registry.connections.add(record), registry.connected$.next(record), instance;
+}
+function reset(registry) {
+	registry.resetAbort.abort();
+	for (let connection of registry.connections) {
+		for (let subject of connection.stateSubjects.values()) subject.complete();
+		connection.stateSubjects.clear();
+	}
+	for (let subject of registry.eventSubjects.values()) subject.complete();
+	registry.topics.clear(), registry.eventSubjects.clear(), registry.responderCounts.clear(), registry.resetAbort = new AbortController(), registry.generation += 1, mergeTopicManifest(registry, DASHBOARD_TOPIC_MANIFEST);
+}
+function throwMissingAppId() {
+	throw new MessageBusError("MISSING_APP_ID", "Cannot initialize the message bus without an app ID. Build the application with the Sanity CLI or pass an app ID when connecting.");
+}
+const resolveAppId = (appId) => appId ?? (typeof __SANITY_APP_ID__ == "string" ? __SANITY_APP_ID__ : void 0);
+function getInstalledMessageBus() {
+	let bus = globalThis[MESSAGE_BUS_KEY];
+	return typeof bus == "object" && bus && MESSAGE_BUS_REGISTRY_KEY in bus ? bus : void 0;
+}
+/**
+* Returns whether a message bus registry is installed.
+* @internal
+*/
+function isMessageBusInstalled() {
+	return getInstalledMessageBus() !== void 0;
+}
+/**
+* Connects to the installed message bus, or returns `undefined` when no compatible connection exists.
+* @public
+*/
+function connectMessageBus(options = {}) {
+	let installedMessageBus = getInstalledMessageBus();
+	if (!installedMessageBus) return;
+	let appId = resolveAppId(options.appId);
+	if (!appId) {
+		console.warn("[sanity-sdk:message-bus] cannot connect without an app ID; build with the Sanity CLI or pass appId");
+		return;
+	}
+	let connection = connectApplicationToMessageBus(installedMessageBus, {
+		appId,
+		moduleId: options.moduleId
+	});
+	return MESSAGE_BUS_REGISTRY_KEY in connection ? connection : void 0;
+}
+/**
+* Resets the installed message bus for test isolation.
+* @internal
+*/
+function resetMessageBus() {
+	let installedMessageBus = getInstalledMessageBus();
+	installedMessageBus && reset(installedMessageBus[MESSAGE_BUS_REGISTRY_KEY]);
+}
+/**
+* Installs the shared message bus and returns the host's connection, or connects to its
+* existing installation. Only the host calls this; another app's ID is rejected because the
+* connection it would get has no `connections`.
+* @internal
+*/
+function installMessageBus(options = {}) {
+	let appId = resolveAppId(options.appId) ?? throwMissingAppId(), installedMessageBus = getInstalledMessageBus();
+	if (installedMessageBus) {
+		let installedAppId = installedMessageBus[MESSAGE_BUS_REGISTRY_KEY].appId;
+		if (installedAppId !== appId) throw new MessageBusError("OWNERSHIP_MISMATCH", `Cannot install the message bus as "${appId}": it is already installed by "${installedAppId}". Applications connect with connectMessageBus().`);
+		return connectApplicationToMessageBus(installedMessageBus, { appId });
+	}
+	let globals = globalThis;
+	globals[MESSAGE_BUS_KEY] && console.error("[sanity-sdk:message-bus] overwriting an incompatible message bus already installed");
+	let host = createIsolatedMessageBus(appId);
+	return globals[MESSAGE_BUS_KEY] = host, host;
+}
+/**
+* Returns the message bus connection for this instance, connecting on first call.
+*
+* @remarks
+* One connection is made per {@link SanityInstance}, carrying that window's
+* module identity. The first caller wins; later callers get the cached
+* connection. When no host bus is installed it returns `undefined` without
+* caching, so a later call retries once a host installs the bus.
+* @internal
+*/
+const getDashboardMessageBus = createActionBinder((instance) => ({ name: instance.instanceId }))(defineStore({
+	name: "dashboardMessageBus",
+	getInitialState: () => ({}),
+	initialize: ({ state }) => () => state.get().connection?.disconnect()
+}), ({ state }, moduleId) => {
+	let current = state.get().connection;
+	if (current) return current;
+	if (!isMessageBusInstalled()) return;
+	let connection = connectMessageBus({ moduleId });
+	if (connection) return state.set("connect", { connection }), connection;
+});
+/**
+* Returns the instance's message bus connection, or throws when no dashboard host has
+* installed a bus. `action` names what the caller was about to do, e.g. `read topic "x"`.
+* @internal
+*/
+function requireDashboardMessageBus(instance, action) {
+	let messageBus = getDashboardMessageBus(instance);
+	if (!messageBus) throw Error(`Cannot ${action} without an installed dashboard message bus`);
+	return messageBus;
+}
+/**
+* Returns whether a dashboard host has installed a message bus.
+*
+* @remarks
+* Answers "does a host own this session", not "has this instance connected yet". Callers
+* such as the login redirect run before {@link getDashboardMessageBus} has been called for
+* the instance, so this must not depend on the connection state.
+* @internal
+*/
+function isDashboardEnvironment() {
+	return isMessageBusInstalled();
+}
+/**
+* An error raised when a dashboard state topic reports failure.
+* @public
+*/
+var TopicError = class extends Error {
+	/** Creates an error for a failed topic. */
+	constructor(topic) {
+		super(`Topic "${topic}" failed`), _defineProperty(this, "topic", void 0), this.name = "TopicError", this.topic = topic;
+	}
+};
+function isTopicResult(value) {
+	return typeof value == "object" && !!value && "ok" in value && typeof value.ok == "boolean";
+}
+function unwrapTopicResult(topic, value) {
+	if (!isTopicResult(value)) return value;
+	if (!value.ok) throw new TopicError(topic);
+	return value.value;
+}
+const TOPIC_STATE_CLEAR_DELAY = 1e3, bindActionByInstance = createActionBinder((instance) => ({ name: instance.instanceId })), dashboardTopicsStore = defineStore({
+	name: "dashboardTopics",
+	getInitialState: () => ({ topics: {} })
+}), getMessageBus = (instance, topic) => requireDashboardMessageBus(instance, `read topic "${topic}"`);
+function getSource(instance, topic) {
+	return getMessageBus(instance, topic).subscribe(topic);
+}
+const updateEntry = (topic, update) => (state) => {
+	let { [topic]: entry = { subscribers: 0 }, ...rest } = state.topics, next = update(entry);
+	return { topics: next.subscribers > 0 ? {
+		...rest,
+		[topic]: next
+	} : rest };
+}, addSubscriber = (topic) => updateEntry(topic, (entry) => ({
+	...entry,
+	subscribers: entry.subscribers + 1
+})), removeSubscriber = (topic) => updateEntry(topic, (entry) => ({
+	...entry,
+	subscribers: entry.subscribers - 1
+})), getTopicState = bindActionByInstance(dashboardTopicsStore, createStateSourceAction({
+	selector: ({ state, instance }, topic) => {
+		let current = getSource(instance, topic).getCurrent(), entry = state.topics[topic];
+		if (current === void 0 && entry?.error) throw entry.error;
+		return unwrapTopicResult(topic, current);
+	},
+	onSubscribe: ({ state, instance }, topic) => {
+		state.set("addSubscriber", addSubscriber(topic));
+		let subscription = getSource(instance, topic).subscribe(() => state.set("publish", updateEntry(topic, (entry) => ({ ...entry }))));
+		return () => {
+			subscription.unsubscribe(), setCleanupTimeout(() => state.set("removeSubscriber", removeSubscriber(topic)), TOPIC_STATE_CLEAR_DELAY);
+		};
+	}
+})), resolveTopic = bindActionByInstance(dashboardTopicsStore, ({ state, instance }, topic) => {
+	let existing = state.get().topics[topic]?.pending;
+	if (existing) return existing;
+	let release = () => setCleanupTimeout(() => state.set("removeSubscriber", removeSubscriber(topic)), TOPIC_STATE_CLEAR_DELAY), pending = getMessageBus(instance, topic).query(topic).then(() => state.set("resolved", updateEntry(topic, ({ pending: _pending, ...entry }) => entry)), (error) => state.set("failed", updateEntry(topic, ({ pending: _pending, ...entry }) => ({
+		...entry,
+		error
+	}))));
+	return pending.then(release, release), state.set("query", updateEntry(topic, (entry) => ({
+		...entry,
+		pending,
+		subscribers: entry.subscribers + 1
+	}))), pending;
+});
+export { isDashboardEnvironment as a, connectMessageBus as c, getDashboardMessageBus as i, installMessageBus as l, getTopicState as n, requireDashboardMessageBus as o, resolveTopic as r, MessageBusError as s, TopicError as t, resetMessageBus as u };
+
+//# sourceMappingURL=topicStore-Ct7IFNtY.js.map