@sanity/sdk-react 3.4.0-rc.0 → 3.5.0-next.20260922182803

package/dist/_exports/dashboard.js

@@ -1,12 +1,12 @@
-import { a as useWindowConnection, c as useSanityInstance, i as DashboardTokenRefreshProvider, n as useTopic, r as useOrganizationId, s as createStateSourceHook, t as useStudioWorkspacesByProjectIdDataset } from "../useStudioWorkspacesByProjectIdDataset-B5A5kBH9.js";
+import { a as DashboardTokenRefreshProvider, c as createStateSourceHook, i as useOrganizationId, l as useSanityInstance, n as useTopic, o as useWindowConnection, r as useEmit, t as useStudioWorkspacesByProjectIdDataset } from "../useStudioWorkspacesByProjectIdDataset-DL6_9jgU.js";
 import { c } from "react-compiler-runtime";
 import "@sanity/sdk";
 import { createLogger, getApplicationOrigin, isDashboardEnvironment, requireDashboardMessageBus } from "@sanity/sdk/_internal";
-import { useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useEffectEvent, 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 { filter, map, of, pairwise } from "rxjs";
+import { MessageBusError, TopicError, TopicError as TopicError$1, capabilities, connectMessageBus } from "@sanity/sdk/dashboard";
 import "@sanity/types";
 import { createInstance } from "@module-federation/runtime";
 import "@module-federation/runtime/types";
@@ -382,13 +382,53 @@ const createRootBuilder = (Builder, ...segments) => new Builder(appendSegments(n
 	return Object.assign(urls, methods);
 }, urlFor = createUrls({});
 /**
+* Publishes what this application is currently showing to the Dashboard message bus, so the host
+* can hold the foreground application's context. Pass `null` when nothing is open.
+*
+* The context is published on mount and whenever it changes, and cleared with `null` on unmount.
+* A change publishes `null` before the new context, as the component has stopped showing the old
+* one. Pass a memoised value: the hook compares by reference, so a new object on every render
+* republishes on every render.
+*
+* The host reads the sending application from `message.meta.appId`, so the payload carries no
+* application ID.
+*
+* @param context - The application context to publish, or `null` to clear it
+*
+* @example
+* ```tsx
+* import {useApplicationContext} from '@sanity/sdk-react/dashboard'
+* import {useMemo} from 'react'
+*
+* function DocumentView({documentId}: {documentId: string}) {
+*   const context = useMemo(
+*     () => ({resource: {id: 'my-project.production', type: 'dataset' as const}, document: {id: documentId}}),
+*     [documentId],
+*   )
+*   useApplicationContext(context)
+*   return <div>Editing {documentId}</div>
+* }
+* ```
+*
 * @public
-* Hook for emitting agent resource context updates to the Dashboard.
-* This allows the Agent to understand what resource the user is currently
-* interacting with (e.g., which document they're editing).
+* @category Dashboard
+*/
+function useApplicationContext(context) {
+	let $ = c(4), emit = useEmit("applications.context.update"), t0, t1;
+	$[0] !== context || $[1] !== emit ? (t0 = () => (emit(context), () => {
+		emit(null);
+	}), t1 = [emit, context], $[0] = context, $[1] = emit, $[2] = t0, $[3] = t1) : (t0 = $[2], t1 = $[3]), useEffect(t0, t1);
+}
+/**
+* @public
+* Hook for reporting the resource the user is currently interacting with (for example, which
+* document they're editing) so the Agent can understand their context. The hook reports on mount
+* and again whenever the context changes.
 *
-* The hook will automatically emit the context when it changes, and also
-* emit the initial context when the hook is first mounted.
+* The two Dashboard runtimes differ in transport, but the signature is the same:
+* - In an iframe (Comlink), it emits the `dashboard/v1/events/agent/resource/update` event.
+* - In a federated app (message bus), it publishes {@link useApplicationContext}'s
+*   `applications.context.update` topic. Reach for `useApplicationContext` directly in new code.
 *
 * @category Agent
 * @param options - The resource context options containing projectId, dataset, and optional documentId
@@ -412,6 +452,19 @@ const createRootBuilder = (Builder, ...segments) => new Builder(appendSegments(n
 * ```
 */
 function useAgentResourceContext(options) {
+	return isDashboardEnvironment() ? useBusAgentResourceContext(options) : useComlinkAgentResourceContext(options);
+}
+function useBusAgentResourceContext(t0) {
+	let $ = c(4), { projectId, dataset, documentId } = t0, t1;
+	$[0] !== dataset || $[1] !== documentId || $[2] !== projectId ? (t1 = projectId && dataset ? {
+		resource: {
+			id: `${projectId}.${dataset}`,
+			type: "dataset"
+		},
+		document: documentId ? { id: documentId } : null
+	} : null, $[0] = dataset, $[1] = documentId, $[2] = projectId, $[3] = t1) : t1 = $[3], useApplicationContext(t1);
+}
+function useComlinkAgentResourceContext(options) {
 	let $ = c(9), { projectId, dataset, documentId } = options, t0;
 	$[0] === Symbol.for("react.memo_cache_sentinel") ? (t0 = {
 		name: SDK_NODE_NAME,
@@ -446,10 +499,9 @@ function useAgentResourceContext(options) {
 		updateContext();
 	}, t3 = [updateContext], $[6] = updateContext, $[7] = t2, $[8] = t3), useEffect(t2, t3);
 }
-const 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 : getApplicationOrigin(applicationBase);
+const loadableInterfaces = ({ activeDeployment, config }, isLocal) => isLocal || config?.mfManifest !== void 0 ? activeDeployment?.interfaces ?? [] : [], loadModules = (base, interfaces) => {
+	let entry = interfaces.length === 0 ? null : getApplicationOrigin(base);
 	if (entry === null) return {
-		...application,
 		views: [],
 		webWorkers: []
 	};
@@ -457,13 +509,13 @@ const loadableInterfaces = ({ activeDeployment, config }) => config?.mfManifest
 	for (let extension of interfaces) {
 		let module = {
 			entry,
-			moduleId: `${applicationBase.id}/${extension.moduleId}`,
+			moduleId: `${base.id}/${extension.moduleId}`,
 			version: extension.version
 		};
 		if (extension.type === "worker") {
 			webWorkers.push({
 				...extension,
-				application: applicationBase,
+				application: base,
 				module
 			});
 			continue;
@@ -471,22 +523,57 @@ const loadableInterfaces = ({ activeDeployment, config }) => config?.mfManifest
 		let { type, ...view } = extension;
 		views.push({
 			...view,
-			application: applicationBase,
+			application: base,
 			module,
 			surface: type === "app" ? "window" : type
 		});
 	}
 	return {
-		...application,
 		views,
 		webWorkers
 	};
+}, toApplication = (application) => {
+	let { activeDeployment: _activeDeployment, config: _config, ...applicationBase } = application, isLocal = "local" in application;
+	return {
+		...application,
+		isLocal,
+		...loadModules({
+			...applicationBase,
+			isLocal
+		}, loadableInterfaces(application, isLocal))
+	};
+}, toInstallation = (installation) => {
+	let { application } = installation, base = {
+		id: installation.id,
+		type: "installation",
+		isLocal: !1,
+		title: application.title,
+		name: application.name,
+		reference: application.reference,
+		icon: application.icon,
+		isSingleton: !0,
+		visibility: "default",
+		slug: application.slug,
+		externalUrl: null,
+		organizationId: application.organizationId,
+		createdAt: installation.createdAt,
+		updatedAt: installation.updatedAt
+	};
+	return {
+		...base,
+		type: "installation",
+		installation,
+		...loadModules(base, installation.interfaces ?? [])
+	};
 };
 /**
-* Returns the applications available in the dashboard.
+* Returns the applications and installations available in the dashboard, in one consistent shape.
 *
-* 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.
+* Suspends until the dashboard publishes its list; a cleared list is empty. Throws a `TopicError`
+* to the nearest error boundary when the dashboard fails to load. Every entry exposes the same base
+* fields plus `views` and `webWorkers`; `type` distinguishes applications (`'studio' | 'coreApp'`)
+* from installations (`'installation'`), which also carry the raw record under `installation`.
+* `isLocal` marks applications served by a CLI dev server.
 *
 * @example
 * ```tsx
@@ -500,7 +587,10 @@ const loadableInterfaces = ({ activeDeployment, config }) => config?.mfManifest
 */
 function useApplications() {
 	let $ = c(2), applications = useTopic("applications.list"), t0;
-	return $[0] === applications ? t0 = $[1] : (t0 = applications?.map(toApplication) ?? [], $[0] = applications, $[1] = t0), t0;
+	return $[0] === applications ? t0 = $[1] : (t0 = applications?.map(_temp$2) ?? [], $[0] = applications, $[1] = t0), t0;
+}
+function _temp$2(entry) {
+	return "type" in entry ? toApplication(entry) : toInstallation(entry);
 }
 /**
 * Returns a dashboard application by id, or `null` when it is unavailable.
@@ -622,132 +712,184 @@ function useAuthToken() {
 	return useTopic("auth.token");
 }
 /**
-* Returns the signed-in user, or `null` while signed out.
+* Returns the capabilities the host provides.
 *
-* Suspends until Dashboard publishes the current user.
+* A capability is something the host provides; an application reads this record to hide its own
+* implementation of anything the host provides, or to skip publishing to a capability the host
+* does not have. A missing key means the host does not provide that capability.
+*
+* Suspends until the host publishes the record.
 *
 * @example
 * ```tsx
-* function CurrentUser() {
-*   const user = useCurrentUser()
-*   return <span>{user?.name ?? 'Signed out'}</span>
+* function UserMenu() {
+*   const {globalUserMenu} = useCapabilities()
+*   if (globalUserMenu) return null
+*   return <LocalUserMenu />
 * }
 * ```
 *
 * @public
 */
-function useCurrentUser() {
-	return useTopic("users.current");
+function useCapabilities() {
+	return useTopic("applications.capabilities");
 }
 /**
-* 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.
+* Returns the signed-in user, or `null` while signed out.
 *
-* @example Fire and forget
-* ```tsx
-* function ExpandPanel() {
-*   const setPanelMode = useEmit('panels.mode.set')
-*   return (
-*     <button onClick={() => setPanelMode({name: 'favorites', mode: 'full'})}>
-*       Expand
-*     </button>
-*   )
-* }
-* ```
+* Suspends until Dashboard publishes the current user.
 *
-* @example Await a reply with Suspense
+* @example
 * ```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>
-*   )
+* function CurrentUser() {
+*   const user = useCurrentUser()
+*   return <span>{user?.name ?? 'Signed out'}</span>
 * }
 * ```
 *
 * @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;
+function useCurrentUser() {
+	return useTopic("users.current");
 }
 /**
 * @public
 *
 * A helper hook designed to be injected into routing components for apps within the Dashboard.
-* While the Dashboard can usually handle navigation, there are special cases when you
-* are already within a target app, and need to navigate to another route inside of that app.
+* It keeps the app's router and the Dashboard in two-way sync: `navigateFn` receives the
+* navigations the Dashboard asks the app to perform, and the returned function reports the app's
+* own in-app navigations back to the Dashboard so the browser URL and the Dashboard's router
+* follow along.
 *
-* For example, your user might "favorite" a document inside of your application.
-* If they click on the Dashboard favorites item in the sidebar, and are already within your application,
-* there needs to be some way for the dashboard to signal to your application to reroute to where that document was favorited.
+* A navigation the app reports is not echoed back through `navigateFn`. The returned function is
+* referentially stable.
 *
-* This hook is intended to receive those messages, and takes a function to route to the correct path.
+* The two Dashboard runtimes differ:
+* - In an iframe (Comlink), inbound `type` may be `'push'`, `'replace'` or `'pop'`. Reporting is
+*   optional because the bridge already forwards the iframe's own `pushState`; a reported `type`
+*   is ignored and the host applies the URL as a `replace`.
+* - In a federated app (message bus), inbound `type` is `'push'` or `'replace'`; `'pop'` is never
+*   sent. Reporting is required because the app's router does not reach the host, and `type` is
+*   honoured. Until the Dashboard publishes the app's base path, reports are dropped with a
+*   console warning.
 *
 * @param navigateFn - Function to handle navigation; should accept:
 * - `path`: a string, which will be a relative path (for example, 'my-route')
 * - `type`: 'push', 'replace', or 'pop', which will be the type of navigation to perform
+* @returns A function the app calls to report its own in-app navigations to the Dashboard.
 *
 * @example
 * ```tsx
 * import {useNavigate} from '@sanity/sdk-react/dashboard'
-* import {BrowserRouter, useNavigate as useRouterNavigate} from 'react-router'
-* import {Suspense} from 'react'
+* import {useEffect} from 'react'
+* import {useLocation, useNavigate as useRouterNavigate} from 'react-router'
 *
-* function DashboardNavigationHandler() {
-*   const navigate = useRouterNavigate()
-*   useNavigate(({path, type}) => {
-*     navigate(path, {replace: type === 'replace'})
+* function DashboardNavigationSync() {
+*   const routerNavigate = useRouterNavigate()
+*   const {pathname, search, hash} = useLocation()
+*   const navigate = useNavigate(({path, type}) => {
+*     routerNavigate(path, {replace: type === 'replace'})
 *   })
+*   useEffect(() => {
+*     navigate({path: `${pathname.slice(1)}${search}${hash}`})
+*   }, [navigate, pathname, search, hash])
 *   return null
 * }
-*
-* // Wrap the component with Suspense since the hook may suspend
-* function MyApp() {
-*   return (
-*     <BrowserRouter>
-*       <Suspense>
-*         <DashboardNavigationHandler />
-*       </Suspense>
-*     </BrowserRouter>
-*   )
-* }
 * ```
 */
 function useNavigate(navigateFn) {
-	let $ = c(2), t0;
+	return isDashboardEnvironment() ? useBusNavigate(navigateFn) : useComlinkNavigate(navigateFn);
+}
+function useComlinkNavigate(navigateFn) {
+	let $ = c(4), t0;
 	$[0] === navigateFn ? t0 = $[1] : (t0 = {
 		name: SDK_NODE_NAME,
 		connectTo: SDK_CHANNEL_NAME,
 		onMessage: { "dashboard/v1/history/change-path": (data) => {
 			navigateFn(data);
 		} }
-	}, $[0] = navigateFn, $[1] = t0), useWindowConnection(t0);
+	}, $[0] = navigateFn, $[1] = t0);
+	let { sendMessage } = useWindowConnection(t0), t1;
+	return $[2] === sendMessage ? t1 = $[3] : (t1 = (t2) => {
+		let { path } = t2;
+		return sendMessage("dashboard/v1/bridge/listeners/history/update-url", { url: new URL(path, window.location.origin).href });
+	}, $[2] = sendMessage, $[3] = t1), t1;
+}
+function joinPath(base, path) {
+	let root = base.replace(/\/$/, "");
+	return path ? `${root}/${path}` : root;
+}
+function useBusNavigate(navigateFn) {
+	let $ = c(9), instance = useSanityInstance(), t0;
+	$[0] === instance ? t0 = $[1] : (t0 = requireDashboardMessageBus(instance, "navigate"), $[0] = instance, $[1] = t0);
+	let bus = t0, navigate = useEffectEvent(navigateFn), ownRequest = useRef(null), t1;
+	$[2] !== bus || $[3] !== navigate ? (t1 = () => {
+		let sub = bus.subscribe("navigation.location").pipe(pairwise(), filter((pair) => {
+			let [prev, curr] = pair;
+			return curr?.transition === null && curr.appId === bus.appId && prev?.transition?.to.appId === bus.appId && prev.transition.to.path === curr.path;
+		}), filter((t2) => {
+			let [, curr_0] = t2, suppress = curr_0.path === ownRequest.current;
+			return ownRequest.current = null, !suppress;
+		}), map(_temp$1)).subscribe((change) => navigate(change));
+		return () => sub.unsubscribe();
+	}, $[2] = bus, $[3] = navigate, $[4] = t1) : t1 = $[4];
+	let t2;
+	$[5] === bus ? t2 = $[6] : (t2 = [bus], $[5] = bus, $[6] = t2), useEffect(t1, t2);
+	let t3;
+	return $[7] === bus ? t3 = $[8] : (t3 = (t4) => {
+		let { path, type: t5 } = t4, type = t5 === void 0 ? "push" : t5, own = path.replace(/^\//, "");
+		ownRequest.current = own;
+		let clearIfStale = () => {
+			ownRequest.current === own && (ownRequest.current = null);
+		};
+		bus.query("applications.base-path").then((base) => {
+			if (!base.ok) throw new TopicError$1("applications.base-path");
+			return bus.emit("navigation.location.update", {
+				url: joinPath(base.value, own),
+				history: type
+			});
+		}).then((reply) => {
+			reply.ok || clearIfStale();
+		}, (error) => {
+			console.warn("Failed to report navigation to the Dashboard", error), clearIfStale();
+		});
+	}, $[7] = bus, $[8] = t3), t3;
+}
+function _temp$1(t0) {
+	let [prev_0, curr_1] = t0;
+	return {
+		path: curr_1.path,
+		type: prev_0.transition.navigationType
+	};
+}
+function useComlinkStudioNavigator(documentHandle) {
+	let $ = c(5), t0;
+	$[0] === Symbol.for("react.memo_cache_sentinel") ? (t0 = {
+		name: SDK_NODE_NAME,
+		connectTo: SDK_CHANNEL_NAME
+	}, $[0] = t0) : t0 = $[0];
+	let { sendMessage } = useWindowConnection(t0), t1;
+	return $[1] !== documentHandle.documentId || $[2] !== documentHandle.documentType || $[3] !== sendMessage ? (t1 = (workspace) => {
+		let message = {
+			type: "dashboard/v1/bridge/navigate-to-resource",
+			data: {
+				resourceId: workspace.id,
+				resourceType: "studio",
+				path: `/intent/edit/id=${documentHandle.documentId};type=${documentHandle.documentType}`
+			}
+		};
+		sendMessage(message.type, message.data);
+	}, $[1] = documentHandle.documentId, $[2] = documentHandle.documentType, $[3] = sendMessage, $[4] = t1) : t1 = $[4], t1;
+}
+function useBusStudioNavigator(documentHandle) {
+	let $ = c(4), navigate = useEmit("navigation.location.update"), t0;
+	return $[0] !== documentHandle.documentId || $[1] !== documentHandle.documentType || $[2] !== navigate ? (t0 = (workspace) => {
+		let url = urlFor.studios(workspace.userApplicationId).workspace(workspace.name).intent("edit", {
+			id: documentHandle.documentId,
+			type: documentHandle.documentType
+		}).url();
+		navigate({ url }).then(_temp, _temp2);
+	}, $[0] = documentHandle.documentId, $[1] = documentHandle.documentType, $[2] = navigate, $[3] = t0) : t0 = $[3], t0;
 }
 /**
 * @public
@@ -757,6 +899,9 @@ function useNavigate(navigateFn) {
 * Uses the `projectId` and `dataset` properties of the {@link DocumentHandle} you provide to resolve the correct Studio.
 * This will only work if you have deployed a studio with a workspace with this `projectId` / `dataset` combination.
 *
+* Works in both Dashboard runtimes: it sends the navigation over the Comlink connection in the
+* iframe runtime and over the message bus in the federated runtime.
+*
 * @remarks If you write your own Document Handle to pass to this hook (as opposed to a Document Handle generated by another hook),
 * it must include values for `documentId`, `documentType`, `projectId`, and `dataset`.
 *
@@ -794,41 +939,38 @@ function useNavigate(navigateFn) {
 * }
 * ```
 */
+function _temp2(error) {
+	console.warn("Failed to navigate to studio document", error);
+}
+function _temp(reply) {
+	reply.ok === !1 && console.warn("Failed to navigate to studio document", reply);
+}
 function useNavigateToStudioDocument(documentHandle, preferredStudioUrl) {
-	let $ = c(8), { workspacesByProjectIdAndDataset } = useStudioWorkspacesByProjectIdDataset(), t0;
-	$[0] === Symbol.for("react.memo_cache_sentinel") ? (t0 = {
-		name: SDK_NODE_NAME,
-		connectTo: SDK_CHANNEL_NAME
-	}, $[0] = t0) : t0 = $[0];
-	let { sendMessage } = useWindowConnection(t0), t1;
-	$[1] !== documentHandle || $[2] !== preferredStudioUrl || $[3] !== sendMessage || $[4] !== workspacesByProjectIdAndDataset ? (t1 = () => {
+	let { workspacesByProjectIdAndDataset } = useStudioWorkspacesByProjectIdDataset(), sendToWorkspace = isDashboardEnvironment() ? useBusStudioNavigator(documentHandle) : useComlinkStudioNavigator(documentHandle);
+	return { navigateToStudioDocument: useCallback(() => {
 		let { projectId, dataset } = documentHandle;
 		if (!projectId || !dataset) {
 			console.warn("Project ID and dataset are required to navigate to a studio document");
 			return;
 		}
-		let workspace;
-		if (preferredStudioUrl) workspace = [...workspacesByProjectIdAndDataset[`${projectId}:${dataset}`] || [], ...workspacesByProjectIdAndDataset["NO_PROJECT_ID:NO_DATASET"] || []].find((w) => w.url === preferredStudioUrl);
-		else {
-			let workspaces = workspacesByProjectIdAndDataset[`${projectId}:${dataset}`];
-			workspaces?.length > 1 && (console.warn("Multiple workspaces found for document and no preferred studio url", documentHandle), console.warn("Using the first one", workspaces[0])), workspace = workspaces?.[0];
-		}
+		let workspace = resolveWorkspace(documentHandle, workspacesByProjectIdAndDataset, preferredStudioUrl);
 		if (!workspace) {
 			console.warn(`No workspace found for document with projectId: ${projectId} and dataset: ${dataset}${preferredStudioUrl ? ` or with preferred studio url: ${preferredStudioUrl}` : ""}`);
 			return;
 		}
-		let message = {
-			type: "dashboard/v1/bridge/navigate-to-resource",
-			data: {
-				resourceId: workspace.id,
-				resourceType: "studio",
-				path: `/intent/edit/id=${documentHandle.documentId};type=${documentHandle.documentType}`
-			}
-		};
-		sendMessage(message.type, message.data);
-	}, $[1] = documentHandle, $[2] = preferredStudioUrl, $[3] = sendMessage, $[4] = workspacesByProjectIdAndDataset, $[5] = t1) : t1 = $[5];
-	let navigateToStudioDocument = t1, t2;
-	return $[6] === navigateToStudioDocument ? t2 = $[7] : (t2 = { navigateToStudioDocument }, $[6] = navigateToStudioDocument, $[7] = t2), t2;
+		sendToWorkspace(workspace);
+	}, [
+		documentHandle,
+		workspacesByProjectIdAndDataset,
+		preferredStudioUrl,
+		sendToWorkspace
+	]) };
+}
+function resolveWorkspace(documentHandle, workspacesByProjectIdAndDataset, preferredStudioUrl) {
+	let { projectId, dataset } = documentHandle, key = `${projectId}:${dataset}`;
+	if (preferredStudioUrl) return [...workspacesByProjectIdAndDataset[key] || [], ...workspacesByProjectIdAndDataset["NO_PROJECT_ID:NO_DATASET"] || []].find((w) => w.url === preferredStudioUrl);
+	let workspaces = workspacesByProjectIdAndDataset[key];
+	return workspaces && workspaces.length > 1 && (console.warn("Multiple workspaces found for document and no preferred studio url", documentHandle), console.warn("Using the first one", workspaces[0])), workspaces?.[0];
 }
 const remoteClientStates = /* @__PURE__ */ new WeakMap();
 /** Returns the instance's remote client state, creating it on first use. @internal */
@@ -925,6 +1067,6 @@ function useComlinkWindowTitle(viewTitle) {
 		};
 	}, [viewTitle, appTitle]);
 }
-export { MessageBusError, DashboardTokenRefreshProvider as TokenRefreshProvider, TopicError, UrlBuilder, connectMessageBus, createRemoteInstance, urlFor, useAgentResourceContext, useApplication, useApplicationBasePath, useApplicationConfig, useApplicationConfigs, useApplicationForegroundId, useApplications, useAuthToken, useCurrentUser, useEmit, useNavigate, useNavigateToStudioDocument, useOrganizationId, useRemoteClient, useTopic, useWindowTitle };
+export { MessageBusError, DashboardTokenRefreshProvider as TokenRefreshProvider, TopicError, UrlBuilder, capabilities, connectMessageBus, createRemoteInstance, urlFor, useAgentResourceContext, useApplication, useApplicationBasePath, useApplicationConfig, useApplicationConfigs, useApplicationContext, useApplicationForegroundId, useApplications, useAuthToken, useCapabilities, useCurrentUser, useEmit, useNavigate, useNavigateToStudioDocument, useOrganizationId, useRemoteClient, useTopic, useWindowTitle };
 
 //# sourceMappingURL=dashboard.js.map