@sanity/sdk 3.0.0 → 3.2.0

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