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

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

@@ -1,1342 +0,0 @@
-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, 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-Dd8k0DNa.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)("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