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

package/bundled-test-harness/assets/host-submode-test-C6SxQ796.js

@@ -0,0 +1,1392 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL, Fs as query, Ps as param, Rc as Deferred, Rr as testRealmInfo, Us as ReadinessTimeoutError } from "./runtime-common-BTaLJEw-.js";
+import { O as baseRealm } from "./constants-Icc0nFW-.js";
+import { t as config } from "./environment-DIUJgBKt.js";
+import { n as TrackedObject } from "./dist-B9tGPKZz.js";
+import { M as waitUntil, T as settled, a as find, d as click, l as triggerEvent, o as waitFor, s as fillIn } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { D as realmConfigCardJSON, F as setupLocalIndexing, I as setupOnSave, L as setupRealmCacheTeardown, Z as withCachedRealmSetup, a as SYSTEM_CARD_FIXTURE_CONTENTS, b as getDbAdapter, ct as setupApplicationTest, j as setupAcceptanceTestRealm, st as visitOperatorMode, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { t as CardsGrid } from "./cards-grid-CbyLapaw.js";
+import { t as viewCardDemoCardSource } from "./view-card-demo-Dt06d2YH.js";
+//#region tests/acceptance/host-submode-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var publishedSpaceHost = config.publishedRealmBoxelSpaceDomain;
+var personCardSource = `
+  import { contains, containsMany, field, linksToMany, CardDef, Component } from "@cardstack/base/card-api";
+  import StringField from "@cardstack/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;
+	};
+}
+function stubUnlistedPath(slugs) {
+	let realmServer = getService("realm-server");
+	let original = realmServer.allocateUnlistedPath;
+	let queue = Array.isArray(slugs) ? [...slugs] : [slugs];
+	realmServer.allocateUnlistedPath = async (sourceRealmURL) => {
+		return {
+			sourceRealmURL,
+			slug: queue.length > 1 ? queue.shift() : queue[0]
+		};
+	};
+	return () => {
+		realmServer.allocateUnlistedPath = original;
+	};
+}
+(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]
+	});
+	let realmContents;
+	hooks.beforeEach(function() {
+		realmContents = {
+			...SYSTEM_CARD_FIXTURE_CONTENTS,
+			"index.json": new CardsGrid(),
+			"realm.json": realmConfigCardJSON({
+				name: "Test Workspace B",
+				backgroundURL: "/test-fixtures/realm-images/pawel-czerwinski-Ly-ZLa-A5jti-Y-unsplash.jpg",
+				iconURL: "/test-fixtures/realm-images/boxel-logo.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 dangling host routing rule", function(hooks) {
+		setupRealmCacheTeardown(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`
+			]);
+			realmContents["realm.json"] = { data: {
+				type: "card",
+				attributes: {
+					cardInfo: { name: "Test Workspace B" },
+					hostRoutingRules: [{ path: "/" }]
+				},
+				relationships: { "hostRoutingRules.0.instance": { links: { self: "./does-not-exist" } } },
+				meta: { adoptsFrom: {
+					module: "@cardstack/base/realm-config",
+					name: "RealmConfig"
+				} }
+			} };
+			await withCachedRealmSetup(async () => {
+				await setupAcceptanceTestRealm({
+					mockMatrixUtils,
+					contents: realmContents
+				});
+			});
+			await getService("realm").ensureRealmMeta(testRealmURL);
+		});
+		(0, import_qunit.test)("publish modal warns that a routing rule points to a missing card", async function(assert) {
+			await visitOperatorMode({
+				submode: "host",
+				trail: [`${testRealmURL}Person/1.json`]
+			});
+			await click("[data-test-publish-realm-button]");
+			await waitFor("[data-test-publish-realm-modal]");
+			await waitFor("[data-test-dangling-routing-warning]");
+			assert.dom("[data-test-dangling-routing-warning]").exists("the dangling-routing warning shows in the publish modal");
+			assert.dom("[data-test-dangling-routing-warning]").containsText("does-not-exist", "the warning names the missing routing target");
+		});
+	});
+	(0, import_qunit.module)("with a realm that is not publishable", function(hooks) {
+		setupRealmCacheTeardown(hooks);
+		hooks.beforeEach(async function() {
+			await query(await getDbAdapter(), [`DELETE FROM realm_metadata WHERE url =`, param(testRealmURL)]);
+			await withCachedRealmSetup(async () => {
+				await setupAcceptanceTestRealm({
+					mockMatrixUtils,
+					contents: realmContents
+				});
+			});
+			await getService("realm").ensureRealmMeta(testRealmURL);
+		});
+		(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.test)("the publish modal warns that the workspace cannot be published", async function(assert) {
+			await visitOperatorMode({
+				submode: "host",
+				trail: [`${testRealmURL}Person/1.json`]
+			});
+			await click("[data-test-publish-realm-button]");
+			await waitFor("[data-test-publish-realm-modal]");
+			await waitFor("[data-test-unpublishable-realm-warning]");
+			assert.dom("[data-test-unpublishable-realm-warning]").containsText("not publishable", "the warning states the workspace cannot be published");
+			await click("[data-test-default-domain-checkbox]");
+			assert.dom("[data-test-publish-button]").isDisabled("publishing stays withheld with a domain selected, rather than being left to fail against the endpoint");
+		});
+	});
+	(0, import_qunit.module)("with a realm flagged unpublishable", function(hooks) {
+		setupRealmCacheTeardown(hooks);
+		hooks.beforeEach(async function() {
+			await query(await getDbAdapter(), [
+				`INSERT INTO realm_metadata (url, publishable) VALUES (`,
+				param(testRealmURL),
+				`,`,
+				param(false),
+				`) ON CONFLICT (url) DO UPDATE SET publishable = false`
+			]);
+			await withCachedRealmSetup(async () => {
+				await setupAcceptanceTestRealm({
+					mockMatrixUtils,
+					contents: realmContents
+				});
+			});
+			await getService("realm").ensureRealmMeta(testRealmURL);
+		});
+		(0, import_qunit.test)("the publish modal warns and withholds publishing", async function(assert) {
+			await visitOperatorMode({
+				submode: "host",
+				trail: [`${testRealmURL}Person/1.json`]
+			});
+			await click("[data-test-publish-realm-button]");
+			await waitFor("[data-test-publish-realm-modal]");
+			await waitFor("[data-test-unpublishable-realm-warning]");
+			assert.dom("[data-test-unpublishable-realm-warning]").containsText("not publishable");
+			await click("[data-test-default-domain-checkbox]");
+			assert.dom("[data-test-publish-button]").isDisabled("a domain is selected, so only the publishability gate can be holding this");
+		});
+	});
+	(0, import_qunit.module)("with a realm that is publishable", function(hooks) {
+		setupRealmCacheTeardown(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 withCachedRealmSetup(async () => {
+				await setupAcceptanceTestRealm({
+					mockMatrixUtils,
+					contents: realmContents
+				});
+			});
+			await getService("realm").ensureRealmMeta(testRealmURL);
+		});
+		(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)("the publish modal shows no unpublishability warning", async function(assert) {
+			await visitOperatorMode({
+				submode: "host",
+				trail: [`${testRealmURL}Person/1.json`]
+			});
+			await click("[data-test-publish-realm-button]");
+			await waitFor("[data-test-publish-realm-modal]");
+			await waitFor("[data-test-default-domain-checkbox]");
+			assert.dom("[data-test-unpublishable-realm-warning]").doesNotExist();
+			await click("[data-test-default-domain-checkbox]");
+			assert.dom("[data-test-publish-button]").isNotDisabled();
+		});
+		(0, import_qunit.test)("an empty selection reports itself as empty, not as unpublishable", async function(assert) {
+			await visitOperatorMode({
+				submode: "host",
+				stacks: [[{
+					id: `${testRealmURL}index`,
+					format: "isolated"
+				}]]
+			});
+			assert.dom("[data-test-host-mode-empty]").containsText("No card selected");
+			assert.dom("[data-test-host-mode-empty]").doesNotContainText("publishable", "having nothing to render is not a publishability problem");
+		});
+		(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)("viewing a card already in the trail unwinds to it", async function(assert) {
+			let belowCardId = `${testRealmURL}ViewCardDemo/2`;
+			let topCardId = `${testRealmURL}ViewCardDemo/1`;
+			await visitOperatorMode({
+				submode: "host",
+				trail: [
+					`${testRealmURL}ViewCardDemo/3.json`,
+					`${belowCardId}.json`,
+					`${topCardId}.json`
+				]
+			});
+			let topSelector = `[data-test-host-mode-stack-item="${topCardId}"]`;
+			let belowSelector = `[data-test-host-mode-stack-item="${belowCardId}"]`;
+			await waitFor(`${topSelector} [data-test-view-card-demo-button]`);
+			await click(`${topSelector} [data-test-view-card-demo-button]`);
+			await waitUntil(() => !document.querySelector(topSelector));
+			assert.dom(belowSelector).exists("unwinds to the targeted card rather than stacking a copy");
+		});
+		(0, import_qunit.test)("clicking the scrim closes the top card of the trail", async function(assert) {
+			let belowCardId = `${testRealmURL}ViewCardDemo/2`;
+			let topCardId = `${testRealmURL}ViewCardDemo/3`;
+			await visitOperatorMode({
+				submode: "host",
+				trail: [
+					`${testRealmURL}ViewCardDemo/1.json`,
+					`${belowCardId}.json`,
+					`${topCardId}.json`
+				]
+			});
+			let topSelector = `[data-test-host-mode-stack-item="${topCardId}"]`;
+			await waitFor(topSelector);
+			await click("[data-test-host-mode-stack]");
+			await waitUntil(() => !document.querySelector(topSelector));
+			assert.dom(`[data-test-host-mode-stack-item="${belowCardId}"]`).exists("only the top card closes");
+		});
+		(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-host-mode-404]");
+			assert.dom("[data-test-host-mode-404]").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) {
+			setupRealmCacheTeardown(hooks);
+			let publishDeferred;
+			let unpublishDeferred;
+			hooks.beforeEach(function() {
+				publishDeferred = new Deferred();
+				unpublishDeferred = new Deferred();
+				let publishRealm = async (sourceRealmURL, publishedRealmURL) => {
+					await publishDeferred.promise;
+					return {
+						sourceRealmURL,
+						publishedRealmURL,
+						publishedRealmId: "1",
+						lastPublishedAt: String((/* @__PURE__ */ new Date()).getTime()),
+						status: "published"
+					};
+				};
+				let unpublishRealm = async (publishedRealmURL) => {
+					await unpublishDeferred.promise;
+					return {
+						sourceRealmURL: null,
+						publishedRealmURL,
+						lastPublishedAt: null
+					};
+				};
+				getService("realm-server").publishRealm = publishRealm;
+				getService("realm-server").unpublishRealm = unpublishRealm;
+				getService("realm-server").waitForRealmReady = async () => {};
+				getService("realm-server").allocateUnlistedPath = async (sourceRealmURL) => ({
+					sourceRealmURL,
+					slug: "defaultunlistedab"
+				});
+			});
+			(0, import_qunit.test)("the Publishing popover closes with its publish, even when the publish fails", async function(assert) {
+				getService("realm-server").publishRealm = async () => {
+					await publishDeferred.promise;
+					throw new Error("The domain refused the publish");
+				};
+				await visitOperatorMode({
+					submode: "host",
+					trail: [`${testRealmURL}Person/1.json`]
+				});
+				await click("[data-test-publish-realm-button]");
+				await click("[data-test-default-domain-checkbox]");
+				await click("[data-test-publish-button]");
+				await click("[data-test-publish-realm-modal] [data-test-close-modal]");
+				await waitUntil(() => find("[data-test-publish-realm-button]")?.textContent?.includes("Publishing…"));
+				await click("[data-test-publish-realm-button]");
+				assert.dom("[data-test-publishing-realm-popover]").exists();
+				publishDeferred.fulfill();
+				await waitUntil(() => !find("[data-test-publish-realm-button]")?.textContent?.includes("Publishing…"));
+				assert.dom("[data-test-publishing-realm-popover]").doesNotExist("it closes with the failed publish");
+			});
+			(0, import_qunit.test)("leaving host mode with the publish dialog open closes it, so it does not come back", async function(assert) {
+				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 operatorModeState = getService("operator-mode-state-service");
+				operatorModeState.updateSubmode("interact");
+				await settled();
+				operatorModeState.updateSubmode("host");
+				await settled();
+				assert.dom("[data-test-host-submode]").exists();
+				assert.dom("[data-test-publish-realm-modal]").doesNotExist();
+			});
+			(0, import_qunit.test)("closing the publish dialog returns focus to the publish button, after it turns to Publishing", async function(assert) {
+				await visitOperatorMode({
+					submode: "host",
+					trail: [`${testRealmURL}Person/1.json`]
+				});
+				await click("[data-test-publish-realm-button]");
+				await click("[data-test-default-domain-checkbox]");
+				await click("[data-test-publish-button]");
+				await waitUntil(() => find("[data-test-publish-realm-button]")?.textContent?.includes("Publishing…"));
+				await click("[data-test-publish-realm-modal] [data-test-close-modal]");
+				await waitUntil(() => document.activeElement === find("[data-test-publish-realm-button]"), { timeoutMessage: "focus never returned to the publish button" });
+				assert.dom("[data-test-publish-realm-button]").isFocused();
+				publishDeferred.fulfill();
+				await waitUntil(() => !find("[data-test-publish-realm-button]")?.textContent?.includes("Publishing…"));
+			});
+			(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.${publishedSpaceHost}/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.${publishedSpaceHost}/test/`).hasAttribute("target", "_blank");
+			});
+			(0, import_qunit.test)("publishes a dotted username to a single-label Boxel Space host", async function(assert) {
+				let matrixService = getService("matrix-service");
+				Object.defineProperty(matrixService, "userName", {
+					configurable: true,
+					get: () => "first.last"
+				});
+				let publishedURLs = [];
+				let realmServer = getService("realm-server");
+				let publishRealm = realmServer.publishRealm;
+				realmServer.publishRealm = async (sourceRealmURL, publishedRealmURL) => {
+					publishedURLs.push(publishedRealmURL);
+					return publishRealm(sourceRealmURL, publishedRealmURL);
+				};
+				publishDeferred.fulfill();
+				try {
+					await visitOperatorMode({
+						submode: "host",
+						trail: [`${testRealmURL}Person/1.json`]
+					});
+					await click("[data-test-publish-realm-button]");
+					assert.dom("[data-test-publish-realm-modal]").containsText(`https://first-last.${publishedSpaceHost}/test/`);
+					assert.dom("[data-test-publish-realm-modal]").doesNotContainText(`first.last.${publishedSpaceHost}`);
+					await click("[data-test-default-domain-checkbox]");
+					await click("[data-test-publish-button]");
+					await waitUntil(() => publishedURLs.length > 0);
+					assert.deepEqual(publishedURLs, [`https://first-last.${publishedSpaceHost}/test/`]);
+				} finally {
+					delete matrixService.userName;
+				}
+			});
+			(0, import_qunit.test)("an existing publication at a dotted two-label host preselects the single-label target", async function(assert) {
+				let matrixService = getService("matrix-service");
+				Object.defineProperty(matrixService, "userName", {
+					configurable: true,
+					get: () => "first.last"
+				});
+				let publishedURLs = [];
+				let realmServer = getService("realm-server");
+				let publishRealm = realmServer.publishRealm;
+				realmServer.publishRealm = async (sourceRealmURL, publishedRealmURL) => {
+					publishedURLs.push(publishedRealmURL);
+					return publishRealm(sourceRealmURL, publishedRealmURL);
+				};
+				publishDeferred.fulfill();
+				let restoreRealmInfo = withUpdatedTestRealmInfo({ lastPublishedAt: { [`https://first.last.${publishedSpaceHost}/test/`]: String(Date.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();
+					await click("[data-test-publish-button]");
+					await waitUntil(() => publishedURLs.length > 0);
+					assert.deepEqual(publishedURLs, [`https://first-last.${publishedSpaceHost}/test/`]);
+				} finally {
+					restoreRealmInfo();
+					delete matrixService.userName;
+				}
+			});
+			(0, import_qunit.test)("the publishing popover reports indexing and rendering progress", async function(assert) {
+				let readyDeferred = new Deferred();
+				let reportProgress;
+				getService("realm-server").waitForRealmReady = async (_url, opts) => {
+					reportProgress = opts?.onProgress;
+					await readyDeferred.promise;
+				};
+				publishDeferred.fulfill();
+				await visitOperatorMode({
+					submode: "host",
+					trail: [`${testRealmURL}Person/1.json`]
+				});
+				await click("[data-test-publish-realm-button]");
+				await click("[data-test-default-domain-checkbox]");
+				await click("[data-test-publish-button]");
+				await waitFor("[data-test-publish-realm-button].publishing");
+				assert.dom("[data-test-publish-progress-status]").hasText("Starting…", "the modal names a pass right away");
+				assert.dom("[data-test-publish-progress-status] [data-test-boxel-progress-bar]").doesNotExist("no bar until the pass reports a total");
+				await click("[data-test-publish-realm-button]");
+				await waitFor(".publishing-realm-popover");
+				assert.dom("[data-test-publish-progress-phase]").hasText("Starting", "names a pass before any reading arrives");
+				assert.dom("[data-test-publish-progress-counts]").doesNotExist("no counts until the pass reports a total");
+				reportProgress({
+					phase: "index",
+					filesCompleted: 42,
+					totalFiles: 270
+				});
+				await settled();
+				assert.dom("[data-test-publish-progress-phase]").hasText("Indexing");
+				assert.dom("[data-test-publish-progress-counts]").hasText("42 of 270 files");
+				assert.dom("[data-test-publish-progress-status]").hasText("Indexing 42 of 270 files…");
+				for (let scope of ["[data-test-publish-progress-status]", ".publishing-realm-popover"]) {
+					assert.dom(`${scope} [data-test-boxel-progress-bar]`).hasAttribute("aria-valuenow", "42");
+					assert.dom(`${scope} [data-test-boxel-progress-bar]`).hasAttribute("aria-valuemax", "270");
+				}
+				reportProgress({
+					phase: "render",
+					filesCompleted: 3,
+					totalFiles: 270
+				});
+				await settled();
+				assert.dom("[data-test-publish-progress-phase]").hasText("Rendering", "follows the publish into its second pass");
+				assert.dom("[data-test-publish-progress-counts]").hasText("3 of 270 files");
+				readyDeferred.fulfill();
+				await waitUntil(() => !document.querySelector("[data-test-publish-realm-button].publishing"));
+				assert.dom(".publishing-realm-popover").doesNotExist("the progress display goes away with the publish");
+			});
+			(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.${publishedSpaceHost}`,
+					subdomain: "custom-site-name",
+					sourceRealmURL: testRealmURL
+				});
+				let restoreRealmInfo = withUpdatedTestRealmInfo({ lastPublishedAt: {
+					[`https://testuser.${publishedSpaceHost}/test/`]: String(now),
+					[`https://custom-site-name.${publishedSpaceHost}/`]: 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 publish an unlisted link", async function(assert) {
+				let restoreUnlisted = stubUnlistedPath("k7f3qz9pbcdmnpqr");
+				let unlistedUrl = `https://testuser.${publishedSpaceHost}/k7f3qz9pbcdmnpqr/`;
+				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 waitFor("[data-test-unlisted-link-url]");
+					assert.dom("[data-test-unlisted-link-url]").hasText(unlistedUrl);
+					assert.dom("[data-test-unlisted-link-checkbox]").isNotChecked();
+					await click("[data-test-unlisted-link-checkbox]");
+					assert.dom("[data-test-unlisted-link-checkbox]").isChecked();
+					assert.dom("[data-test-publish-button]").isNotDisabled();
+					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] [data-test-open-unlisted-link-button]").hasAttribute("href", unlistedUrl).hasAttribute("target", "_blank");
+				} finally {
+					restoreUnlisted();
+				}
+			});
+			(0, import_qunit.test)("unlisted link checkbox can be checked and unchecked", async function(assert) {
+				let restoreUnlisted = stubUnlistedPath("k7f3qz9pbcdmnpqr");
+				try {
+					await visitOperatorMode({
+						submode: "host",
+						trail: [`${testRealmURL}Person/1.json`]
+					});
+					await click("[data-test-publish-realm-button]");
+					await waitFor("[data-test-unlisted-link-url]");
+					assert.dom("[data-test-unlisted-link-checkbox]").isNotChecked();
+					assert.dom("[data-test-publish-button]").isDisabled();
+					await click("[data-test-unlisted-link-checkbox]");
+					assert.dom("[data-test-unlisted-link-checkbox]").isChecked();
+					assert.dom("[data-test-publish-button]").isNotDisabled();
+					await click("[data-test-unlisted-link-checkbox]");
+					assert.dom("[data-test-unlisted-link-checkbox]").isNotChecked();
+					assert.dom("[data-test-publish-button]").isDisabled();
+				} finally {
+					restoreUnlisted();
+				}
+			});
+			(0, import_qunit.test)("can regenerate the unlisted link before publishing", async function(assert) {
+				let restoreUnlisted = stubUnlistedPath(["firstslug00000000", "secondslug0000000"]);
+				try {
+					await visitOperatorMode({
+						submode: "host",
+						trail: [`${testRealmURL}Person/1.json`]
+					});
+					await click("[data-test-publish-realm-button]");
+					await waitFor("[data-test-unlisted-link-url]");
+					assert.dom("[data-test-unlisted-link-url]").hasText(`https://testuser.${publishedSpaceHost}/firstslug00000000/`);
+					await click("[data-test-regenerate-unlisted-link-button]");
+					assert.dom("[data-test-unlisted-link-url]").hasText(`https://testuser.${publishedSpaceHost}/secondslug0000000/`);
+				} finally {
+					restoreUnlisted();
+				}
+			});
+			(0, import_qunit.test)("shows an error with retry when loading the unlisted link fails", async function(assert) {
+				let realmServer = getService("realm-server");
+				let original = realmServer.allocateUnlistedPath;
+				let shouldFail = true;
+				realmServer.allocateUnlistedPath = async (sourceRealmURL) => {
+					if (shouldFail) throw new Error("allocate failed");
+					return {
+						sourceRealmURL,
+						slug: "k7f3qz9pbcdmnpqr"
+					};
+				};
+				try {
+					await visitOperatorMode({
+						submode: "host",
+						trail: [`${testRealmURL}Person/1.json`]
+					});
+					await click("[data-test-publish-realm-button]");
+					await waitFor("[data-test-unlisted-link-error]");
+					assert.dom("[data-test-unlisted-link-loading]").doesNotExist();
+					assert.dom("[data-test-unlisted-link-checkbox]").isDisabled();
+					assert.dom("[data-test-retry-unlisted-link-button]").exists();
+					shouldFail = false;
+					await click("[data-test-retry-unlisted-link-button]");
+					await waitFor("[data-test-unlisted-link-url]");
+					assert.dom("[data-test-unlisted-link-error]").doesNotExist();
+					assert.dom("[data-test-unlisted-link-url]").hasText(`https://testuser.${publishedSpaceHost}/k7f3qz9pbcdmnpqr/`);
+					assert.dom("[data-test-unlisted-link-checkbox]").isNotChecked();
+					assert.dom("[data-test-unlisted-link-checkbox]").isNotDisabled();
+				} finally {
+					realmServer.allocateUnlistedPath = original;
+				}
+			});
+			(0, import_qunit.test)("preselects a previously published unlisted link on refresh", async function(assert) {
+				let now = Date.now();
+				let slug = "k7f3qz9pbcdmnpqr";
+				let unlistedUrl = `https://testuser.${publishedSpaceHost}/${slug}/`;
+				let restoreUnlisted = stubUnlistedPath(slug);
+				let restoreRealmInfo = withUpdatedTestRealmInfo({ lastPublishedAt: { [unlistedUrl]: 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]");
+					await waitFor("[data-test-unlisted-link-url]");
+					assert.dom("[data-test-unlisted-link-url]").hasText(unlistedUrl);
+					assert.dom("[data-test-unlisted-link-checkbox]").isChecked();
+					assert.dom("[data-test-publish-button]").isNotDisabled();
+				} finally {
+					restoreRealmInfo();
+					restoreUnlisted();
+				}
+			});
+			(0, import_qunit.test)("can unpublish realm", async function(assert) {
+				let restoreRealmInfo = withUpdatedTestRealmInfo({ lastPublishedAt: { [`https://testuser.${publishedSpaceHost}/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.${publishedSpaceHost}/ 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.${publishedSpaceHost}/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.${publishedSpaceHost}/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.${publishedSpaceHost}/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.${publishedSpaceHost}/test/Person/1"] [data-test-open-site-button]`).hasAttribute("href", `https://testuser.${publishedSpaceHost}/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.${publishedSpaceHost}`,
+					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(3)";
+					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.${publishedSpaceHost}/`, "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.${publishedSpaceHost}/`, "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.${publishedSpaceHost}`,
+					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.${publishedSpaceHost}`,
+					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.${publishedSpaceHost}/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)("a publish whose HTML is still rendering when the wait times out says so and records its publish time", async function(assert) {
+				getService("realm-server").waitForRealmReady = async () => {
+					throw new ReadinessTimeoutError("Timed out after 300000ms waiting for the realm to pass readiness check", { stage: "prerender-html" });
+				};
+				publishDeferred.fulfill();
+				await visitOperatorMode({
+					submode: "host",
+					trail: [`${testRealmURL}Person/1.json`]
+				});
+				await click("[data-test-publish-realm-button]");
+				await click("[data-test-default-domain-checkbox]");
+				await click("[data-test-publish-button]");
+				let defaultUrl = `https://testuser.${publishedSpaceHost}/test/`;
+				await waitFor(`[data-test-domain-publish-error="${defaultUrl}"]`);
+				assert.dom(`[data-test-domain-publish-error="${defaultUrl}"] .error-text`).hasText("Published, but the site is taking longer than usual to finish rendering. It goes live when rendering finishes.");
+				assert.dom("[data-test-last-published-at]").containsText("Published", "the accepted publish keeps its time");
+			});
+			(0, import_qunit.test)("a readiness timeout after rendering stalls shows its own reason", async function(assert) {
+				let reason = "Timed out after 300000ms waiting for the realm to pass readiness check, with no progress for the last 300000ms: HTTP 503 (not ready: prerender-html)";
+				getService("realm-server").waitForRealmReady = async () => {
+					throw new ReadinessTimeoutError(reason, {
+						stage: "prerender-html",
+						stalled: true
+					});
+				};
+				publishDeferred.fulfill();
+				await visitOperatorMode({
+					submode: "host",
+					trail: [`${testRealmURL}Person/1.json`]
+				});
+				await click("[data-test-publish-realm-button]");
+				await click("[data-test-default-domain-checkbox]");
+				await click("[data-test-publish-button]");
+				let defaultUrl = `https://testuser.${publishedSpaceHost}/test/`;
+				await waitFor(`[data-test-domain-publish-error="${defaultUrl}"]`);
+				assert.dom(`[data-test-domain-publish-error="${defaultUrl}"] .error-text`).hasText(reason);
+				assert.dom("[data-test-last-published-at]").containsText("Published");
+			});
+			(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.${publishedSpaceHost}`,
+					subdomain: "my-custom-site",
+					sourceRealmURL: testRealmURL
+				});
+				let defaultUrl = `https://testuser.${publishedSpaceHost}/test/`;
+				let customUrl = `https://my-custom-site.${publishedSpaceHost}/`;
+				realmServer.publishRealm = async (_sourceURL, publishedURL) => {
+					await publishDeferred.promise;
+					if (publishedURL === customUrl) throw new Error("Custom domain validation failed");
+					return {
+						sourceRealmURL: _sourceURL,
+						publishedRealmURL: publishedURL,
+						publishedRealmId: "1",
+						lastPublishedAt: String((/* @__PURE__ */ new Date()).getTime()),
+						status: "published"
+					};
+				};
+				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.${publishedSpaceHost}`,
+					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(3)").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.${publishedSpaceHost}/`).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.${publishedSpaceHost}`,
+					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(3)").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.${publishedSpaceHost}`,
+					subdomain: "my-custom-site",
+					sourceRealmURL: testRealmURL
+				});
+				let restoreRealmInfo = withUpdatedTestRealmInfo({ lastPublishedAt: { [`https://my-custom-site.${publishedSpaceHost}/`]: ((/* @__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(3) .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(3) .not-published-yet").exists();
+					assert.dom("[data-test-publish-realm-modal] .domain-option:nth-of-type(3)").containsText("Not published yet");
+				} finally {
+					restoreRealmInfo();
+					realmServer.fetchBoxelClaimedDomain = originalFetchClaimed;
+				}
+			});
+		});
+	});
+});
+//#endregion