@sanity/sdk-react 3.1.0 → 3.3.0-rc.0

package/dist/_exports/dashboard.js

@@ -1,9 +1,385 @@
-import { a as useWindowConnection, n as useOrganizationId, r as DashboardTokenRefreshProvider, t as useStudioWorkspacesByProjectIdDataset } from "../useStudioWorkspacesByProjectIdDataset-DxUlukmF.js";
+import { i as useWindowConnection, n as useOrganizationId, o as createStateSourceHook, r as DashboardTokenRefreshProvider, s as useSanityInstance, t as useStudioWorkspacesByProjectIdDataset } from "../useStudioWorkspacesByProjectIdDataset-BZ_Ud887.js";
 import { c } from "react-compiler-runtime";
 import "@sanity/sdk";
+import { createLogger, getTopicState, requireDashboardMessageBus, resolveTopic } from "@sanity/sdk/_internal";
 import { useEffect, useRef, useState } from "react";
 import { SDK_CHANNEL_NAME, SDK_NODE_NAME } from "@sanity/message-protocol";
 import "@sanity/sdk/comlink";
+import { of } from "rxjs";
+import { MessageBusError, TopicError, connectMessageBus } from "@sanity/sdk/dashboard";
+import { createInstance } from "@module-federation/runtime";
+import "@module-federation/runtime/types";
+const MANIFEST_FILE = "mf-manifest.json";
+function withManifest(remote) {
+	if (remote.entry.endsWith(`/${MANIFEST_FILE}`)) return remote;
+	let base = remote.entry.endsWith("/") ? remote.entry : `${remote.entry}/`;
+	return {
+		...remote,
+		entry: new URL(MANIFEST_FILE, base).href
+	};
+}
+/**
+* Creates a client for registering, loading, and preloading federated modules.
+* @public
+*/
+function createRemoteInstance(options) {
+	let logger = createLogger(options.name), instance = createInstance({
+		...options,
+		plugins: [log(logger.debug), ...options.plugins ?? []],
+		remotes: options.remotes?.map((remote) => "entry" in remote ? withManifest(remote) : remote) ?? []
+	});
+	return {
+		registerRemotes: (remotes) => instance.registerRemotes(remotes.map(withManifest), { force: !1 }),
+		loadRemote: async (id) => {
+			let remoteModule;
+			try {
+				remoteModule = await instance.loadRemote(id);
+			} catch (error) {
+				throw Error(`Failed to load remote module "${id}"`, { cause: error });
+			}
+			return remoteModule;
+		},
+		preloadRemote: (name, exposes) => instance.preloadRemote([{
+			nameOrAlias: name,
+			exposes,
+			resourceCategory: "all"
+		}])
+	};
+}
+function log(onDebug) {
+	let logEvent = (eventName, args) => {
+		let { origin: _origin, ...data } = args;
+		onDebug(`[Lifecycle] ${eventName}`, {
+			...data,
+			internal: !0
+		});
+	};
+	return {
+		name: "sanity-logger",
+		beforeInit(args) {
+			return logEvent("beforeInit", args), args;
+		},
+		beforeRegisterRemote(args) {
+			return logEvent("beforeRegisterRemote", args), args;
+		},
+		beforePreloadRemote(args) {
+			logEvent("beforePreloadRemote", args);
+		},
+		beforeRequest(args) {
+			return logEvent("beforeRequest", args), args;
+		},
+		afterResolve(args) {
+			return logEvent("afterResolve", args), args;
+		},
+		onLoad(args) {
+			return logEvent("onLoad", args), args;
+		},
+		loadShare(args) {
+			logEvent("loadShare", args);
+		},
+		beforeLoadShare(args) {
+			return logEvent("beforeLoadShare", args), args;
+		}
+	};
+}
+function _checkPrivateRedeclaration(e, t) {
+	if (t.has(e)) throw TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _classPrivateMethodInitSpec(e, a) {
+	_checkPrivateRedeclaration(e, a), a.add(e);
+}
+function _classPrivateFieldInitSpec(e, t, a) {
+	_checkPrivateRedeclaration(e, t), t.set(e, a);
+}
+function _assertClassBrand(e, t, n) {
+	if (typeof e == "function" ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+	throw TypeError("Private element is not present on this object");
+}
+function _classPrivateFieldSet2(s, a, r) {
+	return s.set(_assertClassBrand(s, a), r), r;
+}
+function _classPrivateFieldGet2(s, a) {
+	return s.get(_assertClassBrand(s, a));
+}
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && typeof Symbol == "function" && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+function toPrimitive(t, r) {
+	if (_typeof(t) != "object" || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (e !== void 0) {
+		var i = e.call(t, r || "default");
+		if (_typeof(i) != "object") return i;
+		throw TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return (r === "string" ? String : Number)(t);
+}
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return _typeof(i) == "symbol" ? i : i + "";
+}
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+const relativeUrlBase = "https://dashboard.invalid", splitPath = (path) => path.flatMap((part) => part.split("/")).filter(Boolean), intentParametersOf = (...[intent, parameters]) => {
+	let searchParameters = new URLSearchParams();
+	switch (intent) {
+		case "edit": {
+			let { id, type, mode } = parameters;
+			searchParameters.set("id", id), type !== void 0 && searchParameters.set("type", type), mode !== void 0 && searchParameters.set("mode", mode);
+			break;
+		}
+		case "create":
+			searchParameters.set("template", parameters.template), searchParameters.set("type", parameters.type);
+			break;
+		case "release": searchParameters.set("id", parameters.id);
+	}
+	return searchParameters;
+}, parseIntentParameters = (parameters) => new URLSearchParams(parameters.replaceAll(";", "&")), serializeIntentParameters = (parameters) => Array.from(parameters, ([name, value]) => `${encodeURIComponent(name)}=${encodeURIComponent(value)}`).join(";"), appendSegments = (url, segments) => {
+	let nextUrl = new URL(url);
+	return segments.length === 0 || (nextUrl.pathname = `${nextUrl.pathname.replace(/\/$/, "")}/${segments.map(encodeURIComponent).join("/")}`), nextUrl;
+};
+var _url = /* @__PURE__ */ new WeakMap(), _UrlBuilder_brand = /* @__PURE__ */ new WeakSet(), UrlBuilder = class {
+	/**
+	* Creates an immutable URL builder at the supplied URL.
+	*
+	* @example
+	* ```ts
+	* const builder = new UrlBuilder(
+	*   new URL('/applications/my-app', 'https://dashboard.sanity.io'),
+	* )
+	*
+	* builder.url() // '/applications/my-app'
+	* ```
+	*/
+	constructor(url) {
+		_classPrivateMethodInitSpec(this, _UrlBuilder_brand), _classPrivateFieldInitSpec(this, _url, void 0), _classPrivateFieldSet2(_url, this, new URL(url));
+	}
+	/**
+	* Returns a builder with each value appended as one encoded path segment.
+	*
+	* Route literals and identifiers can be passed together. A slash inside a value stays within
+	* that segment instead of creating another route level.
+	*
+	* @example
+	* ```ts
+	* class DocumentUrlBuilder extends UrlBuilder {
+	*   document(documentId: string) {
+	*     return this.append('documents', documentId)
+	*   }
+	* }
+	*
+	* const builder = new DocumentUrlBuilder(new URL('https://dashboard.sanity.io'))
+	* builder.document('drafts/document-1').url()
+	* // '/documents/drafts%2Fdocument-1'
+	* ```
+	*/
+	append(...segments) {
+		return _assertClassBrand(_UrlBuilder_brand, this, _create).call(this, appendSegments(_classPrivateFieldGet2(_url, this), segments));
+	}
+	/**
+	* Returns a builder with changes made through the platform `URL` API.
+	*
+	* This supports URL details outside the path grammar, including search parameters and hashes.
+	*
+	* @example
+	* ```ts
+	* class DocumentUrlBuilder extends UrlBuilder {
+	*   perspective(name: string) {
+	*     return this.edit((url) => url.searchParams.set('perspective', name))
+	*   }
+	*
+	*   panel(panelId: string) {
+	*     return this.edit((url) => {
+	*       url.hash = `panel/${panelId}`
+	*     })
+	*   }
+	* }
+	* ```
+	*/
+	edit(update) {
+		let url = new URL(_classPrivateFieldGet2(_url, this));
+		return update(url), _assertClassBrand(_UrlBuilder_brand, this, _create).call(this, url);
+	}
+	/**
+	* Returns another builder type rooted at the appended path segments.
+	*
+	* Use this inside a custom builder method only when its route enters a child grammar with
+	* different methods; use `append` when chaining stays on the current grammar.
+	*
+	* @example
+	* ```ts
+	* class DocumentUrlBuilder extends UrlBuilder {
+	*   perspective(name: string) {
+	*     return this.edit((url) => url.searchParams.set('perspective', name))
+	*   }
+	* }
+	*
+	* class ApplicationUrlBuilder extends UrlBuilder {
+	*   document(documentId: string) {
+	*     return this.transitionTo(DocumentUrlBuilder, 'documents', documentId)
+	*   }
+	* }
+	*
+	* const builder = new ApplicationUrlBuilder(new URL('https://dashboard.sanity.io'))
+	* builder.document('document-1').perspective('published').url()
+	* // '/documents/document-1?perspective=published'
+	* ```
+	*/
+	transitionTo(Builder, ...segments) {
+		return new Builder(appendSegments(_classPrivateFieldGet2(_url, this), segments));
+	}
+	/**
+	* Returns the URL as a relative string by default.
+	*
+	* Supplying an origin returns an absolute URL string for the same dashboard route.
+	*
+	* @example
+	* ```ts
+	* const builder = new UrlBuilder(
+	*   new URL('/applications/my-app', 'https://dashboard.sanity.io'),
+	* )
+	*
+	* builder.url() // '/applications/my-app'
+	* builder.url({origin: 'https://dashboard.sanity.io'})
+	* // 'https://dashboard.sanity.io/applications/my-app'
+	* ```
+	*/
+	url(options) {
+		let relativeUrl = _assertClassBrand(_UrlBuilder_brand, this, _relativeUrl).call(this);
+		return options?.origin === void 0 ? relativeUrl : new URL(relativeUrl, options.origin).href;
+	}
+	/**
+	* Returns the URL as a platform `URL` object using the supplied origin.
+	*
+	* @example
+	* ```ts
+	* const builder = new UrlBuilder(
+	*   new URL('/applications/my-app', 'https://dashboard.sanity.io'),
+	* )
+	*
+	* builder.toURL({origin: 'https://dashboard.sanity.io'}).pathname
+	* // '/applications/my-app'
+	* ```
+	*/
+	toURL({ origin }) {
+		return new URL(_assertClassBrand(_UrlBuilder_brand, this, _relativeUrl).call(this), origin);
+	}
+	/**
+	* Returns the same relative URL as {@link UrlBuilder.url}.
+	*
+	* @example
+	* ```ts
+	* const builder = new UrlBuilder(
+	*   new URL('/applications/my-app', 'https://dashboard.sanity.io'),
+	* )
+	*
+	* `${builder}` // '/applications/my-app'
+	* ```
+	*/
+	toString() {
+		return this.url();
+	}
+};
+function _relativeUrl() {
+	return `${_classPrivateFieldGet2(_url, this).pathname}${_classPrivateFieldGet2(_url, this).search}${_classPrivateFieldGet2(_url, this).hash}`;
+}
+function _create(url) {
+	let Builder = this.constructor;
+	return new Builder(url);
+}
+var CoreApplicationUrlBuilder = class extends UrlBuilder {
+	path(...path) {
+		return this.append(...splitPath(path));
+	}
+};
+_defineProperty(CoreApplicationUrlBuilder, "namespace", "applications");
+var MediaLibraryUrlBuilder = class extends UrlBuilder {
+	asset(assetId) {
+		return this.append("assets", assetId);
+	}
+	collection(collectionId) {
+		return this.append("collections", collectionId);
+	}
+};
+_defineProperty(MediaLibraryUrlBuilder, "namespace", "media");
+var CanvasUrlBuilder = class extends UrlBuilder {
+	document(documentId) {
+		return this.append("doc", documentId);
+	}
+};
+_defineProperty(CanvasUrlBuilder, "namespace", "canvas");
+var StudioUrlBuilder = class extends UrlBuilder {
+	workspace(workspace) {
+		return this.append(workspace);
+	}
+	intent(...args) {
+		return this.append("intent", args[0]).edit((url) => {
+			url.pathname = `${url.pathname}/${serializeIntentParameters(intentParametersOf(...args))}/`;
+		});
+	}
+	perspective(perspective) {
+		return this.edit((url) => url.searchParams.set("perspective", perspective));
+	}
+	comment(commentId) {
+		return this.edit((url) => {
+			let segments = url.pathname.split("/"), parametersIndex = segments.length - 2, parameters = parseIntentParameters(segments[parametersIndex]);
+			parameters.set("inspect", "sanity/comments"), parameters.set("comment", commentId), segments[parametersIndex] = serializeIntentParameters(parameters), url.pathname = segments.join("/");
+		});
+	}
+	task(taskId) {
+		return this.edit((url) => url.searchParams.set("selectedTask", taskId));
+	}
+	path(...path) {
+		return this.append(...splitPath(path));
+	}
+};
+_defineProperty(StudioUrlBuilder, "namespace", "studios");
+const createRootBuilder = (Builder, ...segments) => new Builder(appendSegments(new URL(relativeUrlBase), [Builder.namespace, ...segments])), createUrls = (builders) => {
+	function studios(appId) {
+		return appId === void 0 ? new UrlBuilder(new URL("/studios/", relativeUrlBase)) : createRootBuilder(StudioUrlBuilder, appId);
+	}
+	function applications(appId) {
+		return appId === void 0 ? new UrlBuilder(new URL("/applications/", relativeUrlBase)) : createRootBuilder(CoreApplicationUrlBuilder, appId);
+	}
+	let methods = Object.fromEntries(Object.entries(builders).map(([name, Builder]) => [name, () => createRootBuilder(Builder)])), urls = {
+		studios,
+		applications,
+		mediaLibrary: () => createRootBuilder(MediaLibraryUrlBuilder),
+		canvas: () => createRootBuilder(CanvasUrlBuilder),
+		home: () => new UrlBuilder(new URL(relativeUrlBase)),
+		extend(addedBuilders) {
+			let namespaces = /* @__PURE__ */ new Set([
+				"",
+				StudioUrlBuilder.namespace,
+				CoreApplicationUrlBuilder.namespace,
+				MediaLibraryUrlBuilder.namespace,
+				CanvasUrlBuilder.namespace,
+				...Object.values(builders).map((Builder) => Builder.namespace)
+			]);
+			for (let [name, Builder] of Object.entries(addedBuilders)) {
+				if (name in urls || name in methods) throw Error(`URL builder "${name}" already exists`);
+				if (namespaces.has(Builder.namespace)) throw Error(`URL namespace "${Builder.namespace}" already exists`);
+				namespaces.add(Builder.namespace);
+			}
+			return createUrls({
+				...builders,
+				...addedBuilders
+			});
+		}
+	};
+	return Object.assign(urls, methods);
+}, urlFor = createUrls({});
 /**
 * @public
 * Hook for emitting agent resource context updates to the Dashboard.
@@ -70,6 +446,232 @@ function useAgentResourceContext(options) {
 	}, t3 = [updateContext], $[6] = updateContext, $[7] = t2, $[8] = t3), useEffect(t2, t3);
 }
 /**
+* Returns the current value of a dashboard state topic and follows later updates.
+*
+* The hook suspends until the topic publishes its first value, using the message bus query
+* deadline. A topic declared with `TopicResult` resolves to its successful value; a
+* failed result throws a `TopicError` to the nearest error boundary.
+*
+* @example
+* ```tsx
+* function ForegroundApplication() {
+*   const foregroundId = useTopic('applications.foreground')
+*   return <span>{foregroundId ?? 'No application in the foreground'}</span>
+* }
+* ```
+*
+* @public
+*/
+const useTopic = createStateSourceHook({
+	getState: getTopicState,
+	shouldSuspend: (instance, topic) => getTopicState(instance, topic).getCurrent() === void 0,
+	suspender: resolveTopic
+}), applicationOrigin = (application) => {
+	if (application.externalUrl !== null) return new URL(application.externalUrl).origin;
+	if (application.slug === null) return null;
+	let staging = globalThis.__SANITY_STAGING__ === !0;
+	if (application.isSingleton) {
+		let domain = staging ? "run.sanity.work" : "sanity.run";
+		return `https://${application.slug}-apps-${application.organizationId}.${domain}`;
+	}
+	let domain = staging ? "studio.sanity.work" : "sanity.studio";
+	return `https://${application.slug}.${domain}`;
+}, loadableInterfaces = ({ activeDeployment, config }) => config?.mfManifest === void 0 ? [] : activeDeployment?.interfaces ?? [], toApplication = (application) => {
+	let { activeDeployment: _activeDeployment, config: _config, ...applicationBase } = application, interfaces = loadableInterfaces(application), entry = interfaces.length === 0 ? null : applicationOrigin(applicationBase);
+	if (entry === null) return {
+		...applicationBase,
+		views: [],
+		webWorkers: []
+	};
+	let views = [], webWorkers = [];
+	for (let extension of interfaces) {
+		let module = {
+			entry,
+			moduleId: `${applicationBase.id}/${extension.moduleId}`,
+			version: extension.version
+		};
+		if (extension.type === "worker") {
+			webWorkers.push({
+				...extension,
+				application: applicationBase,
+				module
+			});
+			continue;
+		}
+		let { type, ...view } = extension;
+		views.push({
+			...view,
+			application: applicationBase,
+			module,
+			surface: type === "app" ? "window" : type
+		});
+	}
+	return {
+		...applicationBase,
+		views,
+		webWorkers
+	};
+};
+/**
+* Returns the applications available in the dashboard.
+*
+* Suspends until the dashboard publishes its application list; a cleared list is empty. Throws a
+* `TopicError` to the nearest error boundary when the dashboard fails to load applications.
+*
+* @example
+* ```tsx
+* function Applications() {
+*   const applications = useApplications()
+*   return applications.map((application) => <div key={application.id}>{application.title}</div>)
+* }
+* ```
+*
+* @public
+*/
+function useApplications() {
+	let $ = c(2), applications = useTopic("applications.list"), t0;
+	return $[0] === applications ? t0 = $[1] : (t0 = applications?.map(toApplication) ?? [], $[0] = applications, $[1] = t0), t0;
+}
+/**
+* Returns a dashboard application by id, or `null` when it is unavailable.
+*
+* Suspends until the dashboard publishes its application list.
+*
+* @example
+* ```tsx
+* function SelectedApplication({id}: {id: string}) {
+*   const application = useApplication(id)
+*   return application ? <h1>{application.title}</h1> : <p>Application unavailable</p>
+* }
+* ```
+*
+* @public
+*/
+function useApplication(applicationId) {
+	return useApplications().find((t0) => {
+		let { id } = t0;
+		return id === applicationId;
+	}) ?? null;
+}
+const NO_CONFIGS = Object.freeze([]);
+/**
+* Returns the application configuration modules available in the dashboard.
+*
+* Suspends until the dashboard publishes its application configs; a cleared list is empty.
+*
+* @example
+* ```tsx
+* function Applications() {
+*   const configs = useApplicationConfigs()
+*   return configs.map((config) => <div key={config.moduleId}>{config.appType}</div>)
+* }
+* ```
+*
+* @public
+*/
+function useApplicationConfigs() {
+	return useTopic("applications.config") ?? NO_CONFIGS;
+}
+/**
+* Returns an application configuration by application id or application type, or `null` when
+* none matches.
+*
+* An `appType` query matches the type-level config only (the one without an `appId`), so it is
+* independent of the order the dashboard published configs in. An `appId` query matches that
+* application's config.
+*
+* Suspends until the dashboard publishes its application configs.
+*
+* @example
+* ```tsx
+* function MediaLibraryConfig() {
+*   const config = useApplicationConfig({appType: 'media-library'})
+*   return config ? <span>{config.moduleId}</span> : <p>Not installed</p>
+* }
+* ```
+*
+* @public
+*/
+function useApplicationConfig(selector) {
+	let $ = c(3), configs = useApplicationConfigs(), t0;
+	return $[0] !== configs || $[1] !== selector ? (t0 = configs.find((config) => selector.appId === void 0 ? config.appType === selector.appType && config.appId === void 0 : config.appId === selector.appId) ?? null, $[0] = configs, $[1] = selector, $[2] = t0) : t0 = $[2], t0;
+}
+/**
+* Returns the id of the application in the foreground, or `null` when Dashboard has none.
+*
+* Suspends until Dashboard publishes the foreground application.
+*
+* @example
+* ```tsx
+* function ForegroundApplication() {
+*   const foregroundId = useApplicationForegroundId()
+*   return <span>{foregroundId ?? 'No foreground application'}</span>
+* }
+* ```
+*
+* @public
+*/
+function useApplicationForegroundId() {
+	return useTopic("applications.foreground");
+}
+/**
+* Returns a stable function that emits a dashboard event topic.
+*
+* The event is sent immediately. Ignore the lazy result for fire-and-forget delivery, await it
+* inside `useTransition` to track a reply, or read it with React `use` to suspend. A reply
+* that fails (`NO_RESPONDER`, `TIMEOUT`, `ABORTED`) rejects the result; when read with `use`
+* that reaches the nearest error boundary, so pair the `Suspense` with one.
+*
+* @example Fire and forget
+* ```tsx
+* function ExpandPanel() {
+*   const setPanelMode = useEmit('panels.mode.set')
+*   return (
+*     <button onClick={() => setPanelMode({name: 'favorites', mode: 'full'})}>
+*       Expand
+*     </button>
+*   )
+* }
+* ```
+*
+* @example Await a reply with Suspense
+* ```tsx
+* function Session({request}: {request: MessageBusEmitResult<string>}) {
+*   use(request)
+*   return <p>Ready</p>
+* }
+*
+* function SessionAccordion() {
+*   const refreshToken = useEmit('auth.token.refresh')
+*   const [request, setRequest] = useState<MessageBusEmitResult<string> | null>(null)
+*
+*   return (
+*     <details
+*       onToggle={(event) => setRequest(event.currentTarget.open ? refreshToken() : null)}
+*     >
+*       <summary>Session</summary>
+*       <ErrorBoundary fallback={<p>Could not refresh</p>}>
+*         <Suspense fallback={<p>Refreshing...</p>}>
+*           {request && <Session request={request} />}
+*         </Suspense>
+*       </ErrorBoundary>
+*     </details>
+*   )
+* }
+* ```
+*
+* @public
+*/
+function useEmit(topic) {
+	let $ = c(6), instance = useSanityInstance(), t0 = `emit topic "${topic}"`, t1;
+	$[0] !== instance || $[1] !== t0 ? (t1 = requireDashboardMessageBus(instance, t0), $[0] = instance, $[1] = t0, $[2] = t1) : t1 = $[2];
+	let messageBus = t1, t2;
+	return $[3] !== messageBus || $[4] !== topic ? (t2 = (...t3) => {
+		let args = t3;
+		return messageBus.emit(topic, ...args);
+	}, $[3] = messageBus, $[4] = topic, $[5] = t2) : t2 = $[5], t2;
+}
+/**
 * @public
 *
 * A helper hook designed to be injected into routing components for apps within the Dashboard.
@@ -203,6 +805,25 @@ function useNavigateToStudioDocument(documentHandle, preferredStudioUrl) {
 	let navigateToStudioDocument = t1, t2;
 	return $[6] === navigateToStudioDocument ? t2 = $[7] : (t2 = { navigateToStudioDocument }, $[6] = navigateToStudioDocument, $[7] = t2), t2;
 }
+const remoteClientStates = /* @__PURE__ */ new WeakMap();
+/** Returns the instance's remote client state, creating it on first use. @internal */
+function getRemoteClientState(instance) {
+	if (instance.isDisposed()) throw Error("Cannot create a remote client for a disposed Sanity instance");
+	let current = remoteClientStates.get(instance);
+	if (current) return current;
+	let client = createRemoteInstance({ name: `sanity-remote-${instance.instanceId}` }), state = {
+		getCurrent: () => client,
+		observable: of(client),
+		subscribe: () => () => {}
+	};
+	return remoteClientStates.set(instance, state), instance.onDispose(() => remoteClientStates.delete(instance)), state;
+}
+/**
+* Returns a remote client shared by hooks using the same Sanity instance.
+* The first call creates the client; later calls reuse it.
+* @public
+*/
+const useRemoteClient = createStateSourceHook(getRemoteClientState);
 function resolveAppTitle(resource) {
 	return resource.manifest?.title || resource.activeDeployment?.manifest?.title || resource.title;
 }
@@ -273,6 +894,6 @@ function useWindowTitle(viewTitle) {
 		};
 	}, [viewTitle, appTitle]);
 }
-export { DashboardTokenRefreshProvider as TokenRefreshProvider, useAgentResourceContext, useNavigate, useNavigateToStudioDocument, useOrganizationId, useWindowTitle };
+export { MessageBusError, DashboardTokenRefreshProvider as TokenRefreshProvider, TopicError, UrlBuilder, connectMessageBus, createRemoteInstance, urlFor, useAgentResourceContext, useApplication, useApplicationConfig, useApplicationConfigs, useApplicationForegroundId, useApplications, useEmit, useNavigate, useNavigateToStudioDocument, useOrganizationId, useRemoteClient, useTopic, useWindowTitle };
 
 //# sourceMappingURL=dashboard.js.map