@cardstack/boxel-cli 0.3.2-unstable.58 → 0.3.2-unstable.60

package/bundled-test-harness/assets/host-submode-test-DHd0x-6x.js

@@ -0,0 +1,904 @@
+import { s as __toESM } from "./chunk-CGdGNDIi.js";
+import { Gr as param, Kr as query, Xn as testRealmInfo, Zn as testRealmURL, ca as Deferred, vi as baseRealm } from "./runtime-common-C7uLt5dN.js";
+import { n as TrackedObject } from "./dist-DLRXwlqz.js";
+import { I as waitUntil, d as click, l as triggerEvent, o as waitFor, s as fillIn } from "./dist-D1U_uSwt.js";
+import { t as require_qunit } from "./qunit-Cqwmt9Vl.js";
+import { r as getService } from "./dist-CY3T64Hs.js";
+import { D as setupAcceptanceTestRealm, M as setupOnSave, a as SYSTEM_CARD_FIXTURE_CONTENTS, j as setupLocalIndexing, nt as setupApplicationTest, t as setupMockMatrix, tt as visitOperatorMode, v as getDbAdapter, w as realmConfigCardJSON } from "./mock-matrix-BhFWlMMr.js";
+import { mt as setupBaseRealm, s as CardsGrid } from "./base-realm-DpSTsZxD.js";
+import { t as viewCardDemoCardSource } from "./view-card-demo-CSIVYD3T.js";
+//#region tests/acceptance/host-submode-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var personCardSource = `
+  import { contains, containsMany, field, linksToMany, CardDef, Component } from "https://cardstack.com/base/card-api";
+  import StringField from "https://cardstack.com/base/string";
+
+  export class Person extends CardDef {
+    static displayName = 'Person';
+    @field firstName = contains(StringField);
+    @field lastName = contains(StringField);
+    @field cardTitle = contains(StringField, {
+      computeVia: function (this: Person) {
+        return [this.firstName, this.lastName].filter(Boolean).join(' ');
+      },
+    });
+    static isolated = class Isolated extends Component<typeof this> {
+      <template>
+          <p>Title: <@fields.cardTitle /></p>
+      </template>
+    };
+  }
+`;
+function withUpdatedTestRealmInfo(updates) {
+	let realmResource = getService("realm").realms.get(testRealmURL);
+	if (!realmResource) throw new Error("Test realm resource is not registered");
+	let previousInfo = realmResource.info;
+	realmResource.info = new TrackedObject({
+		...previousInfo ? { ...previousInfo } : { ...testRealmInfo },
+		...updates
+	});
+	return () => {
+		realmResource.info = previousInfo;
+	};
+}
+(0, import_qunit.module)("Acceptance | host submode", function(hooks) {
+	setupApplicationTest(hooks);
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [baseRealm.url, testRealmURL]
+	});
+	setupBaseRealm(hooks);
+	let realmContents;
+	hooks.beforeEach(function() {
+		realmContents = {
+			...SYSTEM_CARD_FIXTURE_CONTENTS,
+			"index.json": new CardsGrid(),
+			"realm.json": realmConfigCardJSON({
+				name: "Test Workspace B",
+				backgroundURL: "https://i.postimg.cc/VNvHH93M/pawel-czerwinski-Ly-ZLa-A5jti-Y-unsplash.jpg",
+				iconURL: "https://i.postimg.cc/L8yXRvws/icon.png"
+			}),
+			"person.gts": personCardSource,
+			"view-card-demo.gts": viewCardDemoCardSource,
+			"Person/1.json": { data: {
+				type: "card",
+				attributes: {
+					firstName: "A",
+					lastName: "B"
+				},
+				meta: { adoptsFrom: {
+					module: "../person",
+					name: "Person"
+				} }
+			} },
+			"Person/2.json": { data: {
+				type: "card",
+				attributes: {
+					firstName: "B",
+					lastName: "C"
+				},
+				meta: { adoptsFrom: {
+					module: "../person",
+					name: "Person"
+				} }
+			} },
+			"Person/3.json": { data: {
+				type: "card",
+				attributes: {
+					firstName: "C",
+					lastName: "D"
+				},
+				meta: { adoptsFrom: {
+					module: "../person",
+					name: "Person"
+				} }
+			} },
+			"ViewCardDemo/1.json": { data: {
+				type: "card",
+				attributes: {
+					cardTitle: "Primary View Demo",
+					targetCardURL: `${testRealmURL}ViewCardDemo/2.json`
+				},
+				meta: { adoptsFrom: {
+					module: "../view-card-demo",
+					name: "ViewCardDemo"
+				} }
+			} },
+			"ViewCardDemo/2.json": { data: {
+				type: "card",
+				attributes: {
+					cardTitle: "Secondary View Demo",
+					targetCardURL: `${testRealmURL}ViewCardDemo/3.json`
+				},
+				meta: { adoptsFrom: {
+					module: "../view-card-demo",
+					name: "ViewCardDemo"
+				} }
+			} },
+			"ViewCardDemo/3.json": { data: {
+				type: "card",
+				attributes: {
+					cardTitle: "Tertiary View Demo",
+					targetCardURL: `${testRealmURL}ViewCardDemo/1.json`
+				},
+				meta: { adoptsFrom: {
+					module: "../view-card-demo",
+					name: "ViewCardDemo"
+				} }
+			} }
+		};
+	});
+	(0, import_qunit.module)("with a realm that is not publishable", function(hooks) {
+		hooks.beforeEach(async function() {
+			await setupAcceptanceTestRealm({
+				mockMatrixUtils,
+				contents: realmContents
+			});
+		});
+		(0, import_qunit.test)("host submode is not available", async function(assert) {
+			await visitOperatorMode({
+				submode: "code",
+				stacks: [[{
+					id: `${testRealmURL}index`,
+					format: "isolated"
+				}]]
+			});
+			await click("[data-test-submode-switcher] button");
+			assert.dom("[data-test-boxel-menu-item-text=\"Host\"]").doesNotExist();
+		});
+		(0, import_qunit.test)("visiting host submode via query parameter shows a button to interact submode", async function(assert) {
+			await visitOperatorMode({
+				submode: "host",
+				stacks: [[{
+					id: `${testRealmURL}Person/1.json`,
+					format: "isolated"
+				}]]
+			});
+			await click("[data-test-switch-to-interact]");
+			assert.dom("[data-test-submode-switcher]").hasText("Interact");
+			assert.dom(`[data-test-stack-card="${testRealmURL}Person/1"]`).exists();
+		});
+	});
+	(0, import_qunit.module)("with a realm that is publishable", function(hooks) {
+		hooks.beforeEach(async function() {
+			await query(await getDbAdapter(), [
+				`INSERT INTO realm_metadata (url, publishable) VALUES (`,
+				param(testRealmURL),
+				`,`,
+				param(true),
+				`) ON CONFLICT (url) DO UPDATE SET publishable = true`
+			]);
+			await setupAcceptanceTestRealm({
+				mockMatrixUtils,
+				contents: realmContents
+			});
+		});
+		(0, import_qunit.test)("host submode is available", async function(assert) {
+			await visitOperatorMode({
+				submode: "interact",
+				stacks: [[{
+					id: `${testRealmURL}index`,
+					format: "isolated"
+				}]]
+			});
+			await click("[data-test-submode-switcher] button");
+			assert.dom("[data-test-boxel-menu-item-text=\"Host\"]").exists();
+		});
+		(0, import_qunit.test)("search is not present", async function(assert) {
+			await visitOperatorMode({
+				submode: "host",
+				trail: [`${testRealmURL}Person/1.json`]
+			});
+			assert.dom("[data-test-open-search-field]").doesNotExist();
+		});
+		(0, import_qunit.test)("entering from interact mode stays on the same card", async function(assert) {
+			await visitOperatorMode({
+				submode: "interact",
+				stacks: [[{
+					id: `${testRealmURL}Person/1.json`,
+					format: "isolated"
+				}]]
+			});
+			await click("[data-test-submode-switcher] button");
+			await click("[data-test-boxel-menu-item-text=\"Host\"]");
+			assert.dom("[data-test-host-mode-card]").exists();
+			assert.dom("[data-test-host-mode-card]").hasText("Title: A B");
+		});
+		(0, import_qunit.test)("entering from code mode shows the index card", async function(assert) {
+			await visitOperatorMode({
+				submode: "code",
+				codePath: `${testRealmURL}Person/1.json`
+			});
+			await click("[data-test-submode-switcher] button");
+			await click("[data-test-boxel-menu-item-text=\"Host\"]");
+			assert.dom("[data-test-host-mode-card]").exists();
+			assert.dom(".boxel-card-container").exists();
+		});
+		(0, import_qunit.test)("entering from code mode with card instance shows the same card", async function(assert) {
+			await visitOperatorMode({
+				submode: "code",
+				codePath: `${testRealmURL}Person/1.json`
+			});
+			await click("[data-test-submode-switcher] button");
+			await click("[data-test-boxel-menu-item-text=\"Host\"]");
+			assert.dom("[data-test-host-mode-card]").exists();
+			assert.dom("[data-test-host-mode-card]").hasText("Title: A B");
+		});
+		(0, import_qunit.test)("clicking a card in card list stacks it", async function(assert) {
+			await visitOperatorMode({
+				submode: "host",
+				trail: [`${testRealmURL}index.json`]
+			});
+			await click("[data-test-boxel-filter-list-button=\"All Cards\"]");
+			await waitFor("[data-test-cards-grid-item]");
+			assert.dom(`[data-test-host-mode-stack-item="${testRealmURL}Person/1"]`).doesNotExist();
+			await click(`[data-test-cards-grid-item="${testRealmURL}Person/1"]`);
+			await waitFor(`[data-test-host-mode-stack-item="${testRealmURL}Person/1"]`);
+			assert.dom(`[data-test-host-mode-stack-item="${testRealmURL}Person/1"]`).exists();
+			assert.dom(`[data-test-host-mode-stack-item="${testRealmURL}Person/1"]`).hasText("Title: A B");
+		});
+		(0, import_qunit.test)("wide format cards use full width", async function(assert) {
+			await visitOperatorMode({
+				submode: "host",
+				trail: [`${testRealmURL}index.json`]
+			});
+			assert.dom(".host-mode-content").hasClass("is-wide");
+			assert.dom(".host-mode-content.is-wide").exists();
+		});
+		(0, import_qunit.test)("regular format cards use standard width", async function(assert) {
+			await visitOperatorMode({
+				submode: "host",
+				trail: [`${testRealmURL}Person/1.json`]
+			});
+			assert.dom(".host-mode-content").doesNotHaveClass("is-wide");
+			assert.dom(".host-mode-content:not(.is-wide)").exists();
+		});
+		(0, import_qunit.test)("viewCard stacks the linked card in host submode", async function(assert) {
+			let targetStackId = `${testRealmURL}ViewCardDemo/2`;
+			await visitOperatorMode({
+				submode: "host",
+				trail: [`${testRealmURL}ViewCardDemo/1.json`]
+			});
+			assert.dom(`[data-test-host-mode-stack-item="${targetStackId}"]`).doesNotExist();
+			await waitFor("[data-test-view-card-demo-button]");
+			await click("[data-test-view-card-demo-button]");
+			await waitFor(`[data-test-host-mode-stack-item="${targetStackId}"]`);
+			assert.dom(`[data-test-host-mode-stack-item="${targetStackId}"]`).exists();
+		});
+		(0, import_qunit.test)("viewCard tabs maintain state after stacking and closing cards", async function(assert) {
+			let primaryCardId = `${testRealmURL}ViewCardDemo/1`;
+			let firstStackCardId = `${testRealmURL}ViewCardDemo/2`;
+			let secondStackCardId = `${testRealmURL}ViewCardDemo/3`;
+			await visitOperatorMode({
+				submode: "host",
+				trail: [`${primaryCardId}.json`]
+			});
+			let primaryCardSelector = `[data-test-host-mode-card="${primaryCardId}"]`;
+			await waitFor(`${primaryCardSelector} [data-test-view-card-demo-active-tab]`);
+			await waitFor(`${primaryCardSelector} [data-test-view-card-demo-button]`);
+			assert.dom(`${primaryCardSelector} [data-test-view-card-demo-active-tab]`).hasAttribute("data-test-view-card-demo-active-tab", "overview");
+			await click(`${primaryCardSelector} [data-test-view-card-demo-tab="details"]`);
+			assert.dom(`${primaryCardSelector} [data-test-view-card-demo-active-tab]`).hasAttribute("data-test-view-card-demo-active-tab", "details");
+			await click(`${primaryCardSelector} [data-test-view-card-demo-button]`);
+			let firstStackSelector = `[data-test-host-mode-stack-item="${firstStackCardId}"]`;
+			await waitFor(`${firstStackSelector} [data-test-view-card-demo-active-tab]`);
+			await waitFor(`${firstStackSelector} [data-test-view-card-demo-button]`);
+			await waitFor(firstStackSelector);
+			assert.dom(`${firstStackSelector} [data-test-view-card-demo-active-tab]`).hasAttribute("data-test-view-card-demo-active-tab", "overview");
+			await click(`${firstStackSelector} [data-test-view-card-demo-tab="history"]`);
+			assert.dom(`${firstStackSelector} [data-test-view-card-demo-active-tab]`).hasAttribute("data-test-view-card-demo-active-tab", "history");
+			await click(`${firstStackSelector} [data-test-view-card-demo-button]`);
+			let secondStackSelector = `[data-test-host-mode-stack-item="${secondStackCardId}"]`;
+			await waitFor(`${secondStackSelector} [data-test-view-card-demo-button]`);
+			await waitFor(secondStackSelector);
+			await click(`[data-test-host-mode-breadcrumb="${firstStackCardId}"]`);
+			await waitUntil(() => {
+				return !document.querySelector(secondStackSelector);
+			});
+			assert.dom(`${firstStackSelector} [data-test-view-card-demo-active-tab]`).hasAttribute("data-test-view-card-demo-active-tab", "history");
+			await click(`[data-test-host-mode-breadcrumb="${primaryCardId}"]`);
+			await waitUntil(() => {
+				return !document.querySelector(firstStackSelector);
+			});
+			assert.dom(`${primaryCardSelector} [data-test-view-card-demo-active-tab]`).hasAttribute("data-test-view-card-demo-active-tab", "details");
+		});
+		(0, import_qunit.test)("breadcrumbs can close stacked cards", async function(assert) {
+			let card1Id = `${testRealmURL}Person/1`;
+			let card2Id = `${testRealmURL}index`;
+			let card3Id = `${testRealmURL}Person/2`;
+			await visitOperatorMode({
+				submode: "host",
+				trail: [
+					`${card1Id}.json`,
+					`${card2Id}.json`,
+					`${card3Id}.json`
+				]
+			});
+			await waitFor(`[data-test-host-mode-card="${card1Id}"]`);
+			assert.dom("[data-test-host-mode-breadcrumb]").exists({ count: 3 });
+			assert.dom(`[data-test-host-mode-stack-item="${card2Id}"]`).exists();
+			assert.dom(`[data-test-host-mode-stack-item="${card3Id}"]`).exists();
+			await click(`[data-test-host-mode-breadcrumb="${card2Id}"]`);
+			await waitUntil(() => {
+				return !document.querySelector(`[data-test-host-mode-stack-item="${card3Id}"]`);
+			});
+			assert.dom("[data-test-host-mode-breadcrumb]").exists({ count: 2 });
+			assert.dom(`[data-test-host-mode-card="${card1Id}"]`).exists();
+			assert.dom(`[data-test-host-mode-stack-item="${card2Id}"]`).exists();
+			await click(`[data-test-host-mode-breadcrumb="${card1Id}"]`);
+			await waitUntil(() => {
+				return !document.querySelector("[data-test-host-mode-stack-item]");
+			});
+			assert.dom(`[data-test-host-mode-card="${card1Id}"]`).exists();
+			assert.dom("[data-test-host-mode-breadcrumb]").doesNotExist();
+			assert.dom("[data-test-host-mode-breadcrumbs]").doesNotExist();
+		});
+		(0, import_qunit.test)("breadcrumb item shows loading state before card is available", async function(assert) {
+			let card1Id = `${testRealmURL}Person/1`;
+			let card2Id = `${testRealmURL}index`;
+			let card3Id = `${testRealmURL}Person/2`;
+			let network = getService("network");
+			let handler = async (request) => {
+				if (request.url.includes(card3Id)) {
+					await waitFor(`[data-test-host-mode-breadcrumb="${card3Id}"]`);
+					assert.dom(`[data-test-host-mode-breadcrumb="${card3Id}"] .label`).hasText("Loading…");
+					return null;
+				}
+				return null;
+			};
+			network.mount(handler, { prepend: true });
+			try {
+				await visitOperatorMode({
+					submode: "host",
+					trail: [
+						`${card1Id}.json`,
+						`${card2Id}.json`,
+						`${card3Id}.json`
+					]
+				});
+				await waitUntil(() => {
+					return document.querySelector(`[data-test-host-mode-breadcrumb="${card3Id}"] .label`)?.textContent?.trim() === "B C";
+				});
+				assert.dom(`[data-test-host-mode-breadcrumb="${card3Id}"] .label`).hasText("B C");
+			} finally {
+				network.resetState();
+			}
+		});
+		(0, import_qunit.test)("shows error state when card is not found", async function(assert) {
+			await visitOperatorMode({
+				submode: "host",
+				trail: [`${testRealmURL}nonexistent.json`]
+			});
+			await waitFor("[data-test-card-error]");
+			assert.dom("[data-test-card-error]").exists();
+		});
+		(0, import_qunit.test)("ai assistant is not displayed in host submode", async function(assert) {
+			await visitOperatorMode({
+				submode: "code",
+				codePath: `${testRealmURL}Person/1.json`,
+				stacks: [[{
+					id: `${testRealmURL}Person/1.json`,
+					format: "isolated"
+				}]],
+				aiAssistantOpen: true
+			});
+			assert.dom("[data-test-open-ai-assistant]").exists();
+			assert.dom("[data-test-ai-assistant-panel]").exists();
+			await click("[data-test-submode-switcher-button]");
+			await click("[data-test-boxel-menu-item-text=\"Interact\"]");
+			assert.dom("[data-test-open-ai-assistant]").exists();
+			assert.dom("[data-test-ai-assistant-panel]").exists();
+			await click("[data-test-submode-switcher-button]");
+			await click("[data-test-boxel-menu-item-text=\"Host\"]");
+			assert.dom("[data-test-open-ai-assistant]").doesNotExist();
+			assert.dom("[data-test-ai-assistant-panel]").doesNotExist();
+			await click("[data-test-submode-switcher-button]");
+			await click("[data-test-boxel-menu-item-text=\"Code\"]");
+			assert.dom("[data-test-open-ai-assistant]").exists();
+			assert.dom("[data-test-ai-assistant-panel]").exists();
+		});
+		(0, import_qunit.module)("publish and unpublish realm", function(hooks) {
+			let publishDeferred;
+			let unpublishDeferred;
+			hooks.beforeEach(function() {
+				publishDeferred = new Deferred();
+				unpublishDeferred = new Deferred();
+				let publishRealm = async (sourceRealmURL, publishedRealmURL) => {
+					await publishDeferred.promise;
+					return { data: {
+						type: "published_realm",
+						id: "1",
+						attributes: {
+							sourceRealmURL,
+							publishedRealmURL,
+							lastPublishedAt: (/* @__PURE__ */ new Date()).getTime()
+						}
+					} };
+				};
+				let unpublishRealm = async (_publishedRealmURL) => {
+					await unpublishDeferred.promise;
+					return { success: true };
+				};
+				getService("realm-server").publishRealm = publishRealm;
+				getService("realm-server").unpublishRealm = unpublishRealm;
+			});
+			(0, import_qunit.test)("can publish realm", async function(assert) {
+				await visitOperatorMode({
+					submode: "host",
+					trail: [`${testRealmURL}Person/1.json`]
+				});
+				assert.dom("[data-test-publish-realm-button]").hasText("Publish Site");
+				await click("[data-test-publish-realm-button]");
+				assert.dom("[data-test-publish-realm-modal]").exists();
+				assert.dom("[data-test-last-published-at]").doesNotExist();
+				assert.dom("[data-test-unpublish-button]").doesNotExist();
+				assert.dom("[data-test-open-site-button]").doesNotExist();
+				assert.dom("[data-test-default-domain-checkbox]").isNotChecked();
+				assert.dom("[data-test-publish-button]").isDisabled();
+				await click("[data-test-default-domain-checkbox]");
+				assert.dom("[data-test-default-domain-checkbox]").isChecked();
+				assert.dom("[data-test-publish-button]").isNotDisabled();
+				await click("[data-test-publish-button]");
+				assert.dom("[data-test-publish-button]").hasText("Publishing…");
+				assert.dom("[data-test-publish-button]").hasAttribute("disabled");
+				await waitFor("[data-test-publish-realm-button].publishing");
+				assert.dom("[data-test-publish-realm-button]").hasText("Publishing…");
+				assert.dom("[data-test-publish-realm-button]").hasClass("publishing");
+				await click("[data-test-publish-realm-button]");
+				await waitFor(".publishing-realm-popover");
+				assert.dom(".publishing-realm-popover").exists();
+				assert.dom(".publishing-realm-popover").containsText(`Publishing to: https://testuser.localhost:4201/test/`);
+				assert.dom(".publishing-realm-popover").exists();
+				assert.dom(".loading-icon").exists();
+				publishDeferred.fulfill();
+				await waitUntil(() => {
+					return !document.querySelector("[data-test-publish-realm-button].publishing");
+				});
+				assert.dom("[data-test-publish-realm-button]").hasText("Republish Site");
+				assert.dom("[data-test-publish-realm-button]").doesNotHaveClass("publishing");
+				assert.dom(".publishing-realm-popover").doesNotExist();
+				await click("[data-test-publish-realm-button]");
+				assert.dom("[data-test-last-published-at]").exists();
+				assert.dom("[data-test-last-published-at]").containsText("Published");
+				assert.dom("[data-test-unpublish-button]").exists();
+				assert.dom("[data-test-unpublish-button]").containsText("Unpublish");
+				assert.dom("[data-test-open-site-button]").exists();
+				assert.dom("[data-test-open-site-button]").containsText("Open Site");
+				assert.dom("[data-test-publish-realm-modal] [data-test-open-boxel-space-button]").hasAttribute("href", "https://testuser.localhost:4201/test/").hasAttribute("target", "_blank");
+			});
+			(0, import_qunit.test)("preselects previously published domains on refresh", async function(assert) {
+				let now = Date.now();
+				let realmServer = getService("realm-server");
+				let originalFetchClaimed = realmServer.fetchBoxelClaimedDomain;
+				realmServer.fetchBoxelClaimedDomain = async () => ({
+					id: "claimed-domain-1",
+					hostname: "custom-site-name.localhost:4201",
+					subdomain: "custom-site-name",
+					sourceRealmURL: testRealmURL
+				});
+				let restoreRealmInfo = withUpdatedTestRealmInfo({ lastPublishedAt: {
+					"https://testuser.localhost:4201/test/": String(now),
+					"https://custom-site-name.localhost:4201/": String(now)
+				} });
+				try {
+					await visitOperatorMode({
+						submode: "host",
+						trail: [`${testRealmURL}Person/1.json`]
+					});
+					await click("[data-test-publish-realm-button]");
+					await waitFor("[data-test-publish-realm-modal]");
+					assert.dom("[data-test-default-domain-checkbox]").isChecked();
+					assert.dom("[data-test-custom-subdomain-checkbox]").isChecked();
+					assert.dom("[data-test-publish-button]").isNotDisabled();
+				} finally {
+					realmServer.fetchBoxelClaimedDomain = originalFetchClaimed;
+					restoreRealmInfo();
+				}
+			});
+			(0, import_qunit.test)("default domain checkbox can be checked and unchecked", async function(assert) {
+				await visitOperatorMode({
+					submode: "host",
+					trail: [`${testRealmURL}Person/1.json`]
+				});
+				await click("[data-test-publish-realm-button]");
+				assert.dom("[data-test-default-domain-checkbox]").isNotChecked();
+				assert.dom("[data-test-publish-button]").isDisabled();
+				await click("[data-test-default-domain-checkbox]");
+				assert.dom("[data-test-default-domain-checkbox]").isChecked();
+				assert.dom("[data-test-publish-button]").isNotDisabled();
+				await click("[data-test-default-domain-checkbox]");
+				assert.dom("[data-test-default-domain-checkbox]").isNotChecked();
+				assert.dom("[data-test-publish-button]").isDisabled();
+			});
+			(0, import_qunit.test)("can unpublish realm", async function(assert) {
+				let restoreRealmInfo = withUpdatedTestRealmInfo({ lastPublishedAt: { ["https://testuser.localhost:4201/test/"]: ((/* @__PURE__ */ new Date()).getTime() - 4320 * 60 * 1e3).toString() } });
+				try {
+					await visitOperatorMode({
+						submode: "host",
+						trail: [`${testRealmURL}Person/1.json`]
+					});
+					await click("[data-test-publish-realm-button]");
+					assert.dom("[data-test-last-published-at]").containsText("3 days ago");
+					assert.dom("[data-test-unpublish-button]").exists();
+					assert.dom("[data-test-open-site-button]").exists();
+					await click("[data-test-unpublish-button]");
+					assert.dom("[data-test-unpublish-button]").hasText("Unpublishing…");
+					unpublishDeferred.fulfill();
+					await waitUntil(() => {
+						return !document.querySelector("[data-test-unpublish-button]");
+					});
+					assert.dom("[data-test-last-published-at]").doesNotExist();
+					assert.dom("[data-test-unpublish-button]").doesNotExist();
+					assert.dom("[data-test-open-site-button]").doesNotExist();
+				} finally {
+					restoreRealmInfo();
+				}
+			});
+			(0, import_qunit.test)("open site button only appears when realm is published", async function(assert) {
+				await visitOperatorMode({
+					submode: "host",
+					trail: [`${testRealmURL}Person/1.json`]
+				});
+				assert.dom("[data-test-open-site-button]").doesNotExist();
+			});
+			(0, import_qunit.test)("can claim domain for boxel site", async function(assert) {
+				let mockDomainValidationResponse = async (request) => {
+					if (!request.url.includes("_check-boxel-domain-availability")) return null;
+					return new Response(JSON.stringify({
+						available: true,
+						domain: "my-boxel-site.localhost"
+					}), { headers: { "Content-Type": "application/json" } });
+				};
+				let mockClaimedDomainResponse = async (request) => {
+					if (request.method !== "POST" || !request.url.includes("_boxel-claimed-domains")) return null;
+					return new Response(JSON.stringify({ data: {
+						type: "claimed-domain",
+						id: "1",
+						attributes: {
+							hostname: "my-boxel-site.localhost",
+							subdomain: "my-boxel-site",
+							sourceRealmURL: testRealmURL
+						}
+					} }), { headers: { "Content-Type": "application/vnd.api+json" } });
+				};
+				getService("network").mount(mockDomainValidationResponse, { prepend: true });
+				getService("network").mount(mockClaimedDomainResponse, { prepend: true });
+				await visitOperatorMode({
+					submode: "host",
+					trail: [`${testRealmURL}Person/1.json`]
+				});
+				await click("[data-test-publish-realm-button]");
+				assert.dom("[data-test-custom-subdomain-input]").doesNotExist();
+				await click("[data-test-custom-subdomain-setup-button]");
+				assert.dom("[data-test-boxel-button]").isDisabled();
+				await fillIn("[data-test-custom-subdomain-input] input", "my-boxel-site");
+				assert.dom("[data-test-claim-custom-subdomain-button]").isNotDisabled();
+				await click("[data-test-claim-custom-subdomain-button]");
+				assert.dom("[data-test-custom-subdomain-cancel]").doesNotExist();
+				assert.dom("[data-test-custom-subdomain-setup-button]").doesNotExist();
+				assert.dom("[data-test-custom-subdomain-details]").includesText("https://my-boxel-site.localhost:4201/ Not published yet");
+				assert.dom("[data-test-unclaim-custom-subdomain-button]").exists();
+				assert.dom("[data-test-custom-subdomain-checkbox]").isChecked();
+			});
+			(0, import_qunit.test)("shows error when claiming domain fails with 422", async function(assert) {
+				let mockDomainValidationResponse = async (request) => {
+					if (!request.url.includes("_check-boxel-domain-availability")) return null;
+					return new Response(JSON.stringify({
+						available: true,
+						domain: "my-boxel-site.localhost"
+					}), { headers: { "Content-Type": "application/json" } });
+				};
+				let mockClaimedDomainError = async (request) => {
+					if (request.method !== "POST" || !request.url.includes("_boxel-claimed-domains")) return null;
+					return new Response("There was an error claiming this domain", {
+						status: 422,
+						headers: { "Content-Type": "application/vnd.api+json" }
+					});
+				};
+				getService("network").mount(mockDomainValidationResponse, { prepend: true });
+				getService("network").mount(mockClaimedDomainError, { prepend: true });
+				await visitOperatorMode({
+					submode: "host",
+					trail: [`${testRealmURL}Person/1.json`]
+				});
+				await click("[data-test-publish-realm-button]");
+				await click("[data-test-custom-subdomain-setup-button]");
+				await fillIn("[data-test-custom-subdomain-input] input", "my-boxel-site");
+				await click("[data-test-claim-custom-subdomain-button]");
+				assert.dom("[data-test-custom-subdomain-cancel]").exists();
+				assert.dom("[data-test-custom-subdomain-input]").exists();
+				assert.dom("[data-test-boxel-input-group-error-message]").hasText("There was an error claiming this domain");
+			});
+			(0, import_qunit.test)("open site popover shows published realms and opens them correctly", async function(assert) {
+				let now = Date.now();
+				let restoreRealmInfo = withUpdatedTestRealmInfo({ lastPublishedAt: {
+					"https://testuser.localhost:4201/test/": String(now),
+					"https://another-domain.com/realm/": String(now - 1e3)
+				} });
+				try {
+					await visitOperatorMode({
+						submode: "host",
+						trail: [`${testRealmURL}Person/1.json`]
+					});
+					assert.dom("[data-test-open-site-button]").hasAttribute("href", "https://testuser.localhost:4201/test/Person/1").hasAttribute("target", "_blank");
+					await triggerEvent("[data-test-open-site-button]", "mouseenter");
+					await waitFor("[data-test-tooltip-content]");
+					assert.dom("[data-test-tooltip-content]").hasText("Open Site in a New Tab (Shift+Click for options)", "Tooltip shows correct text when menu is closed");
+					assert.dom("[data-test-open-site-popover]").doesNotExist();
+					await click("[data-test-open-site-button]", { shiftKey: true });
+					assert.dom("[data-test-open-site-popover]").exists();
+					assert.dom("[data-test-published-realm-item]").exists({ count: 2 });
+					assert.dom("[data-test-published-realm-item] [data-test-open-site-button]").exists({ count: 2 });
+					assert.dom("[data-test-published-realm-item=\"https://testuser.localhost:4201/test/Person/1\"]").exists();
+					assert.dom("[data-test-published-realm-item=\"https://another-domain.com/realm/Person/1\"]").exists();
+					assert.dom("[data-test-published-realm-item=\"https://testuser.localhost:4201/test/Person/1\"] [data-test-open-site-button]").hasAttribute("href", "https://testuser.localhost:4201/test/Person/1").hasAttribute("target", "_blank");
+					assert.dom("[data-test-published-realm-item=\"https://another-domain.com/realm/Person/1\"] [data-test-open-site-button]").hasAttribute("href", "https://another-domain.com/realm/Person/1").hasAttribute("target", "_blank");
+				} finally {
+					restoreRealmInfo();
+				}
+			});
+			(0, import_qunit.test)("claimed custom site name displays details and reverts after unclaim", async function(assert) {
+				let realmServer = getService("realm-server");
+				let originalFetchClaimed = realmServer.fetchBoxelClaimedDomain;
+				let originalDeleteClaimed = realmServer.deleteBoxelClaimedDomain;
+				let deleteCalled = false;
+				realmServer.fetchBoxelClaimedDomain = async () => ({
+					id: "claimed-domain-1",
+					hostname: "custom-site-name.localhost:4201",
+					subdomain: "custom-site-name",
+					sourceRealmURL: testRealmURL
+				});
+				realmServer.deleteBoxelClaimedDomain = async () => {
+					deleteCalled = true;
+					realmServer.fetchBoxelClaimedDomain = async () => null;
+				};
+				try {
+					await visitOperatorMode({
+						submode: "host",
+						trail: [`${testRealmURL}Person/1.json`]
+					});
+					await click("[data-test-publish-realm-button]");
+					await waitFor("[data-test-publish-realm-modal]");
+					let customDomainOption = "[data-test-publish-realm-modal] .domain-option:nth-of-type(2)";
+					await waitFor(`${customDomainOption} .realm-icon`);
+					assert.dom(`${customDomainOption} .realm-icon`).exists("shows realm icon when site name is claimed");
+					assert.dom(`${customDomainOption} .domain-url`).hasText("https://custom-site-name.localhost:4201/", "shows claimed custom site URL");
+					assert.dom("[data-test-unclaim-custom-subdomain-button]").exists("shows unclaim button when domain is claimed");
+					assert.dom("[data-test-custom-subdomain-setup-button]").doesNotExist("setup button hidden while domain is claimed");
+					await click("[data-test-unclaim-custom-subdomain-button]");
+					assert.true(deleteCalled, "unclaim endpoint invoked");
+					await waitUntil(() => {
+						return !document.querySelector(`${customDomainOption} .realm-icon`) && document.querySelector("[data-test-custom-subdomain-setup-button]");
+					});
+					assert.dom("[data-test-custom-subdomain-setup-button]").exists("setup button returns after unclaim");
+					assert.dom("[data-test-unclaim-custom-subdomain-button]").doesNotExist("unclaim button removed after unclaim");
+					assert.dom(`${customDomainOption} .domain-url`).hasText("https://custom-site-name.localhost:4201/", "displays placeholder custom site URL after unclaim");
+					assert.dom("[data-test-boxel-input-validation-state=\"valid\"]").doesNotExist("validation check mark not displayed after unclaim");
+				} finally {
+					realmServer.fetchBoxelClaimedDomain = originalFetchClaimed;
+					realmServer.deleteBoxelClaimedDomain = originalDeleteClaimed;
+				}
+			});
+			(0, import_qunit.test)("claimed custom domain is preselected even before first publish", async function(assert) {
+				let realmServer = getService("realm-server");
+				let originalFetchClaimed = realmServer.fetchBoxelClaimedDomain;
+				realmServer.fetchBoxelClaimedDomain = async () => ({
+					id: "claimed-domain-1",
+					hostname: "custom-site-name.localhost:4201",
+					subdomain: "custom-site-name",
+					sourceRealmURL: testRealmURL
+				});
+				try {
+					await visitOperatorMode({
+						submode: "host",
+						trail: [`${testRealmURL}Person/1.json`]
+					});
+					await click("[data-test-publish-realm-button]");
+					await waitFor("[data-test-publish-realm-modal]");
+					assert.dom("[data-test-custom-subdomain-checkbox]").isChecked();
+					assert.dom("[data-test-default-domain-checkbox]").isNotChecked();
+					assert.dom("[data-test-publish-button]").isNotDisabled();
+				} finally {
+					realmServer.fetchBoxelClaimedDomain = originalFetchClaimed;
+				}
+			});
+			(0, import_qunit.test)("custom site checkbox can be checked and unchecked", async function(assert) {
+				let realmServer = getService("realm-server");
+				let originalFetchClaimed = realmServer.fetchBoxelClaimedDomain;
+				realmServer.fetchBoxelClaimedDomain = async () => ({
+					id: "claimed-domain-1",
+					hostname: "custom-site-name.localhost:4201",
+					subdomain: "custom-site-name",
+					sourceRealmURL: testRealmURL
+				});
+				try {
+					await visitOperatorMode({
+						submode: "host",
+						trail: [`${testRealmURL}Person/1.json`]
+					});
+					await click("[data-test-publish-realm-button]");
+					await waitFor("[data-test-custom-subdomain-checkbox]");
+					assert.dom("[data-test-custom-subdomain-checkbox]").isChecked();
+					assert.dom("[data-test-publish-button]").isNotDisabled();
+					await click("[data-test-custom-subdomain-checkbox]");
+					assert.dom("[data-test-custom-subdomain-checkbox]").isNotChecked();
+					assert.dom("[data-test-publish-button]").isDisabled();
+					await click("[data-test-custom-subdomain-checkbox]");
+					assert.dom("[data-test-custom-subdomain-checkbox]").isChecked();
+					assert.dom("[data-test-publish-button]").isNotDisabled();
+				} finally {
+					realmServer.fetchBoxelClaimedDomain = originalFetchClaimed;
+				}
+			});
+			(0, import_qunit.test)("shows inline error when publishing to a domain fails", async function(assert) {
+				let publishError = new Deferred();
+				let publishRealm = async () => {
+					await publishError.promise;
+					throw new Error("Network error: Failed to publish realm");
+				};
+				getService("realm-server").publishRealm = publishRealm;
+				await visitOperatorMode({
+					submode: "host",
+					trail: [`${testRealmURL}Person/1.json`]
+				});
+				await click("[data-test-publish-realm-button]");
+				assert.dom("[data-test-publish-realm-modal]").exists();
+				let defaultUrl = "https://testuser.localhost:4201/test/";
+				assert.dom(`[data-test-domain-publish-error="${defaultUrl}"]`).doesNotExist();
+				await click("[data-test-default-domain-checkbox]");
+				await click("[data-test-publish-button]");
+				publishError.reject(/* @__PURE__ */ new Error("Network error: Failed to publish realm"));
+				await waitFor(`[data-test-domain-publish-error="${defaultUrl}"]`);
+				assert.dom(`[data-test-domain-publish-error="${defaultUrl}"]`).exists();
+				assert.dom(`[data-test-domain-publish-error="${defaultUrl}"] .error-text`).hasText("Network error: Failed to publish realm");
+				assert.dom("[data-test-publish-realm-modal]").exists();
+			});
+			(0, import_qunit.test)("shows inline error for failed domain while allowing successful ones", async function(assert) {
+				let realmServer = getService("realm-server");
+				let originalFetchClaimed = realmServer.fetchBoxelClaimedDomain;
+				let originalPublishRealm = realmServer.publishRealm;
+				realmServer.fetchBoxelClaimedDomain = async () => ({
+					id: "claimed-domain-1",
+					hostname: "my-custom-site.localhost:4201",
+					subdomain: "my-custom-site",
+					sourceRealmURL: testRealmURL
+				});
+				let defaultUrl = "https://testuser.localhost:4201/test/";
+				let customUrl = "https://my-custom-site.localhost:4201/";
+				realmServer.publishRealm = async (_sourceURL, publishedURL) => {
+					await publishDeferred.promise;
+					if (publishedURL === customUrl) throw new Error("Custom domain validation failed");
+					return { data: {
+						type: "published_realm",
+						id: "1",
+						attributes: {
+							sourceRealmURL: _sourceURL,
+							publishedRealmURL: publishedURL,
+							lastPublishedAt: (/* @__PURE__ */ new Date()).getTime()
+						}
+					} };
+				};
+				try {
+					await visitOperatorMode({
+						submode: "host",
+						trail: [`${testRealmURL}Person/1.json`]
+					});
+					await click("[data-test-publish-realm-button]");
+					await waitFor("[data-test-publish-realm-modal]");
+					assert.dom("[data-test-custom-subdomain-checkbox]").isChecked();
+					assert.dom("[data-test-default-domain-checkbox]").isNotChecked();
+					await click("[data-test-default-domain-checkbox]");
+					await click("[data-test-publish-button]");
+					publishDeferred.fulfill();
+					await waitUntil(() => {
+						return !document.querySelector("[data-test-publish-realm-button].publishing");
+					});
+					await click("[data-test-publish-realm-button]");
+					assert.dom("[data-test-publish-realm-modal] .domain-option:nth-of-type(1)").containsText("Published");
+					assert.dom(`[data-test-domain-publish-error="${customUrl}"]`).exists();
+					assert.dom(`[data-test-domain-publish-error="${customUrl}"] .error-text`).hasText("Custom domain validation failed");
+					assert.dom(`[data-test-domain-publish-error="${defaultUrl}"]`).doesNotExist();
+				} finally {
+					realmServer.fetchBoxelClaimedDomain = originalFetchClaimed;
+					realmServer.publishRealm = originalPublishRealm;
+				}
+			});
+			(0, import_qunit.test)("can publish claimed domain", async function(assert) {
+				let realmServer = getService("realm-server");
+				let originalFetchClaimed = realmServer.fetchBoxelClaimedDomain;
+				realmServer.fetchBoxelClaimedDomain = async () => ({
+					id: "claimed-domain-1",
+					hostname: "my-custom-site.localhost:4201",
+					subdomain: "my-custom-site",
+					sourceRealmURL: testRealmURL
+				});
+				try {
+					await visitOperatorMode({
+						submode: "host",
+						trail: [`${testRealmURL}Person/1.json`]
+					});
+					await click("[data-test-publish-realm-button]");
+					await waitFor("[data-test-publish-realm-modal]");
+					await click("[data-test-default-domain-checkbox]");
+					assert.dom("[data-test-default-domain-checkbox]").isChecked();
+					assert.dom("[data-test-custom-subdomain-checkbox]").isChecked();
+					await click("[data-test-publish-button]");
+					assert.dom("[data-test-publish-button]").hasText("Publishing…");
+					publishDeferred.fulfill();
+					await waitUntil(() => {
+						return !document.querySelector("[data-test-publish-realm-button].publishing");
+					});
+					await click("[data-test-publish-realm-button]");
+					assert.dom("[data-test-publish-realm-modal] .domain-option:nth-of-type(1)").containsText("Published");
+					assert.dom("[data-test-publish-realm-modal] .domain-option:nth-of-type(2)").containsText("Published");
+					assert.dom("[data-test-unpublish-button]").exists();
+					assert.dom("[data-test-unpublish-custom-subdomain-button]").exists();
+					await waitFor("[data-test-open-custom-subdomain-button]");
+					assert.dom("[data-test-open-custom-subdomain-button]").exists();
+					assert.dom("[data-test-open-custom-subdomain-button]").hasAttribute("href", "https://my-custom-site.localhost:4201/").hasAttribute("target", "_blank");
+				} finally {
+					realmServer.fetchBoxelClaimedDomain = originalFetchClaimed;
+				}
+			});
+			(0, import_qunit.test)("custom subdomain checkbox is checked when modal opens with claimed domain", async function(assert) {
+				let realmServer = getService("realm-server");
+				let originalFetchClaimed = realmServer.fetchBoxelClaimedDomain;
+				realmServer.fetchBoxelClaimedDomain = async () => ({
+					id: "claimed-domain-1",
+					hostname: "my-custom-site.localhost:4201",
+					subdomain: "my-custom-site",
+					sourceRealmURL: testRealmURL
+				});
+				try {
+					await visitOperatorMode({
+						submode: "host",
+						trail: [`${testRealmURL}Person/1.json`]
+					});
+					await click("[data-test-publish-realm-button]");
+					await waitFor("[data-test-publish-realm-modal]");
+					assert.dom("[data-test-custom-subdomain-checkbox]").isChecked();
+					assert.dom("[data-test-publish-realm-modal] .domain-option:nth-of-type(2)").containsText("Not published yet");
+					await click("[data-test-custom-subdomain-checkbox]");
+					assert.dom("[data-test-custom-subdomain-checkbox]").isNotChecked();
+				} finally {
+					realmServer.fetchBoxelClaimedDomain = originalFetchClaimed;
+				}
+			});
+			(0, import_qunit.test)("can unpublish claimed domain", async function(assert) {
+				let realmServer = getService("realm-server");
+				let originalFetchClaimed = realmServer.fetchBoxelClaimedDomain;
+				realmServer.fetchBoxelClaimedDomain = async () => ({
+					id: "claimed-domain-1",
+					hostname: "my-custom-site.localhost:4201",
+					subdomain: "my-custom-site",
+					sourceRealmURL: testRealmURL
+				});
+				let restoreRealmInfo = withUpdatedTestRealmInfo({ lastPublishedAt: { ["https://my-custom-site.localhost:4201/"]: ((/* @__PURE__ */ new Date()).getTime() - 2880 * 60 * 1e3).toString() } });
+				try {
+					await visitOperatorMode({
+						submode: "host",
+						trail: [`${testRealmURL}Person/1.json`]
+					});
+					await click("[data-test-publish-realm-button]");
+					await waitFor("[data-test-publish-realm-modal]");
+					assert.dom("[data-test-publish-realm-modal] .domain-option:nth-of-type(2) .last-published-at").containsText("Published 2 days ago");
+					assert.dom("[data-test-unpublish-custom-subdomain-button]").exists();
+					await click("[data-test-unpublish-custom-subdomain-button]");
+					assert.dom("[data-test-unpublish-custom-subdomain-button]").hasText("Unpublishing…");
+					unpublishDeferred.fulfill();
+					await waitUntil(() => {
+						return !document.querySelector("[data-test-unpublish-custom-subdomain-button]");
+					});
+					assert.dom("[data-test-publish-realm-modal] .domain-option:nth-of-type(2) .not-published-yet").exists();
+					assert.dom("[data-test-publish-realm-modal] .domain-option:nth-of-type(2)").containsText("Not published yet");
+				} finally {
+					restoreRealmInfo();
+					realmServer.fetchBoxelClaimedDomain = originalFetchClaimed;
+				}
+			});
+		});
+	});
+});
+//#endregion