@cardstack/boxel-cli 0.13.0-unstable.4 → 0.13.0-unstable.5

package/bundled-test-harness/assets/dashboard-get-started-test-DOGPzGoA.js

@@ -0,0 +1,374 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Kn as APP_BOXEL_MESSAGE_MSGTYPE } from "./runtime-common-BTaLJEw-.js";
+import { M as waitUntil, T as settled, a as find, d as click, i as findAll, o as waitFor } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { D as realmConfigCardJSON, j as setupAcceptanceTestRealm, st as visitOperatorMode } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { a as markUpdated, c as overrideRealmInfo, f as realmURL, g as sharedRealmURL, h as setupMoreWorkspaces, i as markPublishable, l as ownedRealmURL, m as setupDashboardTest, o as nameFromTip, r as markHosted, s as operatorModeState } from "./dashboard-ir2bakJS.js";
+//#region tests/acceptance/dashboard-get-started-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Acceptance | dashboard get started", function(hooks) {
+	let mockMatrixUtils = setupDashboardTest(hooks);
+	const GET_STARTED = "[data-test-get-started]";
+	const BUTTON = "[data-test-get-started-button]";
+	function countText() {
+		return (find("[data-test-get-started-count]")?.textContent ?? "").replace(/\s+/g, " ").trim();
+	}
+	function stepDone(id) {
+		return find(`[data-test-get-started-step="${id}"]`)?.getAttribute("data-test-get-started-step-done");
+	}
+	async function reopenDashboard() {
+		operatorModeState().workspaceChooserOpened = false;
+		await settled();
+		operatorModeState().workspaceChooserOpened = true;
+		await waitFor("[data-test-dashboard-greeting]");
+	}
+	async function visitAsNewUser() {
+		await visitOperatorMode({ workspaceChooserOpened: true });
+		getService("recent-cards-service").resetState();
+		await mockMatrixUtils.setDashboardStateFromAnotherDevice({});
+		await settled();
+		await reopenDashboard();
+	}
+	async function openSteps() {
+		await click(BUTTON);
+	}
+	async function openBoxelAiSession() {
+		await click("[data-test-get-started-action=\"ask-ai\"]");
+		let matrixService = getService("matrix-service");
+		await waitUntil(() => matrixService.currentRoomId);
+		await settled();
+		return matrixService.currentRoomId;
+	}
+	function sendMessage(roomId) {
+		mockMatrixUtils.simulateRemoteMessage(roomId, "@testuser:localhost", {
+			body: "Make me a card for tracking tasks",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html"
+		});
+	}
+	(0, import_qunit.test)("a new account finds the steps closed, and the button opens them right after the header", async function(assert) {
+		await visitAsNewUser();
+		assert.dom(BUTTON).hasText("Get started");
+		assert.dom(BUTTON).hasAttribute("aria-expanded", "false");
+		assert.dom(GET_STARTED).doesNotExist();
+		await openSteps();
+		assert.dom(BUTTON).hasAttribute("aria-expanded", "true");
+		assert.dom(GET_STARTED).exists();
+		assert.dom("[data-test-get-started-count]").hasText("0 of 3 done");
+		assert.deepEqual(findAll("[data-test-get-started-step]").map((el) => el.getAttribute("data-test-get-started-step")), [
+			"open-card",
+			"ask-ai",
+			"publish"
+		]);
+		assert.dom("[data-test-get-started-step-done=\"true\"]").doesNotExist();
+		assert.strictEqual(find("[data-test-dashboard-greeting]").closest("header").nextElementSibling, find(GET_STARTED), "the steps open right after the header");
+	});
+	(0, import_qunit.test)("the button closes the steps it opened", async function(assert) {
+		await visitAsNewUser();
+		await openSteps();
+		await click(BUTTON);
+		assert.dom(GET_STARTED).doesNotExist();
+		assert.dom(BUTTON).hasAttribute("aria-expanded", "false");
+	});
+	(0, import_qunit.test)("the minimize button folds the list to its progress and next step, and expands it again", async function(assert) {
+		const TOGGLE = "[data-test-get-started-toggle]";
+		await visitAsNewUser();
+		await openSteps();
+		getService("recent-cards-service").add(`${realmURL}index`);
+		await settled();
+		assert.strictEqual(nameFromTip(TOGGLE), "Minimize steps");
+		await click(TOGGLE);
+		assert.dom(GET_STARTED).exists("the list stays open, folded");
+		assert.dom("[data-test-get-started-step]").doesNotExist();
+		assert.strictEqual(countText(), "1 of 3 done · Next: Ask Boxel AI Assistant to build something");
+		assert.strictEqual(nameFromTip(TOGGLE), "Expand steps");
+		assert.dom(TOGGLE).hasAttribute("aria-expanded", "false");
+		assert.dom(BUTTON).hasAttribute("aria-expanded", "true");
+		await click(TOGGLE);
+		assert.dom("[data-test-get-started-step]").exists({ count: 3 });
+		assert.strictEqual(nameFromTip(TOGGLE), "Minimize steps");
+		assert.dom(TOGGLE).hasAttribute("aria-expanded", "true");
+	});
+	(0, import_qunit.test)("reopened from the button, a folded list shows its steps again", async function(assert) {
+		await visitAsNewUser();
+		await openSteps();
+		await click("[data-test-get-started-toggle]");
+		await click(BUTTON);
+		await click(BUTTON);
+		assert.dom("[data-test-get-started-step]").exists({ count: 3 });
+	});
+	(0, import_qunit.test)("a step done while the steps are open keeps them open", async function(assert) {
+		await visitAsNewUser();
+		await openSteps();
+		await mockMatrixUtils.setDashboardStateFromAnotherDevice({ agentSetup: { claude: 1 } });
+		await settled();
+		assert.dom("[data-test-get-started-count]").hasText("1 of 3 done");
+		assert.strictEqual(stepDone("agent"), "true");
+		assert.strictEqual(stepDone("open-card"), "false");
+	});
+	(0, import_qunit.test)("opened steps are closed again when the dashboard reopens", async function(assert) {
+		await visitAsNewUser();
+		await openSteps();
+		getService("recent-cards-service").add(`${realmURL}index`);
+		await settled();
+		await reopenDashboard();
+		assert.dom(GET_STARTED).doesNotExist();
+		assert.dom(BUTTON).hasAttribute("aria-expanded", "false");
+		await openSteps();
+		assert.strictEqual(stepDone("open-card"), "true");
+	});
+	(0, import_qunit.test)("opening a card and publishing a workspace tick their steps", async function(assert) {
+		await visitAsNewUser();
+		await openSteps();
+		getService("recent-cards-service").add(`${realmURL}index`);
+		markHosted(realmURL);
+		await settled();
+		assert.strictEqual(stepDone("open-card"), "true");
+		assert.strictEqual(stepDone("publish"), "true");
+		assert.strictEqual(stepDone("ask-ai"), "false");
+		assert.dom("[data-test-get-started-publish-unavailable]").doesNotExist("a done step does not say what publishing needs");
+	});
+	(0, import_qunit.test)("owning only workspaces that cannot be published, the publish step says so instead of offering a button", async function(assert) {
+		await visitAsNewUser();
+		await openSteps();
+		assert.dom("[data-test-get-started-action=\"publish\"]").doesNotExist();
+		assert.dom("[data-test-get-started-publish-unavailable]").hasText("None of your workspaces can be published. Create a new one to publish it.");
+	});
+	(0, import_qunit.test)("owning no workspace, the publish step says publishing needs one", async function(assert) {
+		mockMatrixUtils.setRealmPermissions({ [realmURL]: ["read", "write"] });
+		await visitAsNewUser();
+		await openSteps();
+		assert.dom("[data-test-get-started-action=\"publish\"]").doesNotExist();
+		assert.dom("[data-test-get-started-publish-unavailable]").hasText("Publishing needs a workspace you own. Create one to publish it.");
+	});
+	(0, import_qunit.test)("the publish step's note waits for the info of the workspaces the user owns", async function(assert) {
+		await visitAsNewUser();
+		let resource = getService("realm").realms.get(realmURL);
+		let info = resource.info;
+		resource.fetchInfo = () => new Promise(() => {});
+		resource.info = void 0;
+		await openSteps();
+		assert.dom("[data-test-get-started-step=\"publish\"]").exists();
+		assert.dom("[data-test-get-started-publish-unavailable]").doesNotExist("no note while the info loads");
+		delete resource.fetchInfo;
+		resource.info = info;
+		await settled();
+		assert.dom("[data-test-get-started-publish-unavailable]").exists("the note shows once the info has loaded");
+	});
+	(0, import_qunit.module)("with workspaces to publish", function(hooks) {
+		setupMoreWorkspaces(hooks, mockMatrixUtils);
+		const PUBLISH_ACTION = "[data-test-get-started-action=\"publish\"]";
+		const PUBLISH_MODAL = "[data-test-publish-realm-modal]";
+		const MENU_ITEMS = "[data-test-pretui-menu-panel] [role=\"menuitem\"]";
+		(0, import_qunit.test)("with one workspace to publish, the publish step opens it in host mode with the publish dialog", async function(assert) {
+			await visitAsNewUser();
+			markPublishable(ownedRealmURL);
+			markPublishable(sharedRealmURL);
+			await settled();
+			await openSteps();
+			await waitFor(PUBLISH_ACTION);
+			await click(PUBLISH_ACTION);
+			await waitFor(PUBLISH_MODAL);
+			assert.dom("[data-test-host-submode]").exists();
+			assert.dom(PUBLISH_MODAL).containsText("workspace-b/");
+		});
+		(0, import_qunit.test)("the publish step keeps its button once a workspace is published", async function(assert) {
+			await visitAsNewUser();
+			markPublishable(ownedRealmURL);
+			markHosted(ownedRealmURL);
+			await settled();
+			await openSteps();
+			await waitFor(PUBLISH_ACTION);
+			assert.strictEqual(stepDone("publish"), "true");
+			await click(PUBLISH_ACTION);
+			await waitFor(PUBLISH_MODAL);
+			assert.dom("[data-test-host-submode]").exists();
+			assert.dom(PUBLISH_MODAL).containsText("workspace-b/");
+		});
+		(0, import_qunit.test)("workspaces that share a name are told apart by their address in the menu", async function(assert) {
+			await visitAsNewUser();
+			markPublishable(realmURL);
+			markPublishable(ownedRealmURL);
+			overrideRealmInfo(realmURL, { name: "Workspace B" });
+			let now = Date.now();
+			markUpdated(realmURL, /* @__PURE__ */ new Date(now - 6e4));
+			markUpdated(ownedRealmURL, new Date(now));
+			await settled();
+			await openSteps();
+			await waitFor(PUBLISH_ACTION);
+			await click(PUBLISH_ACTION);
+			assert.deepEqual(findAll(MENU_ITEMS).map((item) => item.textContent?.trim()), ["Workspace B (workspace-b)", "Workspace B (workspace-a)"]);
+		});
+		(0, import_qunit.test)("workspaces that share a name and the last part of their address are told apart by the whole address", async function(assert) {
+			const otherRealmURL = "http://test-realm/otheruser/workspace-b/";
+			const permissions = [
+				"read",
+				"write",
+				"realm-owner"
+			];
+			await setupAcceptanceTestRealm({
+				realmURL: otherRealmURL,
+				mockMatrixUtils,
+				permissions: { "@testuser:localhost": [...permissions] },
+				contents: { "realm.json": realmConfigCardJSON({ name: "Workspace B" }) }
+			});
+			mockMatrixUtils.setRealmSessionPermissions(otherRealmURL, [...permissions]);
+			mockMatrixUtils.setActiveRealms([
+				realmURL,
+				ownedRealmURL,
+				sharedRealmURL,
+				otherRealmURL
+			]);
+			await visitAsNewUser();
+			markPublishable(ownedRealmURL);
+			markPublishable(otherRealmURL);
+			let now = Date.now();
+			markUpdated(otherRealmURL, /* @__PURE__ */ new Date(now - 6e4));
+			markUpdated(ownedRealmURL, new Date(now));
+			await settled();
+			await openSteps();
+			await waitFor(PUBLISH_ACTION);
+			await click(PUBLISH_ACTION);
+			assert.deepEqual(findAll(MENU_ITEMS).map((item) => item.textContent?.trim()), ["Workspace B (test-realm/testuser/workspace-b)", "Workspace B (test-realm/otheruser/workspace-b)"]);
+		});
+		(0, import_qunit.test)("with several workspaces to publish, the publish step asks which, most recently updated first", async function(assert) {
+			await visitAsNewUser();
+			let now = Date.now();
+			for (let url of [
+				realmURL,
+				ownedRealmURL,
+				sharedRealmURL
+			]) markPublishable(url);
+			markUpdated(realmURL, /* @__PURE__ */ new Date(now - 6e4));
+			markUpdated(ownedRealmURL, /* @__PURE__ */ new Date(now - 3e4));
+			markUpdated(sharedRealmURL, new Date(now));
+			await settled();
+			await openSteps();
+			await waitFor(PUBLISH_ACTION);
+			assert.dom(`${PUBLISH_ACTION} [data-test-get-started-publish-chevron]`).hasAttribute("data-test-get-started-publish-chevron", "down");
+			await click(PUBLISH_ACTION);
+			assert.dom(`${PUBLISH_ACTION} [data-test-get-started-publish-chevron]`).hasAttribute("data-test-get-started-publish-chevron", "up", "the chevron turns up while the menu is open");
+			assert.deepEqual(findAll(MENU_ITEMS).map((item) => item.textContent?.trim()), ["Workspace B", "Workspace A"]);
+			await click(findAll(MENU_ITEMS)[1]);
+			await waitFor(PUBLISH_MODAL);
+			assert.dom("[data-test-host-submode]").exists();
+			assert.dom(PUBLISH_MODAL).containsText("workspace-a/");
+		});
+	});
+	(0, import_qunit.test)("asking Boxel AI Assistant something ticks the ask step, and opening a session does not", async function(assert) {
+		await visitAsNewUser();
+		await openSteps();
+		let roomId = await openBoxelAiSession();
+		assert.strictEqual(stepDone("ask-ai"), "false", "an empty session has not been asked anything");
+		sendMessage(roomId);
+		await waitUntil(() => countText() === "1 of 3 done");
+		assert.strictEqual(stepDone("ask-ai"), "true");
+	});
+	(0, import_qunit.test)("a session the bot has renamed ticks the ask step, before any message loads", async function(assert) {
+		await visitAsNewUser();
+		await openSteps();
+		let roomId = await openBoxelAiSession();
+		mockMatrixUtils.setRoomState(roomId, "m.room.name", { name: "Task tracker" });
+		await waitUntil(() => countText() === "1 of 3 done");
+		assert.strictEqual(stepDone("ask-ai"), "true");
+	});
+	(0, import_qunit.test)("with every step done, neither the button nor the steps show", async function(assert) {
+		await visitAsNewUser();
+		await openSteps();
+		assert.dom(GET_STARTED).exists();
+		await mockMatrixUtils.setDashboardStateFromAnotherDevice({
+			agent: "claude",
+			agentSetup: { claude: 1 }
+		});
+		getService("recent-cards-service").add(`${realmURL}index`);
+		markHosted(realmURL);
+		await settled();
+		assert.dom(GET_STARTED).doesNotExist("nothing left to start");
+		assert.dom(BUTTON).doesNotExist();
+		let matrixService = getService("matrix-service");
+		await waitUntil(() => matrixService.dashboardState.onboardingDismissed);
+		assert.dom("[data-test-get-started-dismissed]").doesNotExist("finishing offers no undo");
+		assert.true(mockMatrixUtils.getDashboardState().onboardingDismissed, "the dismissal is stored");
+		getService("recent-cards-service").resetState();
+		await settled();
+		assert.dom(BUTTON).doesNotExist("a step that reads as undone later does not bring it back");
+		await reopenDashboard();
+		assert.dom(BUTTON).doesNotExist("still gone after reopening");
+	});
+	(0, import_qunit.test)("picking a coding agent puts the agent step in place of the ask step", async function(assert) {
+		await visitAsNewUser();
+		await openSteps();
+		await mockMatrixUtils.setDashboardStateFromAnotherDevice({ agent: "codex" });
+		await settled();
+		assert.dom("[data-test-get-started-count]").hasText("0 of 3 done");
+		assert.deepEqual(findAll("[data-test-get-started-step]").map((el) => el.getAttribute("data-test-get-started-step")), [
+			"open-card",
+			"agent",
+			"publish"
+		]);
+		assert.strictEqual(stepDone("agent"), "false");
+	});
+	(0, import_qunit.test)("the agent step's action shows the Agents section", async function(assert) {
+		await visitAsNewUser();
+		await openSteps();
+		await mockMatrixUtils.setDashboardStateFromAnotherDevice({ agent: "codex" });
+		await settled();
+		await click("[data-test-get-started-action=\"agent\"]");
+		assert.dom("[data-test-section-rail-entry=\"agents\"]").hasAttribute("aria-current", "location");
+	});
+	(0, import_qunit.test)("Dismiss saves that and leaves a note whose Undo brings the list back", async function(assert) {
+		await visitAsNewUser();
+		await openSteps();
+		await click("[data-test-get-started-dismiss]");
+		let matrixService = getService("matrix-service");
+		assert.dom(GET_STARTED).doesNotExist();
+		assert.dom("[data-test-get-started-dismissed]").containsText("Get started won’t show again.");
+		assert.true(matrixService.dashboardState.onboardingDismissed);
+		assert.dom("[data-test-get-started-undo-dismiss]").isFocused("focus moves to Undo, since Dismiss is gone");
+		assert.dom(BUTTON).doesNotExist("dismissed, the button goes too");
+		await click("[data-test-get-started-undo-dismiss]");
+		assert.dom("[data-test-get-started-dismissed]").doesNotExist();
+		assert.dom("[data-test-get-started-step]").exists({ count: 3 });
+		assert.false(matrixService.dashboardState.onboardingDismissed);
+		assert.dom(BUTTON).exists("Undo brings the button back");
+		assert.dom("[data-test-get-started-dismiss]").isFocused();
+	});
+	(0, import_qunit.test)("an undo from another device clears the dismissed note", async function(assert) {
+		await visitAsNewUser();
+		await openSteps();
+		await click("[data-test-get-started-dismiss]");
+		assert.dom("[data-test-get-started-dismissed]").exists();
+		await mockMatrixUtils.setDashboardStateFromAnotherDevice({ onboardingDismissed: false });
+		await settled();
+		assert.dom("[data-test-get-started-dismissed]").doesNotExist();
+		assert.dom(BUTTON).hasAttribute("aria-expanded", "false");
+		await mockMatrixUtils.setDashboardStateFromAnotherDevice({ onboardingDismissed: true });
+		await settled();
+		assert.dom("[data-test-get-started-dismissed]").doesNotExist("a dismissal made elsewhere brings no note here");
+	});
+	(0, import_qunit.test)("a dismissal from another device hides the open steps and the button", async function(assert) {
+		await visitAsNewUser();
+		await openSteps();
+		assert.dom(GET_STARTED).exists();
+		await mockMatrixUtils.setDashboardStateFromAnotherDevice({ onboardingDismissed: true });
+		await settled();
+		assert.dom(GET_STARTED).doesNotExist();
+		assert.dom(BUTTON).doesNotExist();
+		assert.dom("[data-test-get-started-dismissed]").doesNotExist();
+		await mockMatrixUtils.setDashboardStateFromAnotherDevice({ onboardingDismissed: false });
+		await settled();
+		assert.dom(BUTTON).hasAttribute("aria-expanded", "false");
+		assert.dom(GET_STARTED).doesNotExist("an undo made elsewhere leaves the steps closed");
+	});
+	(0, import_qunit.test)("once dismissed, neither the steps nor the button show on open", async function(assert) {
+		await visitAsNewUser();
+		await mockMatrixUtils.setDashboardStateFromAnotherDevice({ onboardingDismissed: true });
+		await settled();
+		await reopenDashboard();
+		assert.dom(GET_STARTED).doesNotExist();
+		assert.dom(BUTTON).doesNotExist();
+		assert.dom("[data-test-get-started-dismissed]").doesNotExist();
+	});
+});
+//#endregion

package/bundled-test-harness/assets/dashboard-ir2bakJS.js

@@ -0,0 +1,142 @@
+import "./chunk-Rp0pCe6z.js";
+import { n as TrackedObject } from "./dist-B9tGPKZz.js";
+import { a as find, c as triggerKeyEvent, d as click, i as findAll } from "./dist-BOAdzfkP.js";
+import { Ct as getTestRealmRegistry, D as realmConfigCardJSON, F as setupLocalIndexing, L as setupRealmCacheTeardown, ct as setupApplicationTest, j as setupAcceptanceTestRealm, mt as setupAuthEndpoints, t as setupMockMatrix, z as setupUserSubscription } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/helpers/dashboard.ts
+var realmURL = "http://test-realm/testuser/workspace-a/";
+async function clickScopeOption(value) {
+	let label = find(`[data-test-dashboard-filter] [data-test-pretui-segmented-option="${value}"]`)?.closest("label");
+	if (!label) throw new Error(`no label for the ${value} scope option`);
+	await click(label);
+}
+function markHosted(url, lastPublishedAt = { "https://published.example.com/": String(Date.now()) }) {
+	let realmResource = getService("realm").realms.get(url);
+	realmResource.info = new TrackedObject({
+		...realmResource.info,
+		lastPublishedAt
+	});
+}
+function markUpdated(url, updatedAt) {
+	let realmResource = getService("realm").realms.get(url);
+	realmResource.info = new TrackedObject({
+		...realmResource.info,
+		updatedAt: updatedAt.toISOString()
+	});
+}
+function overrideRealmInfo(url, change) {
+	let realm = getTestRealmRegistry().get(url)?.realm;
+	if (!realm) throw new Error(`no test realm at ${url}`);
+	let getRealmInfo = realm.getRealmInfo.bind(realm);
+	realm.getRealmInfo = async () => ({
+		...await getRealmInfo(),
+		...change
+	});
+	let realmResource = getService("realm").realms.get(url);
+	realmResource.info = new TrackedObject({
+		...realmResource.info,
+		...change
+	});
+}
+function markPublishable(url) {
+	overrideRealmInfo(url, { publishable: true });
+}
+var ownedRealmURL = "http://test-realm/testuser/workspace-b/";
+var sharedRealmURL = "http://test-realm/testuser/workspace-c/";
+function setupMoreWorkspaces(hooks, mockMatrixUtils) {
+	hooks.beforeEach(async function() {
+		for (let [url, name, permissions] of [[
+			ownedRealmURL,
+			"Workspace B",
+			[
+				"read",
+				"write",
+				"realm-owner"
+			]
+		], [
+			sharedRealmURL,
+			"Workspace C",
+			["read", "write"]
+		]]) {
+			await setupAcceptanceTestRealm({
+				realmURL: url,
+				mockMatrixUtils,
+				permissions: { "@testuser:localhost": [...permissions] },
+				contents: { "realm.json": realmConfigCardJSON({ name }) }
+			});
+			mockMatrixUtils.setRealmSessionPermissions(url, [...permissions]);
+		}
+		mockMatrixUtils.setRealmSessionPermissions(realmURL, [
+			"read",
+			"write",
+			"realm-owner"
+		]);
+		mockMatrixUtils.setActiveRealms([
+			realmURL,
+			ownedRealmURL,
+			sharedRealmURL
+		]);
+	});
+}
+function nameFromTip(selector) {
+	let id = find(selector)?.getAttribute("aria-labelledby") ?? "";
+	return document.getElementById(id)?.textContent?.trim();
+}
+function descriptionOf(selector) {
+	return (find(selector)?.getAttribute("aria-describedby")?.split(" ") ?? []).map((id) => document.getElementById(id)?.textContent?.trim());
+}
+async function pressKey(key) {
+	let target = document.activeElement;
+	if (!(target instanceof HTMLElement)) throw new Error("nothing has focus");
+	await triggerKeyEvent(target, "keydown", key);
+}
+function sectionOrder() {
+	return findAll("[data-test-dashboard-section]").map((section) => section.getAttribute("data-test-dashboard-section"));
+}
+function railOrder() {
+	return findAll("[data-test-section-rail-entry]").map((entry) => entry.getAttribute("data-test-section-rail-entry"));
+}
+function operatorModeState() {
+	return getService("operator-mode-state-service");
+}
+function setupDashboardTest(hooks, { matrix = {
+	loggedInAs: "@testuser:localhost",
+	displayName: "Ada Lovelace",
+	activeRealms: [realmURL],
+	dashboardState: {
+		agent: "codex",
+		agentSetup: { codex: 2 }
+	}
+}, realms = [{
+	url: realmURL,
+	name: "Workspace A"
+}], authEndpoints = true, beforeRealms, onRealm } = {}) {
+	setupApplicationTest(hooks);
+	setupLocalIndexing(hooks);
+	setupRealmCacheTeardown(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, matrix);
+	beforeRealms?.(hooks);
+	hooks.beforeEach(async function() {
+		setupUserSubscription();
+		if (authEndpoints) setupAuthEndpoints();
+		for (let { url, name, permissions, contents } of realms) {
+			let { realm } = await setupAcceptanceTestRealm({
+				realmURL: url,
+				mockMatrixUtils,
+				permissions: permissions ?? { "@testuser:localhost": [
+					"read",
+					"write",
+					"realm-owner"
+				] },
+				contents: {
+					"realm.json": realmConfigCardJSON({ name }),
+					...contents
+				}
+			});
+			onRealm?.(realm, url);
+		}
+	});
+	return mockMatrixUtils;
+}
+//#endregion
+export { markUpdated as a, overrideRealmInfo as c, railOrder as d, realmURL as f, sharedRealmURL as g, setupMoreWorkspaces as h, markPublishable as i, ownedRealmURL as l, setupDashboardTest as m, descriptionOf as n, nameFromTip as o, sectionOrder as p, markHosted as r, operatorModeState as s, clickScopeOption as t, pressKey as u };