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

package/bundled-test-harness/assets/host-mode-test-BmkN2PCJ.js

@@ -0,0 +1,831 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Ir as testHostModeRealmURL, Rc as Deferred } from "./runtime-common-BTaLJEw-.js";
+import { t as getOwner } from "./owner-BT6cj890.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory, S as on } from "./index-DaCZcoCY-CgzbilMy.js";
+import { n as src_default } from "./src-DPaAwa4H.js";
+import "./modifier-D0EP-FQ7.js";
+import "./component-BJO47HTh.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as HostModeService } from "./host-mode-service-B4bisRdR.js";
+import { M as waitUntil, T as settled, c as triggerKeyEvent, d as click, k as visit, n as scrollTo, o as waitFor, y as currentURL } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { D as realmConfigCardJSON, Et as percySnapshot, F as setupLocalIndexing, I as setupOnSave, a as SYSTEM_CARD_FIXTURE_CONTENTS, ct as setupApplicationTest, j as setupAcceptanceTestRealm, mt as setupAuthEndpoints, t as setupMockMatrix, y as fixtureImageURL, z as setupUserSubscription } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { t as getPageTitle } from "./test-support-C3PTOFHZ.js";
+import { t as viewCardDemoCardSource } from "./view-card-demo-Dt06d2YH.js";
+//#region tests/acceptance/c63cc76ab4.css
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+//#endregion
+//#region tests/acceptance/host-mode-test.gts
+var testHostModeRealmURLWithoutRealm = testHostModeRealmURL.replace(/\/test\/?$/, "");
+var StubHostModeService = class extends HostModeService {
+	get isActive() {
+		return true;
+	}
+	get hostModeOrigin() {
+		return removeTrailingSlash(testHostModeRealmURLWithoutRealm);
+	}
+};
+var StubCustomSubdomainHostModeService = class extends StubHostModeService {
+	get hostModeOrigin() {
+		return removeTrailingSlash(testHostModeRealmURL);
+	}
+};
+var StubRoutingHostModeService = class extends StubHostModeService {
+	get hostRoutingMap() {
+		return [
+			{
+				path: "/test/terms",
+				id: `${testHostModeRealmURL}Pet/mango`
+			},
+			{
+				path: "/test/tos",
+				redirectTo: "/test/terms",
+				statusCode: 302
+			},
+			{
+				path: "/test/docs",
+				redirectTo: "/test/terms?section=intro",
+				statusCode: 302
+			},
+			{
+				path: "/test/blog",
+				redirectTo: "https://boxel.example/posts",
+				statusCode: 301
+			}
+		];
+	}
+};
+var StubHijackedOriginHostModeService = class extends StubRoutingHostModeService {
+	get hostModeOrigin() {
+		return "https://attacker.example";
+	}
+};
+(0, import_qunit.module)("Acceptance | host mode tests", function(hooks) {
+	setupApplicationTest(hooks);
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testHostModeRealmURL]
+	});
+	let { setActiveRealms, setExpiresInSec, createAndJoinRoom } = mockMatrixUtils;
+	hooks.beforeEach(function() {
+		let owner = getOwner(this);
+		owner.unregister?.("service:host-mode-service");
+		owner.register("service:host-mode-service", StubHostModeService);
+	});
+	hooks.beforeEach(async function() {
+		createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "room-test"
+		});
+		setupUserSubscription();
+		setupAuthEndpoints();
+		setExpiresInSec(3600);
+		let loader = getService("loader-service").loader;
+		let cardApi;
+		let string;
+		cardApi = await loader.import("@cardstack/base/card-api");
+		string = await loader.import("@cardstack/base/string");
+		let { field, contains, CardDef, Component } = cardApi;
+		let { default: StringField } = string;
+		class Pet extends CardDef {
+			static displayName = "Pet";
+			static headerColor = "#355e3b";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(StringField, { computeVia: function() {
+						return this.name;
+					} });
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static embedded = class Embedded extends Component {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "UGGFKzPi",
+						"block": "[[[10,\"h3\"],[15,\"data-test-pet\",[30,1,[\"name\"]]],[12],[1,\"\\n  \"],[8,[30,2,[\"name\"]],null,null,null],[1,\"\\n\"],[13]],[\"@model\",\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/acceptance/host-mode-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+			static isolated = class Isolated extends Component {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "BxQla0Sh",
+						"block": "[[[10,0],[14,0,\"pet-isolated\"],[14,\"data-scopedcss-74d6e98ba4-fb8b4d7f1e\",\"\"],[12],[1,\"\\n  \"],[10,\"h2\"],[15,\"data-test-pet-isolated\",[30,1,[\"name\"]]],[14,\"data-scopedcss-74d6e98ba4-fb8b4d7f1e\",\"\"],[12],[1,\"\\n    \"],[8,[30,2,[\"name\"]],[[24,\"data-scopedcss-74d6e98ba4-fb8b4d7f1e\",\"\"]],null,null],[1,\"\\n  \"],[13],[1,\"\\n\"],[13],[1,\"\\n\"]],[\"@model\",\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/acceptance/host-mode-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class TallStackCard extends CardDef {
+			static displayName = "Tall Stack Card";
+			static {
+				decorateFieldV2(this.prototype, "targetCardURL", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#targetCardURL = (initializeDeferredDecorator(this, "targetCardURL"), void 0);
+			static isolated = class Isolated extends Component {
+				openTarget = () => {
+					let target = this.args.model.targetCardURL;
+					if (target) this.args.viewCard?.(new URL(target));
+				};
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "5amp2V0u",
+						"block": "[[[10,\"article\"],[14,0,\"tall-stack-card\"],[14,\"data-scopedcss-74d6e98ba4-ba7db09379\",\"\"],[12],[1,\"\\n  \"],[11,\"button\"],[24,\"data-test-tall-stack-card-open\",\"\"],[24,\"data-scopedcss-74d6e98ba4-ba7db09379\",\"\"],[24,4,\"button\"],[4,[32,0],[\"click\",[30,0,[\"openTarget\"]]],null],[12],[1,\"Open next\"],[13],[1,\"\\n\"],[13],[1,\"\\n\"]],[],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/acceptance/host-mode-test.gts",
+						"scope": () => [on],
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class Whitepaper extends CardDef {
+			static displayName = "Boxel Whitepaper";
+			static prefersWideFormat = true;
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(StringField, { computeVia: function() {
+						return "Boxel Whitepaper";
+					} });
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static isolated = class Isolated extends Component {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "I6B1h388",
+						"block": "[[[10,\"article\"],[14,0,\"whitepaper\"],[14,\"data-test-whitepaper\",\"\"],[14,\"data-scopedcss-74d6e98ba4-6a5c19e5ce\",\"\"],[12],[1,\"\\n  \"],[10,\"header\"],[14,0,\"wp-header\"],[14,\"data-scopedcss-74d6e98ba4-6a5c19e5ce\",\"\"],[12],[1,\"\\n    \"],[10,\"h1\"],[14,\"data-scopedcss-74d6e98ba4-6a5c19e5ce\",\"\"],[12],[1,\"Boxel Whitepaper\"],[13],[1,\"\\n    \"],[10,2],[14,0,\"wp-subtitle\"],[14,\"data-scopedcss-74d6e98ba4-6a5c19e5ce\",\"\"],[12],[1,\"A System for Composable Software in the Age\\n      of Abundant Code\"],[13],[1,\"\\n    \"],[10,2],[14,0,\"wp-byline\"],[14,\"data-scopedcss-74d6e98ba4-6a5c19e5ce\",\"\"],[12],[1,\"By Chris Tse, Cardstack Foundation — January\\n      2026\"],[13],[1,\"\\n  \"],[13],[1,\"\\n  \"],[10,\"section\"],[14,\"data-scopedcss-74d6e98ba4-6a5c19e5ce\",\"\"],[12],[1,\"\\n    \"],[10,\"h2\"],[14,\"data-scopedcss-74d6e98ba4-6a5c19e5ce\",\"\"],[12],[1,\"Executive Summary\"],[13],[1,\"\\n    \"],[10,2],[14,\"data-scopedcss-74d6e98ba4-6a5c19e5ce\",\"\"],[12],[1,\"We are witnessing the most significant shift in software\\n      development since the invention of high-level programming\\n      languages. Large language models (LLMs) can now generate\\n      functional code in seconds. Yet the infrastructure surrounding\\n      that code—the databases, the deployment pipelines, the security\\n      models, the economic relationships—remains trapped in paradigms\\n      from the 1990s.\"],[13],[1,\"\\n    \"],[10,2],[14,\"data-scopedcss-74d6e98ba4-6a5c19e5ce\",\"\"],[12],[1,\"The result is a peculiar kind of friction. You can ask Claude\\n      to write you a React component in thirty seconds, but deploying\\n      that component to production still requires navigating a maze of\\n      Git repositories, CI/CD pipelines, environment variables, SSL\\n      certificates, and cloud provider dashboards. The intelligence\\n      has arrived, but the architecture hasn't caught up.\"],[13],[1,\"\\n    \"],[10,2],[14,\"data-scopedcss-74d6e98ba4-6a5c19e5ce\",\"\"],[12],[1,\"Boxel is what comes next: a complete environment where\\n      AI-generated software can be created, run, evolved, and\\n      monetized without ever leaving a coherent system. Not another\\n      tool to add to your stack—a replacement for the stack itself.\"],[13],[1,\"\\n  \"],[13],[1,\"\\n  \"],[10,\"section\"],[14,\"data-scopedcss-74d6e98ba4-6a5c19e5ce\",\"\"],[12],[1,\"\\n    \"],[10,\"h2\"],[14,\"data-scopedcss-74d6e98ba4-6a5c19e5ce\",\"\"],[12],[1,\"1. The Fragmentation Problem\"],[13],[1,\"\\n    \"],[10,2],[14,\"data-scopedcss-74d6e98ba4-6a5c19e5ce\",\"\"],[12],[1,\"Open your browser tabs right now. If you're building anything\\n      with AI, you probably have ChatGPT or Claude open for ideation\\n      and code generation. Cursor or Windsurf for editing that code in\\n      context. V0 or Lovable for generating UI components. GitHub for\\n      version control. Vercel or Netlify for deployment. Notion or\\n      Confluence for documentation. Figma for design. Slack or Discord\\n      for communication.\"],[13],[1,\"\\n    \"],[10,2],[14,\"data-scopedcss-74d6e98ba4-6a5c19e5ce\",\"\"],[12],[1,\"Each of these tools is excellent at what it does. Each\\n      represents millions of dollars in engineering investment and\\n      years of refinement. And each is a silo.\"],[13],[1,\"\\n    \"],[10,2],[14,\"data-scopedcss-74d6e98ba4-6a5c19e5ce\",\"\"],[12],[1,\"The workflow: describe an idea to ChatGPT, copy the code into\\n      Cursor, commit to GitHub, deploy to Vercel, document in Notion,\\n      share in Slack. At each boundary, you lose context. The AI that\\n      helped you write the code doesn't know how you deployed it. The\\n      documentation system doesn't understand the code it describes.\"],[13],[1,\"\\n    \"],[10,2],[14,\"data-scopedcss-74d6e98ba4-6a5c19e5ce\",\"\"],[12],[1,\"The irony is acute. We have AI systems capable of understanding\\n      complex software in its entirety—but we force them to operate\\n      through disconnected interfaces, each with its own\\n      authentication, its own data model, its own limitations. We have\\n      given AI the ability to think holistically while constraining it\\n      to act in fragments.\"],[13],[1,\"\\n  \"],[13],[1,\"\\n\"],[13],[1,\"\\n\\n\"]],[],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/acceptance/host-mode-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		await setupAcceptanceTestRealm({
+			realmURL: testHostModeRealmURL,
+			mockMatrixUtils,
+			permissions: { "*": ["read"] },
+			contents: {
+				...SYSTEM_CARD_FIXTURE_CONTENTS,
+				"pet.gts": { Pet },
+				"whitepaper.gts": { Whitepaper },
+				"view-card-demo.gts": viewCardDemoCardSource,
+				"tall-stack-card.gts": { TallStackCard },
+				"TallStackCard/1.json": { data: {
+					attributes: { targetCardURL: `${testHostModeRealmURL}TallStackCard/2.json` },
+					meta: { adoptsFrom: {
+						module: `${testHostModeRealmURL}tall-stack-card`,
+						name: "TallStackCard"
+					} }
+				} },
+				"TallStackCard/2.json": { data: {
+					attributes: {},
+					meta: { adoptsFrom: {
+						module: `${testHostModeRealmURL}tall-stack-card`,
+						name: "TallStackCard"
+					} }
+				} },
+				"TallStackCard/3.json": { data: {
+					attributes: { targetCardURL: `${testHostModeRealmURL}TallStackCard/4.json` },
+					meta: { adoptsFrom: {
+						module: `${testHostModeRealmURL}tall-stack-card`,
+						name: "TallStackCard"
+					} }
+				} },
+				"TallStackCard/4.json": { data: {
+					attributes: {},
+					meta: { adoptsFrom: {
+						module: `${testHostModeRealmURL}tall-stack-card`,
+						name: "TallStackCard"
+					} }
+				} },
+				"Whitepaper/index.json": { data: {
+					type: "card",
+					attributes: {},
+					meta: { adoptsFrom: {
+						module: `${testHostModeRealmURL}whitepaper`,
+						name: "Whitepaper"
+					} }
+				} },
+				"Pet/mango.json": { data: {
+					attributes: { name: "Mango" },
+					meta: { adoptsFrom: {
+						module: `${testHostModeRealmURL}pet`,
+						name: "Pet"
+					} }
+				} },
+				"ViewCardDemo/index.json": { data: {
+					type: "card",
+					attributes: {
+						cardTitle: "Primary View Demo",
+						targetCardURL: `${testHostModeRealmURL}ViewCardDemo/secondary.json`
+					},
+					meta: { adoptsFrom: {
+						module: `${testHostModeRealmURL}view-card-demo`,
+						name: "ViewCardDemo"
+					} }
+				} },
+				"ViewCardDemo/secondary.json": { data: {
+					type: "card",
+					attributes: {
+						cardTitle: "Secondary View Demo",
+						targetCardURL: `${testHostModeRealmURL}ViewCardDemo/tertiary.json`
+					},
+					meta: { adoptsFrom: {
+						module: `${testHostModeRealmURL}view-card-demo`,
+						name: "ViewCardDemo"
+					} }
+				} },
+				"ViewCardDemo/tertiary.json": { data: {
+					type: "card",
+					attributes: {
+						cardTitle: "Tertiary View Demo",
+						targetCardURL: `${testHostModeRealmURL}ViewCardDemo/index.json`
+					},
+					meta: { adoptsFrom: {
+						module: `${testHostModeRealmURL}view-card-demo`,
+						name: "ViewCardDemo"
+					} }
+				} },
+				"index.json": { data: {
+					type: "card",
+					meta: { adoptsFrom: {
+						module: "@cardstack/base/cards-grid",
+						name: "CardsGrid"
+					} }
+				} },
+				"broken-card.gts": `
+          import { contains, field, Component, CardDef } from '@cardstack/base/card-api';
+          import StringField from '@cardstack/base/string';
+          export class BrokenCard extends CardDef {
+            static displayName = 'BrokenCard';
+            @field name = contains(StringField);
+            static isolated = class Isolated extends Component<typeof this> {
+              <template><div>{{this.triggerError}}</div></template>
+              get triggerError() {
+                throw new Error('Intentional rendering error');
+              }
+            };
+          }
+        `,
+				"BrokenCard/broken.json": { data: {
+					attributes: { name: "Broken" },
+					meta: { adoptsFrom: {
+						module: `${testHostModeRealmURL}broken-card`,
+						name: "BrokenCard"
+					} }
+				} },
+				"missing-dep-card.gts": `
+          import { Component, CardDef } from '@cardstack/base/card-api';
+          import { MissingThing } from './missing-dependency';
+          export class MissingDepCard extends CardDef {
+            static displayName = 'MissingDepCard';
+            static isolated = class Isolated extends Component<typeof this> {
+              <template><div>{{MissingThing}}</div></template>
+            };
+          }
+        `,
+				"MissingDepCard/instance.json": { data: { meta: { adoptsFrom: {
+					module: `${testHostModeRealmURL}missing-dep-card`,
+					name: "MissingDepCard"
+				} } } },
+				"spring-guide.md": "# Spring Guide\n\nSprings settle toward their target.\n",
+				"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"
+				})
+			}
+		});
+		setActiveRealms([testHostModeRealmURL]);
+	});
+	(0, import_qunit.test)("visiting a default width card in host mode", async function(assert) {
+		await visit("/test/Pet/mango.json");
+		assert.dom("[data-test-host-mode-content]").hasStyle({ "background-image": `url("${fixtureImageURL("/test-fixtures/realm-images/pawel-czerwinski-Ly-ZLa-A5jti-Y-unsplash.jpg")}")` });
+		assert.dom(`[data-test-host-mode-card="${testHostModeRealmURL}Pet/mango"]`).exists();
+		assert.dom("[data-test-host-mode-content]").hasNoClass("is-wide");
+		assert.strictEqual(getPageTitle(), "Mango");
+		await percySnapshot(assert);
+	});
+	(0, import_qunit.test)("visiting a full width card in host mode", async function(assert) {
+		await visit("/test");
+		assert.dom(`[data-test-host-mode-card="${testHostModeRealmURL}index"]`).exists();
+		assert.strictEqual(getPageTitle(), "Test Workspace B");
+		assert.dom("[data-test-host-mode-content]").hasClass("is-wide");
+		await percySnapshot(assert);
+	});
+	(0, import_qunit.test)("host mode fetches the card head from the search API and injects it", async function(assert) {
+		let cardUrl = `${testHostModeRealmURL}Pet/mango`;
+		let htmlId = `${cardUrl}#head#${testHostModeRealmURL}pet/Pet`;
+		let capturedHeadQuery;
+		let realFetch = globalThis.fetch;
+		globalThis.fetch = async (input, init) => {
+			if ((typeof input === "string" ? input : input?.url ?? "").includes("_federated-search") && init?.body) {
+				let body = JSON.parse(init.body);
+				if (body?.filter?.eq?.htmlQuery) {
+					capturedHeadQuery = body;
+					return new Response(JSON.stringify({
+						data: [{
+							type: "entry",
+							id: cardUrl,
+							relationships: { html: { data: [{
+								type: "html",
+								id: htmlId
+							}] } }
+						}],
+						included: [{
+							type: "html",
+							id: htmlId,
+							attributes: {
+								format: "head",
+								html: "<title data-test-card-head-title>Mango</title>\n<meta property=\"og:title\" content=\"Mango\" />"
+							}
+						}],
+						meta: { page: { total: 1 } }
+					}), {
+						status: 200,
+						headers: { "content-type": "application/vnd.card+json" }
+					});
+				}
+			}
+			return realFetch(input, init);
+		};
+		let headStart = document.createElement("meta");
+		headStart.setAttribute("data-boxel-head-start", "");
+		let headEnd = document.createElement("meta");
+		headEnd.setAttribute("data-boxel-head-end", "");
+		document.head.append(headStart, headEnd);
+		try {
+			await visit("/test/Pet/mango.json");
+			assert.deepEqual(capturedHeadQuery?.fields, { entry: ["html"] }, "requests only the html branch");
+			assert.strictEqual(capturedHeadQuery?.filter?.eq?.htmlQuery?.eq?.format, "head", "selects the head rendering");
+			assert.deepEqual(capturedHeadQuery?.cardUrls, [`${cardUrl}.json`], "scoped to the visited card");
+			let ogTitle = document.head.querySelector("meta[property=\"og:title\"]");
+			assert.ok(ogTitle, "the head markup from the search response is injected");
+			assert.strictEqual(ogTitle?.getAttribute("content"), "Mango", "the injected head markup is the visited card head");
+			let hostModeService = getService("host-mode-service");
+			assert.true(hostModeService.headTemplateContainsTitle, "the fetched head markup carries a title");
+		} finally {
+			globalThis.fetch = realFetch;
+			for (let node = headStart.nextSibling; node && node !== headEnd;) {
+				let next = node.nextSibling;
+				node.remove();
+				node = next;
+			}
+			headStart.remove();
+			headEnd.remove();
+		}
+	});
+	(0, import_qunit.test)("visiting a Markdown file in host mode renders it", async function(assert) {
+		let fileURL = `${testHostModeRealmURL}spring-guide.md`;
+		await visit("/test/spring-guide.md");
+		assert.dom(`[data-test-host-mode-card="${fileURL}"]`).exists();
+		assert.dom(`[data-test-host-mode-card="${fileURL}"]`).containsText("Springs settle toward their target.");
+		assert.dom(".host-mode-card").doesNotContainText("Loading card…");
+	});
+	(0, import_qunit.test)("a Markdown file in the stack renders and is named in the breadcrumbs", async function(assert) {
+		let fileURL = `${testHostModeRealmURL}spring-guide.md`;
+		await visit(`/test/Pet/mango.json?hostModeStack=${encodeURIComponent(JSON.stringify([fileURL]))}`);
+		assert.dom(`[data-test-host-mode-stack-item="${fileURL}"]`).containsText("Springs settle toward their target.");
+		assert.dom(`[data-test-host-mode-stack-item="${fileURL}"]`).doesNotContainText("Loading card…");
+		assert.dom(`[data-test-host-mode-breadcrumb="${fileURL}"]`).containsText("spring-guide.md");
+	});
+	(0, import_qunit.test)("visiting a non-existent card shows an error", async function(assert) {
+		let store = getService("store");
+		let originalGet = store.get.bind(store);
+		let gate = new Deferred();
+		let pending = new Deferred();
+		let targetId = `${testHostModeRealmURL}Pet/non-existent.json`;
+		store.get = async (...args) => {
+			let [id] = args;
+			if (id === targetId) {
+				pending.fulfill();
+				await gate.promise;
+			}
+			return originalGet(...args);
+		};
+		let visitPromise = visit("/test/Pet/non-existent.json");
+		await pending.promise;
+		assert.dom("[data-test-host-loading]").doesNotExist("Loading screen is never shown on host mode");
+		gate.fulfill();
+		await visitPromise;
+		await waitFor("[data-test-host-mode-404]");
+		assert.dom("[data-test-host-mode-404]").containsText("This page could not be found.");
+		assert.strictEqual(getPageTitle(), `Card not found: ${testHostModeRealmURL}Pet/non-existent`);
+		assert.dom("[data-test-host-loading]").doesNotExist();
+		store.get = originalGet;
+	});
+	(0, import_qunit.test)("visiting a card whose dependency is missing surfaces the error rather than a 404", async function(assert) {
+		await visit("/test/MissingDepCard/instance.json");
+		await waitFor("[data-test-card-error]");
+		assert.dom("[data-test-host-mode-404]").doesNotExist("a missing dependency is not a missing card");
+		assert.dom("[data-test-card-error]").containsText("This card contains an error");
+		assert.strictEqual(getPageTitle(), `Error rendering ${testHostModeRealmURL}MissingDepCard/instance`);
+	});
+	(0, import_qunit.test)("visiting a card with a rendering error shows an error", async function(assert) {
+		await visit("/test/BrokenCard/broken.json");
+		await waitFor("[data-test-card-error]");
+		assert.dom("[data-test-card-error]").exists();
+		assert.dom("[data-test-card-error]").containsText("This card contains an error");
+		assert.strictEqual(getPageTitle(), `Error rendering ${testHostModeRealmURL}BrokenCard/broken`);
+	});
+	(0, import_qunit.test)("invoking viewCard from a card stacks the linked card", async function(assert) {
+		let targetStackId = `${testHostModeRealmURL}ViewCardDemo/secondary`;
+		await visit("/test/ViewCardDemo/index.json");
+		await waitFor("[data-test-view-card-demo-button]");
+		assert.dom(`[data-test-host-mode-stack-item="${targetStackId}"]`).doesNotExist();
+		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)("clicking a card in card list stacks it", async function(assert) {
+		await visit("/test");
+		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="${testHostModeRealmURL}Pet/mango"]`).doesNotExist();
+		await click(`[data-test-cards-grid-item="${testHostModeRealmURL}Pet/mango"]`);
+		await waitFor(`[data-test-host-mode-stack-item="${testHostModeRealmURL}Pet/mango"]`);
+		assert.dom(`[data-test-host-mode-stack-item="${testHostModeRealmURL}Pet/mango"]`).exists();
+		assert.dom("[data-test-pet-isolated=\"Mango\"]").exists();
+	});
+	(0, import_qunit.test)("viewCard tabs persist after stacking and closing cards in host mode", async function(assert) {
+		let primaryCardId = `${testHostModeRealmURL}ViewCardDemo/index`;
+		let firstStackCardId = `${testHostModeRealmURL}ViewCardDemo/secondary`;
+		let secondStackCardId = `${testHostModeRealmURL}ViewCardDemo/tertiary`;
+		await visit("/test/ViewCardDemo/index.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 the primary card from deeper in the trail closes the stack", async function(assert) {
+		let primaryCardSelector = `[data-test-host-mode-card="${testHostModeRealmURL}ViewCardDemo/index"]`;
+		let firstStackSelector = `[data-test-host-mode-stack-item="${testHostModeRealmURL}ViewCardDemo/secondary"]`;
+		let secondStackSelector = `[data-test-host-mode-stack-item="${testHostModeRealmURL}ViewCardDemo/tertiary"]`;
+		await visit("/test/ViewCardDemo/index.json");
+		await waitFor(`${primaryCardSelector} [data-test-view-card-demo-button]`);
+		await click(`${primaryCardSelector} [data-test-view-card-demo-button]`);
+		await waitFor(`${firstStackSelector} [data-test-view-card-demo-button]`);
+		await click(`${firstStackSelector} [data-test-view-card-demo-button]`);
+		await waitFor(`${secondStackSelector} [data-test-view-card-demo-button]`);
+		await click(`${secondStackSelector} [data-test-view-card-demo-button]`);
+		await waitUntil(() => !document.querySelector(secondStackSelector));
+		assert.dom(firstStackSelector).doesNotExist("the whole trail unwinds to the root rather than stacking the primary card again");
+		assert.dom(primaryCardSelector).exists();
+		assert.strictEqual(new URL(currentURL(), "http://localhost").searchParams.get("hostModeStack"), null, "the emptied stack drops out of the query param");
+	});
+	(0, import_qunit.test)("viewing a card below it in the trail unwinds to that card", async function(assert) {
+		let belowCardId = `${testHostModeRealmURL}ViewCardDemo/secondary`;
+		let topCardId = `${testHostModeRealmURL}ViewCardDemo/index`;
+		await visit(`/test/ViewCardDemo/tertiary.json?hostModeStack=${encodeURIComponent(JSON.stringify([belowCardId, topCardId]))}`);
+		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");
+		assert.strictEqual(new URL(currentURL(), "http://localhost").searchParams.get("hostModeStack"), JSON.stringify([belowCardId]), "the unwound trail is what persists to the query param");
+	});
+	(0, import_qunit.test)("clicking the scrim closes the top card of the trail", async function(assert) {
+		let firstStackCardId = `${testHostModeRealmURL}ViewCardDemo/secondary`;
+		let secondStackCardId = `${testHostModeRealmURL}ViewCardDemo/tertiary`;
+		await visit(`/test/ViewCardDemo/index.json?hostModeStack=${encodeURIComponent(JSON.stringify([firstStackCardId, secondStackCardId]))}`);
+		let secondStackSelector = `[data-test-host-mode-stack-item="${secondStackCardId}"]`;
+		await waitFor(secondStackSelector);
+		await click("[data-test-host-mode-stack] .inner");
+		await waitUntil(() => !document.querySelector(secondStackSelector));
+		assert.dom(`[data-test-host-mode-stack-item="${firstStackCardId}"]`).exists("only the top card closes");
+	});
+	(0, import_qunit.test)("closing a card that appears twice in the trail closes the visible copy", async function(assert) {
+		let repeatedCardId = `${testHostModeRealmURL}ViewCardDemo/secondary`;
+		let middleCardId = `${testHostModeRealmURL}ViewCardDemo/tertiary`;
+		await visit(`/test/ViewCardDemo/index.json?hostModeStack=${encodeURIComponent(JSON.stringify([
+			repeatedCardId,
+			middleCardId,
+			repeatedCardId
+		]))}`);
+		await waitFor("[data-test-host-mode-stack-item-index=\"2\"]");
+		await click("[data-test-host-mode-stack] .inner");
+		await waitUntil(() => !document.querySelector("[data-test-host-mode-stack-item-index=\"2\"]"));
+		assert.dom("[data-test-host-mode-stack-item-index=\"1\"]").hasAttribute("data-test-host-mode-stack-item", middleCardId, "the card below the closed copy becomes the top of the trail");
+		assert.dom("[data-test-host-mode-stack-item-index=\"0\"]").hasAttribute("data-test-host-mode-stack-item", repeatedCardId, "the buried copy survives");
+		assert.strictEqual(new URL(currentURL(), "http://localhost").searchParams.get("hostModeStack"), JSON.stringify([repeatedCardId, middleCardId]), "the persisted trail lost the top copy, not the bottom one");
+	});
+	(0, import_qunit.test)("a card opened on the stack starts at its top, and closing it returns the card below to where it was left", async function(assert) {
+		let firstCardId = `${testHostModeRealmURL}TallStackCard/1`;
+		let secondCardId = `${testHostModeRealmURL}TallStackCard/2`;
+		let scroller = "[data-test-host-mode-stack-scroller]";
+		await visit(`/test/Pet/mango.json?hostModeStack=${encodeURIComponent(JSON.stringify([firstCardId]))}`);
+		await waitFor(`[data-test-host-mode-stack-item="${firstCardId}"]`);
+		await scrollTo(scroller, 0, 500);
+		await click(`[data-test-host-mode-stack-item="${firstCardId}"] [data-test-tall-stack-card-open]`);
+		await waitFor(`[data-test-host-mode-stack-item="${secondCardId}"]`);
+		await settled();
+		assert.strictEqual(document.querySelector(scroller).scrollTop, 0, "the opened card starts at its top");
+		await click(`[data-test-host-mode-stack-item="${secondCardId}"] [data-test-host-stack-item-close-button]`);
+		await waitUntil(() => !document.querySelector(`[data-test-host-mode-stack-item="${secondCardId}"]`));
+		await settled();
+		assert.strictEqual(document.querySelector(scroller).scrollTop, 500, "the card below is back where it was left");
+	});
+	(0, import_qunit.test)("two copies of a card in the trail keep separate scroll positions", async function(assert) {
+		let repeatedCardId = `${testHostModeRealmURL}TallStackCard/3`;
+		let middleCardId = `${testHostModeRealmURL}TallStackCard/2`;
+		let pushedCardId = `${testHostModeRealmURL}TallStackCard/4`;
+		let scroller = "[data-test-host-mode-stack-scroller]";
+		let scrollTop = () => document.querySelector(scroller).scrollTop;
+		let closeTopCard = async (index) => {
+			await click(`[data-test-host-mode-stack-item-index="${index}"] [data-test-host-stack-item-close-button]`);
+			await waitUntil(() => !document.querySelector(`[data-test-host-mode-stack-item-index="${index}"]`));
+			await settled();
+		};
+		await visit(`/test/Pet/mango.json?hostModeStack=${encodeURIComponent(JSON.stringify([
+			repeatedCardId,
+			middleCardId,
+			repeatedCardId
+		]))}`);
+		await waitFor("[data-test-host-mode-stack-item-index=\"2\"]");
+		await scrollTo(scroller, 0, 500);
+		await click(`[data-test-host-mode-stack-item-index="2"] [data-test-tall-stack-card-open]`);
+		await waitFor(`[data-test-host-mode-stack-item="${pushedCardId}"]`);
+		await settled();
+		await closeTopCard(3);
+		assert.strictEqual(scrollTop(), 500, "the top copy is back where it was");
+		await closeTopCard(2);
+		assert.strictEqual(scrollTop(), 0, "the middle card is at its top");
+		await closeTopCard(1);
+		assert.strictEqual(scrollTop(), 0, "the lower copy keeps its own position, not the top copy’s");
+	});
+	(0, import_qunit.test)("when host mode is narrow, only the top stack card shows, at full width", async function(assert) {
+		let firstCardId = `${testHostModeRealmURL}TallStackCard/1`;
+		let secondCardId = `${testHostModeRealmURL}TallStackCard/2`;
+		let testRoot = document.querySelector("#ember-testing");
+		let originalWidth = testRoot.style.width;
+		testRoot.style.width = "400px";
+		try {
+			await visit(`/test/Pet/mango.json?hostModeStack=${encodeURIComponent(JSON.stringify([firstCardId, secondCardId]))}`);
+			let top = `[data-test-host-mode-stack-item="${secondCardId}"]`;
+			let buried = `[data-test-host-mode-stack-item="${firstCardId}"]`;
+			await waitFor(top);
+			await waitUntil(() => document.querySelector(buried)?.offsetWidth === 0);
+			assert.dom(buried).isNotVisible("the buried card is hidden");
+			assert.dom(top).isVisible("the top card shows");
+			assert.dom("[data-test-host-mode-breadcrumbs]").isNotVisible("the breadcrumbs are hidden");
+			let content = document.querySelector("[data-test-host-mode-content]");
+			let item = document.querySelector(top);
+			let card = item.querySelector("[data-test-host-mode-card]");
+			assert.ok(item.offsetWidth > content.offsetWidth * .9, `the top card spans nearly the full width (${item.offsetWidth} of ${content.offsetWidth})`);
+			assert.strictEqual(card.offsetWidth, item.offsetWidth, "the card fills its stack item instead of being clipped");
+		} finally {
+			testRoot.style.width = originalWidth;
+		}
+	});
+	(0, import_qunit.test)("when host mode is narrow, the primary card fits the screen", async function(assert) {
+		let testRoot = document.querySelector("#ember-testing");
+		let originalWidth = testRoot.style.width;
+		testRoot.style.width = "400px";
+		try {
+			await visit("/test/Pet/mango.json");
+			await waitFor("[data-test-host-mode-narrow]");
+			await waitFor("[data-test-host-mode-card]");
+			let content = document.querySelector("[data-test-host-mode-content]");
+			let card = document.querySelector("[data-test-host-mode-card]");
+			let style = getComputedStyle(content);
+			let innerWidth = content.clientWidth - parseFloat(style.paddingLeft) - parseFloat(style.paddingRight);
+			let cardWidth = card.getBoundingClientRect().width;
+			assert.ok(cardWidth <= innerWidth + .5, `the card stays inside host mode's gutter (${cardWidth} of ${innerWidth})`);
+		} finally {
+			testRoot.style.width = originalWidth;
+		}
+	});
+	(0, import_qunit.test)("stack state persists in query parameter", async function(assert) {
+		await visit(`/test/Pet/mango.json?hostModeStack=${encodeURIComponent(JSON.stringify([`${testHostModeRealmURL}index`]))}`);
+		assert.dom(`[data-test-host-mode-stack-item="${testHostModeRealmURL}index"]`).exists();
+		await click(`[data-test-host-mode-stack-item="${testHostModeRealmURL}index"] [data-test-host-stack-item-close-button]`);
+		assert.strictEqual(currentURL(), "/test/Pet/mango.json");
+		assert.strictEqual(new URL(currentURL(), "http://localhost").searchParams.get("hostModeStack"), null);
+	});
+	(0, import_qunit.test)("Back and Forward move the stack with the URL", async function(assert) {
+		let primary = `${testHostModeRealmURL}ViewCardDemo/index`;
+		let second = `${testHostModeRealmURL}ViewCardDemo/secondary`;
+		let third = `${testHostModeRealmURL}ViewCardDemo/tertiary`;
+		let stackItem = (id) => `[data-test-host-mode-stack-item="${id}"]`;
+		let stackParam = () => new URL(currentURL(), "http://localhost").searchParams.get("hostModeStack");
+		await visit("/test/ViewCardDemo/index.json");
+		await waitFor(`[data-test-host-mode-card="${primary}"] [data-test-view-card-demo-button]`);
+		await click(`[data-test-host-mode-card="${primary}"] [data-test-view-card-demo-button]`);
+		await waitFor(`${stackItem(second)} [data-test-view-card-demo-button]`);
+		await click(`${stackItem(second)} [data-test-view-card-demo-button]`);
+		await waitFor(stackItem(third));
+		assert.strictEqual(stackParam(), JSON.stringify([second, third]));
+		let twoDeep = currentURL();
+		await visit(`/test/ViewCardDemo/index.json?hostModeStack=${encodeURIComponent(JSON.stringify([second]))}`);
+		await waitFor(stackItem(third), { count: 0 });
+		assert.dom(stackItem(second)).exists("Back leaves the card below");
+		assert.dom(stackItem(third)).doesNotExist("and takes the top one away");
+		await visit(twoDeep);
+		await waitFor(stackItem(third));
+		assert.dom(stackItem(second)).exists("Forward keeps the card below");
+		assert.dom(stackItem(third)).exists("and brings the top one back");
+		assert.strictEqual(stackParam(), JSON.stringify([second, third]));
+	});
+	(0, import_qunit.test)("a hostModeStack that is not a list of card ids is no stack", async function(assert) {
+		let mango = `[data-test-host-mode-card="${testHostModeRealmURL}Pet/mango"]`;
+		for (let value of [
+			"{}",
+			"5",
+			"\"abc\"",
+			"[1, 2]"
+		]) {
+			await visit(`/test/Pet/mango.json?hostModeStack=${encodeURIComponent(value)}`);
+			assert.dom(mango).exists(`${value}: the page loads`);
+			assert.dom("[data-test-host-mode-stack-item]").doesNotExist(`${value}: with no stack`);
+		}
+	});
+	(0, import_qunit.test)("a card that opens takes focus, and closing it returns focus to what opened it", async function(assert) {
+		let stackSelector = `[data-test-host-mode-stack-item="${`${testHostModeRealmURL}ViewCardDemo/secondary`}"]`;
+		let openerSelector = "[data-test-view-card-demo-button]";
+		await visit("/test/ViewCardDemo/index.json");
+		await waitFor(openerSelector);
+		await click(openerSelector);
+		await waitFor(stackSelector);
+		assert.dom(stackSelector).isFocused("the opened card has focus");
+		await click(`${stackSelector} [data-test-host-stack-item-close-button]`);
+		await waitUntil(() => !document.querySelector(stackSelector));
+		assert.dom(openerSelector).isFocused("focus is back on the opener");
+	});
+	(0, import_qunit.test)("closing a card opened from a stacked card returns focus inside that card", async function(assert) {
+		let firstStackSelector = `[data-test-host-mode-stack-item="${testHostModeRealmURL}ViewCardDemo/secondary"]`;
+		let secondStackSelector = `[data-test-host-mode-stack-item="${testHostModeRealmURL}ViewCardDemo/tertiary"]`;
+		let innerOpener = `${firstStackSelector} [data-test-view-card-demo-button]`;
+		await visit("/test/ViewCardDemo/index.json");
+		await waitFor("[data-test-view-card-demo-button]");
+		await click("[data-test-view-card-demo-button]");
+		await waitFor(innerOpener);
+		await click(innerOpener);
+		await waitFor(secondStackSelector);
+		assert.dom(secondStackSelector).isFocused("the card on top has focus");
+		await click(`${secondStackSelector} [data-test-host-stack-item-close-button]`);
+		await waitUntil(() => !document.querySelector(secondStackSelector));
+		assert.dom(innerOpener).isFocused("focus is back on the control that opened it");
+	});
+	(0, import_qunit.test)("Escape closes the top card of the trail", async function(assert) {
+		let firstStackCardId = `${testHostModeRealmURL}ViewCardDemo/secondary`;
+		let secondStackCardId = `${testHostModeRealmURL}ViewCardDemo/tertiary`;
+		await visit(`/test/ViewCardDemo/index.json?hostModeStack=${encodeURIComponent(JSON.stringify([firstStackCardId, secondStackCardId]))}`);
+		let secondStackSelector = `[data-test-host-mode-stack-item="${secondStackCardId}"]`;
+		let firstStackSelector = `[data-test-host-mode-stack-item="${firstStackCardId}"]`;
+		await waitFor(secondStackSelector);
+		await triggerKeyEvent(secondStackSelector, "keydown", "Escape");
+		await waitUntil(() => !document.querySelector(secondStackSelector));
+		assert.dom(firstStackSelector).exists("only the top card closes");
+		assert.dom(firstStackSelector).isFocused("focus moves to the card now on top");
+	});
+	(0, import_qunit.test)("clicking on a stack card does not close it", async function(assert) {
+		await visit(`/test/Pet/mango.json?hostModeStack=${encodeURIComponent(JSON.stringify([`${testHostModeRealmURL}index`]))}`);
+		let stackSelector = `[data-test-host-mode-stack-item="${testHostModeRealmURL}index"]`;
+		assert.dom(stackSelector).exists();
+		await click(stackSelector);
+		assert.dom(stackSelector).exists();
+	});
+	(0, import_qunit.test)("stack does not exist when there are no stacked cards", async function(assert) {
+		await visit("/test/Pet/mango.json");
+		assert.dom("[data-test-host-mode-stack]").doesNotExist();
+	});
+	(0, import_qunit.test)("scroll position is restored on card container after hydration", async function(assert) {
+		let start = document.createElement("div");
+		start.id = "boxel-isolated-start";
+		let end = document.createElement("div");
+		end.id = "boxel-isolated-end";
+		let fakeContainer = document.createElement("div");
+		fakeContainer.style.cssText = "height: 200px; overflow-y: auto;";
+		fakeContainer.innerHTML = "<div style=\"height: 2000px;\"></div>";
+		document.body.appendChild(start);
+		document.body.appendChild(fakeContainer);
+		document.body.appendChild(end);
+		fakeContainer.scrollTop = 150;
+		let testStyle = document.createElement("style");
+		testStyle.setAttribute("data-test-scroll-override", "");
+		testStyle.textContent = "[data-test-host-mode-card-loaded] { height: 400px !important; max-height: 400px !important; }";
+		document.head.appendChild(testStyle);
+		try {
+			await visit("/test/Whitepaper/index.json");
+			await waitFor("[data-test-whitepaper]");
+			assert.dom("[data-host-mode-card-scroll-container]").exists();
+			let cardContainer = document.querySelector("[data-host-mode-card-scroll-container]");
+			assert.strictEqual(cardContainer.scrollTop, 150, "scroll position from prerendered container is restored on the hydrated card scroll host");
+		} finally {
+			document.querySelector("[data-test-scroll-override]")?.remove();
+			start.remove();
+			end.remove();
+			fakeContainer.remove();
+		}
+	});
+	(0, import_qunit.module)("with redirect routing rules", function(hooks) {
+		hooks.beforeEach(function() {
+			let owner = getOwner(this);
+			owner.unregister?.("service:host-mode-service");
+			owner.register("service:host-mode-service", StubRoutingHostModeService);
+		});
+		(0, import_qunit.test)("a serve rule still renders its target card", async function(assert) {
+			await visit("/test/terms");
+			assert.dom(`[data-test-host-mode-card="${testHostModeRealmURL}Pet/mango"]`).exists("the rule’s target card renders at the routed path");
+		});
+		(0, import_qunit.test)("transitioning to a redirect rule replaces the location with its target", async function(assert) {
+			await visit("/test/tos");
+			assert.strictEqual(src_default.location.href, `${src_default.location.origin}/test/terms`, "the realm-relative target is resolved against the host-mode origin");
+		});
+		(0, import_qunit.test)("a redirect rule may target an external URL", async function(assert) {
+			await visit("/test/blog");
+			assert.strictEqual(src_default.location.href, "https://boxel.example/posts", "an external target is used verbatim");
+		});
+		(0, import_qunit.test)("the source query string carries onto the redirect target", async function(assert) {
+			await visit("/test/tos?utm_source=newsletter");
+			assert.strictEqual(src_default.location.href, `${src_default.location.origin}/test/terms?utm_source=newsletter`, "the inbound query is preserved, matching what serve-index does");
+		});
+		(0, import_qunit.test)("a target with its own query wins over the source query", async function(assert) {
+			await visit("/test/docs?section=appendix");
+			assert.strictEqual(src_default.location.href, `${src_default.location.origin}/test/terms?section=intro`, "the declared target query is left alone, matching serve-index");
+		});
+		(0, import_qunit.test)("a hijacked hostModeOrigin cannot steer the redirect", async function(assert) {
+			let owner = getOwner(this);
+			owner.unregister?.("service:host-mode-service");
+			owner.register("service:host-mode-service", StubHijackedOriginHostModeService);
+			await visit("/test/tos");
+			assert.strictEqual(src_default.location.href, `${src_default.location.origin}/test/terms`, "the redirect stays on the document origin");
+			assert.notOk(src_default.location.href.startsWith("https://attacker.example"), "hostModeOrigin is not used as the redirect base");
+		});
+		(0, import_qunit.test)("the app's own query params are not forwarded", async function(assert) {
+			await visit("/test/blog?sid=secret-token&utm_source=newsletter");
+			assert.strictEqual(src_default.location.href, "https://boxel.example/posts?utm_source=newsletter", "foreign params ride along; app-internal ones are dropped");
+		});
+	});
+	(0, import_qunit.module)("with a custom subdomain", function(hooks) {
+		hooks.beforeEach(function() {
+			let owner = getOwner(this);
+			owner.unregister?.("service:host-mode-service");
+			owner.register("service:host-mode-service", StubCustomSubdomainHostModeService);
+		});
+		(0, import_qunit.test)("visiting a card in host mode", async function(assert) {
+			await visit("/Pet/mango.json");
+			assert.dom(`[data-test-host-mode-card="${testHostModeRealmURL}Pet/mango"]`).exists();
+		});
+		(0, import_qunit.test)("at the site root, an opened card is written to the URL, and Back closes it", async function(assert) {
+			let mango = `${testHostModeRealmURL}Pet/mango`;
+			let stackItem = `[data-test-host-mode-stack-item="${mango}"]`;
+			await visit("/");
+			await click("[data-test-boxel-filter-list-button=\"All Cards\"]");
+			await waitFor(`[data-test-cards-grid-item="${mango}"]`);
+			await click(`[data-test-cards-grid-item="${mango}"]`);
+			await waitFor(stackItem);
+			let url = new URL(currentURL(), "http://localhost");
+			assert.strictEqual(url.pathname, "/", "still the root page");
+			assert.strictEqual(url.searchParams.get("hostModeStack"), JSON.stringify([mango]), "the URL names the opened card");
+			await visit("/");
+			await waitFor(stackItem, { count: 0 });
+			assert.dom(stackItem).doesNotExist("Back closes the card");
+		});
+	});
+});
+function removeTrailingSlash(url) {
+	return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+//#endregion