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

package/bundled-test-harness/assets/realm-config-policy-standing-test-Ber-IXpc.js

@@ -0,0 +1,290 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
+import { T as rri } from "./paths-C9-NYXnM.js";
+import { O as baseRealm } from "./constants-Icc0nFW-.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as OperatorModeContainer } from "./container-CBZZ8uFw.js";
+import { T as settled, d as click, m as rerender, o as waitFor } from "./dist-BOAdzfkP.js";
+import { n as ISOLATED_RENDER_ELEMENT_ID } from "./render-service-Bc0F9vjl.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { D as realmConfigCardJSON, F as setupLocalIndexing, M as setupCardLogs, P as setupIntegrationTestRealm, lt as setupRenderingTest, ot as setupOperatorModeStateCleanup, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { n as renderComponent } from "./render-component-B15Z0e2v.js";
+import { t as setupCatalogTestSubset } from "./catalog-test-subset-DwqjYkNV.js";
+//#region tests/integration/realm-config-policy-standing-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var CONFIG = `${testRealmURL}realm`;
+var POLICY = `${testRealmURL}policies/education`;
+var MISSING = `${testRealmURL}policies/no-such-card`;
+var NOTE = `${testRealmURL}notes/n1`;
+var CARD_DEF = {
+	module: rri("@cardstack/base/card-api"),
+	name: "CardDef"
+};
+var noop = () => {};
+var policy = { data: {
+	type: "card",
+	attributes: {
+		cardInfo: { name: "Education" },
+		rules: [{
+			targetType: CARD_DEF,
+			grants: [{ operation: "read" }]
+		}]
+	},
+	meta: { adoptsFrom: {
+		module: rri("@cardstack/catalog/realm-policy/realm-policy"),
+		name: "RealmPolicy"
+	} }
+} };
+var note = { data: {
+	type: "card",
+	attributes: { cardInfo: { name: "A note" } },
+	meta: { adoptsFrom: CARD_DEF }
+} };
+(0, import_qunit.module)("Integration | realm config policy standing", function(hooks) {
+	setupRenderingTest(hooks);
+	setupOperatorModeStateCleanup(hooks);
+	setupCatalogTestSubset(hooks);
+	setupLocalIndexing(hooks);
+	let loader;
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [baseRealm.url, testRealmURL],
+		autostart: true
+	});
+	hooks.beforeEach(function() {
+		loader = getService("loader-service").loader;
+	});
+	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/card-api"));
+	async function renderConfig(pointer, format = "isolated", { awaitStanding = true, realmPrefix } = {}) {
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			permissions: {
+				"*": ["read"],
+				"@testuser:localhost": [
+					"read",
+					"write",
+					"realm-owner"
+				]
+			},
+			contents: {
+				"realm.json": realmConfigCardJSON({
+					name: "Education",
+					...pointer !== void 0 ? { policy: pointer } : {}
+				}),
+				"policies/education.json": policy,
+				"notes/n1.json": note
+			}
+		});
+		if (realmPrefix) getService("network").virtualNetwork.addRealmMapping(realmPrefix, testRealmURL);
+		await getService("realm").login(testRealmURL);
+		getService("operations");
+		getService("operator-mode-state-service").restore({ stacks: [[{
+			id: CONFIG,
+			format
+		}]] });
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "SXcFsxeJ",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-config-policy-standing-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor(`[data-test-stack-card="${realmPrefix ? `${realmPrefix}realm` : CONFIG}"]`);
+		if (awaitStanding) await waitFor("[data-test-realm-policy-standing=\"answered\"]", { timeout: 1e4 });
+		return {
+			realm,
+			config: await getService("store").get(CONFIG)
+		};
+	}
+	function issuesShown() {
+		return [...document.querySelectorAll("[data-test-realm-policy-issue]")].map((el) => el.getAttribute("data-test-realm-policy-issue"));
+	}
+	(0, import_qunit.test)("the policy card the pointer names renders in its fitted view, and opens in a stack of its own", async function(assert) {
+		await renderConfig(POLICY);
+		await waitFor("[data-test-realm-config-policy-card=\"shown\"]");
+		assert.dom("[data-test-realm-config-policy-card-fitted]").containsText("Education", "the policy card's own fitted view renders");
+		assert.dom("[data-test-realm-config-policy-pointer]").hasText(POLICY, "with the pointer beneath it");
+		assert.dom("[data-test-realm-policy-status=\"in-force\"]").hasText("In force");
+		assert.deepEqual(issuesShown(), [], "and no issue is listed");
+		await click("[data-test-realm-config-policy-card-fitted]");
+		await waitFor("[data-test-stack-card-index=\"1\"]");
+		assert.dom(`[data-test-stack-card-index="1"][data-test-stack-card="${POLICY}"]`).exists("clicking the card opens the policy in a new stack item");
+	});
+	(0, import_qunit.test)("a realm registered under a prefix recognises its own config card", async function(assert) {
+		let virtualNetwork = getService("network").virtualNetwork;
+		try {
+			let { config } = await renderConfig(POLICY, "isolated", { realmPrefix: "@test/cards/" });
+			assert.strictEqual(config.id, "@test/cards/realm", "the config card is identified in prefix form");
+			assert.dom("[data-test-realm-policy-status=\"in-force\"]").hasText("In force", "the standing view asked the realm");
+		} finally {
+			virtualNetwork.removeRealmMapping("@test/cards/");
+		}
+	});
+	(0, import_qunit.test)("a view someone is looking at stays live while the tab renders a card for its own index", async function(assert) {
+		let context = globalThis;
+		context.__boxelRenderContext = true;
+		context.__boxelRenderContextScope = ISOLATED_RENDER_ELEMENT_ID;
+		try {
+			await renderConfig(POLICY);
+			assert.dom("[data-test-realm-policy-status=\"in-force\"]").hasText("In force", "the standing view asked the realm");
+			await waitFor("[data-test-realm-config-policy-card=\"shown\"]");
+			assert.dom("[data-test-realm-config-policy-card-fitted]").containsText("Education", "and the policy card it names loaded");
+		} finally {
+			delete context.__boxelRenderContext;
+			delete context.__boxelRenderContextScope;
+		}
+	});
+	(0, import_qunit.test)("a view inside the element the indexer renders into asks nothing", async function(assert) {
+		let context = globalThis;
+		context.__boxelRenderContext = true;
+		context.__boxelRenderContextScope = "ember-testing";
+		try {
+			await renderConfig(POLICY, "isolated", { awaitStanding: false });
+			await settled();
+			assert.dom(".policy-standing").exists("the standing view rendered");
+			assert.dom("[data-test-realm-policy-standing=\"answered\"]").doesNotExist("but did not ask the realm");
+			assert.dom("[data-test-realm-policy-status]").doesNotExist();
+			assert.dom("[data-test-realm-config-policy-card=\"shown\"]").doesNotExist("and the policy card it names was not loaded");
+		} finally {
+			delete context.__boxelRenderContext;
+			delete context.__boxelRenderContextScope;
+		}
+	});
+	(0, import_qunit.test)("a pointer to a card the index does not hold shows policy-card-missing, and no card", async function(assert) {
+		await renderConfig(MISSING);
+		assert.dom("[data-test-realm-config-policy-pointer]").hasText(MISSING, "the pointer is shown as written");
+		assert.dom("[data-test-realm-policy-status=\"not-in-force\"]").exists("the policy is shown as not in force");
+		assert.deepEqual(issuesShown(), ["policy-card-missing"]);
+		assert.dom("[data-test-realm-policy-issue=\"policy-card-missing\"]").includesText(MISSING, "the issue names the card the pointer names");
+		await waitFor("[data-test-realm-config-policy-card]");
+		assert.dom("[data-test-realm-config-policy-card]").hasAttribute("data-test-realm-config-policy-card", "missing", "a reader of the realm is told there is no card at the URL");
+		assert.dom("[data-test-realm-config-policy-card-fitted]").doesNotExist("there is no card to render");
+	});
+	(0, import_qunit.test)("a pointer to a card that is not a policy shows not-a-policy, beside that card", async function(assert) {
+		await renderConfig(NOTE);
+		assert.dom("[data-test-realm-policy-status=\"not-in-force\"]").exists("the policy is shown as not in force");
+		assert.deepEqual(issuesShown(), ["not-a-policy"]);
+		await waitFor("[data-test-realm-config-policy-card=\"shown\"]");
+		assert.dom("[data-test-realm-config-policy-card-fitted]").containsText("A note", "the card the pointer names is the one shown");
+	});
+	(0, import_qunit.test)("the problem shows beside the pointer where it is edited", async function(assert) {
+		await renderConfig(MISSING, "edit");
+		assert.dom("[data-test-field=\"policy\"] [data-test-realm-policy-issue=\"policy-card-missing\"]").exists("the issue is shown in the policy field’s row");
+	});
+	(0, import_qunit.test)("choosing a policy from the card chooser clears the issue once the save lands", async function(assert) {
+		await renderConfig(MISSING, "edit");
+		assert.deepEqual(issuesShown(), ["policy-card-missing"]);
+		await click("[data-test-realm-config-policy-remove]");
+		await click("[data-test-realm-config-policy-choose]");
+		await waitFor(`[data-test-item-button="${POLICY}"]`, { timeout: 1e4 });
+		await click(`[data-test-item-button="${POLICY}"]`);
+		await click("[data-test-card-chooser-go-button]");
+		await waitFor("[data-test-realm-policy-status=\"in-force\"]", { timeout: 1e4 });
+		assert.deepEqual(issuesShown(), [], "the issue is gone");
+		await waitFor("[data-test-realm-config-policy-card=\"shown\"]");
+		assert.dom("[data-test-field=\"policy\"] [data-test-realm-config-policy-card-fitted]").containsText("Education", "and the chosen card renders in its place");
+		assert.dom("[data-test-field=\"policy\"] [data-test-realm-config-policy-pointer]").hasText(POLICY, "with its id beneath it, which is what is stored");
+	});
+	(0, import_qunit.test)("a policy created from the card chooser is named at once, and shows as being created until it is saved", async function(assert) {
+		let { config } = await renderConfig(void 0, "edit");
+		await click("[data-test-realm-config-policy-choose]");
+		await waitFor(`[data-test-item-button-create-new="${testRealmURL}"]`, { timeout: 1e4 });
+		let created = click(`[data-test-item-button-create-new="${testRealmURL}"]`);
+		await waitFor("[data-test-realm-config-policy-card=\"creating\"]", { timeout: 1e4 });
+		assert.dom("[data-test-card-chooser-modal]").doesNotExist("the chooser is dismissed without waiting for the save");
+		let expected = config.policy;
+		assert.true(new RegExp(`^${testRealmURL}RealmPolicy/[0-9a-f-]{36}$`).test(expected), `the pointer names the id the realm will give the new card: ${expected}`);
+		assert.dom("[data-test-field=\"policy\"] [data-test-realm-config-policy-pointer]").hasText(expected, "and shows it");
+		assert.dom("[data-test-realm-config-policy-card-busy]").hasText("Creating the policy…", "the card shows as being created");
+		assert.dom("[data-test-realm-config-policy-card-fitted]").doesNotExist("there is no card to render yet");
+		assert.dom("[data-test-realm-policy-standing]").doesNotExist("nor a standing to report");
+		assert.dom("[data-test-realm-config-policy-remove]").exists("and it can be removed like any chosen policy");
+		await created;
+		await waitFor("[data-test-realm-config-policy-card=\"shown\"]", { timeout: 1e4 });
+		assert.dom("[data-test-realm-config-policy-card-busy]").doesNotExist("once saved, the card is no longer being created");
+		assert.dom("[data-test-field=\"policy\"] [data-test-realm-config-policy-card-fitted]").exists("and its fitted view renders in its place");
+		assert.strictEqual(config.policy, expected, "the realm gave the card the id the pointer names");
+		assert.dom(`[data-test-stack-card="${expected}"]`).exists("the new policy opens in a stack item of its own to be written");
+		await waitFor("[data-test-realm-policy-status=\"in-force\"]", { timeout: 1e4 });
+		assert.dom("[data-test-realm-policy-status=\"in-force\"]").hasText("In force", "and the policy it names is in force");
+	});
+	(0, import_qunit.test)("a policy removed while it is being created stays removed once it is saved", async function(assert) {
+		let { config } = await renderConfig(void 0, "edit");
+		await click("[data-test-realm-config-policy-choose]");
+		await waitFor(`[data-test-item-button-create-new="${testRealmURL}"]`, { timeout: 1e4 });
+		let created = click(`[data-test-item-button-create-new="${testRealmURL}"]`);
+		await waitFor("[data-test-realm-config-policy-card=\"creating\"]", { timeout: 1e4 });
+		await click("[data-test-realm-config-policy-remove]");
+		assert.dom("[data-test-realm-config-policy-card-busy]").doesNotExist("the card no longer shows as being created");
+		assert.dom("[data-test-field=\"policy\"] [data-test-realm-config-policy-choose]").exists("and the chooser is offered again");
+		await created;
+		assert.notOk(config.policy, "the save landing afterwards does not name the card again");
+		assert.dom("[data-test-field=\"policy\"] [data-test-realm-config-policy-choose]").exists("and the chooser is still offered");
+	});
+	(0, import_qunit.test)("a realm with no policy offers the card chooser where the pointer is edited", async function(assert) {
+		await renderConfig(void 0, "edit");
+		assert.dom("[data-test-field=\"policy\"] [data-test-realm-config-policy-choose]").hasText("Link Realm Policy");
+		assert.dom("[data-test-realm-config-policy-remove]").doesNotExist();
+	});
+	(0, import_qunit.test)("an answer about the saved pointer is not shown beside a different one", async function(assert) {
+		let { config } = await renderConfig(MISSING, "edit");
+		assert.deepEqual(issuesShown(), ["policy-card-missing"]);
+		config.policy = POLICY;
+		await rerender();
+		assert.dom("[data-test-realm-policy-status]").doesNotExist("the standing of the saved pointer is not shown beside a pointer typed since");
+		await waitFor("[data-test-realm-policy-status=\"in-force\"]", { timeout: 1e4 });
+		assert.deepEqual(issuesShown(), [], "once the save lands, the realm reports the fixed pointer in force");
+	});
+	(0, import_qunit.test)("removing a policy in force clears the pointer, and the realm names no policy once the save lands", async function(assert) {
+		let { realm, config } = await renderConfig(POLICY, "edit");
+		await waitFor("[data-test-realm-config-policy-card=\"shown\"]");
+		assert.dom("[data-test-realm-policy-status=\"in-force\"]").exists();
+		await click("[data-test-realm-config-policy-remove]");
+		assert.notOk(config.policy, "the pointer is cleared");
+		assert.dom("[data-test-realm-config-policy-card-fitted]").doesNotExist("the policy card is no longer shown");
+		assert.dom("[data-test-realm-config-policy-remove]").doesNotExist();
+		assert.dom("[data-test-realm-config-policy-choose]").exists("and another policy can be chosen");
+		assert.dom("[data-test-realm-policy-status]").doesNotExist("a realm that names no policy has no standing");
+		let named = await realm.getRealmPolicy();
+		for (let tries = 0; named !== void 0 && tries < 50; tries++) {
+			await new Promise((resolve) => setTimeout(resolve, 200));
+			named = await realm.getRealmPolicy();
+		}
+		assert.strictEqual(named, void 0, "once the save lands, the realm reads no policy from realm.json");
+	});
+	(0, import_qunit.test)("removing the policy takes its standing away at once, and offers the chooser", async function(assert) {
+		await renderConfig(MISSING, "edit");
+		assert.deepEqual(issuesShown(), ["policy-card-missing"]);
+		await click("[data-test-realm-config-policy-remove]");
+		assert.dom("[data-test-realm-policy-status]").doesNotExist("an empty pointer is not shown the old pointer’s problem");
+		assert.dom("[data-test-realm-config-policy-choose]").exists();
+	});
+	(0, import_qunit.test)("creating the card the pointer names clears the issue", async function(assert) {
+		let { realm } = await renderConfig(MISSING);
+		assert.deepEqual(issuesShown(), ["policy-card-missing"]);
+		await realm.write("policies/no-such-card.json", JSON.stringify(policy));
+		await waitFor("[data-test-realm-policy-status=\"in-force\"]", { timeout: 1e4 });
+		assert.deepEqual(issuesShown(), [], "the realm reports the policy in force");
+	});
+	(0, import_qunit.test)("a realm with no policy shows no issue affordance", async function(assert) {
+		await renderConfig(void 0);
+		assert.dom("[data-test-realm-config-policy-none]").hasText("No policy. The realm's permissions alone decide who may do what.");
+		assert.dom("[data-test-realm-policy-status]").doesNotExist("nothing is said about a policy the realm does not name");
+		assert.dom("[data-test-realm-config-policy-card]").doesNotExist();
+	});
+	(0, import_qunit.test)("a pointer the realm cannot read as a card id says the realm names no policy", async function(assert) {
+		await renderConfig("policies/education");
+		assert.dom("[data-test-realm-policy-status=\"unread-pointer\"]").exists("the realm dropped a relative pointer, and the card says so");
+		assert.deepEqual(issuesShown(), []);
+	});
+});
+//#endregion

package/bundled-test-harness/assets/realm-config-routing-rule-edit-test-3Xqt5VlM.js

@@ -0,0 +1,274 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
+import { O as baseRealm, x as PermissionsContextName } from "./constants-Icc0nFW-.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as OperatorModeContainer } from "./container-CBZZ8uFw.js";
+import { T as settled, d as click, o as waitFor, s as fillIn } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, P as setupIntegrationTestRealm, lt as setupRenderingTest, nt as provide, ot as setupOperatorModeStateCleanup, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { n as renderComponent, t as renderCard } from "./render-component-B15Z0e2v.js";
+//#region tests/integration/components/realm-config-routing-rule-edit-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var realmName = "Local Workspace";
+var noop = () => {};
+(0, import_qunit.module)("Integration | realm-config | routing rule instance editor", function(hooks) {
+	setupRenderingTest(hooks);
+	setupOperatorModeStateCleanup(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [baseRealm.url, testRealmURL],
+		autostart: true
+	});
+	async function renderRealmConfigEdit(hostRoutingRules, relationships) {
+		let loader = getService("loader-service").loader;
+		let cardApi = await loader.import("@cardstack/base/card-api");
+		let string = await loader.import("@cardstack/base/string");
+		let cardsGrid = await loader.import("@cardstack/base/cards-grid");
+		let { field, contains, CardDef } = cardApi;
+		let { default: StringField } = string;
+		let { CardsGrid } = cardsGrid;
+		class Pet extends CardDef {
+			static displayName = "Pet";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			permissions: { "@testuser:localhost": [
+				"read",
+				"write",
+				"realm-owner"
+			] },
+			contents: {
+				"pet.gts": { Pet },
+				".realm.json": `{ "name": "${realmName}" }`,
+				"Pet/mango.json": new Pet({ name: "Mango" }),
+				"index.json": new CardsGrid(),
+				"realm.json": { data: {
+					type: "card",
+					attributes: { hostRoutingRules },
+					...relationships ? { relationships } : {},
+					meta: { adoptsFrom: {
+						module: "@cardstack/base/realm-config",
+						name: "RealmConfig"
+					} }
+				} }
+			}
+		});
+		getService("operator-mode-state-service").restore({ stacks: [[{
+			id: `${testRealmURL}realm`,
+			format: "edit"
+		}]] });
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "cwfZ95Ew",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/realm-config-routing-rule-edit-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor(`[data-test-stack-card="${testRealmURL}realm"]`);
+	}
+	(0, import_qunit.test)("the card chooser is locked to the consuming realm", async function(assert) {
+		await renderRealmConfigEdit([{ path: "/docs" }]);
+		await click("[data-test-add-new=\"instance\"]");
+		await waitFor("[data-test-card-chooser-modal]");
+		await waitFor(`[data-test-card-chooser-modal] [data-test-realm-url="${testRealmURL}"]`);
+		await waitFor("[data-test-card-chooser-modal] [data-test-realm-picker]");
+		assert.dom("[data-test-card-chooser-modal] [data-test-realm-picker]").hasAttribute("aria-disabled", "true", "the realm picker is locked");
+		assert.dom("[data-test-card-chooser-modal] [data-test-realm-picker] [data-test-boxel-picker-selected-item=\"All\"]").doesNotExist("the realm picker is scoped to a specific realm, not the unscoped \"All\" select-all pill");
+		assert.dom("[data-test-card-chooser-modal] [data-test-realm-picker] [data-test-boxel-picker-remove-button]").doesNotExist("the consuming-realm pill does not offer a remove affordance when the picker is locked");
+		assert.dom(`[data-test-card-chooser-modal] [data-test-realm-url="${testRealmURL}"]`).exists("candidates from the consuming realm are shown");
+		assert.dom(`[data-test-card-chooser-modal] [data-test-realm-url="${baseRealm.url}"]`).doesNotExist("cross-realm candidates are excluded by the lock");
+	});
+	(0, import_qunit.test)("pasting a full card URL from the consuming realm shows the result", async function(assert) {
+		await renderRealmConfigEdit([{ path: "/docs" }]);
+		await click("[data-test-add-new=\"instance\"]");
+		await waitFor("[data-test-card-chooser-modal]");
+		await fillIn("[data-test-card-chooser-modal] [data-test-search-field]", `${testRealmURL}Pet/mango`);
+		await waitFor("[data-test-card-chooser-modal] [data-section-sid^=\"url:\"]");
+		assert.dom("[data-test-card-chooser-modal] [data-section-sid^=\"url:\"]").doesNotHaveClass("search-result-block--collapsed", "the URL-paste section is not collapsed by the seeded realm focus");
+		assert.dom("[data-test-card-chooser-modal] [data-section-sid^=\"url:\"] [data-test-item-button]").isVisible("the pasted card result tile is visible");
+		await click("[data-test-card-chooser-modal] [data-section-sid^=\"url:\"] [data-test-item-button]");
+		assert.dom("[data-test-card-chooser-go-button]").isNotDisabled("the pasted card can be chosen");
+	});
+	(0, import_qunit.test)("pasting a card URL from outside the consuming realm offers no result", async function(assert) {
+		await renderRealmConfigEdit([{ path: "/docs" }]);
+		await click("[data-test-add-new=\"instance\"]");
+		await waitFor("[data-test-card-chooser-modal]");
+		await fillIn("[data-test-card-chooser-modal] [data-test-search-field]", `${baseRealm.url}types/card`);
+		await waitFor("[data-test-card-chooser-modal] [data-test-search-sheet-empty]", { timeout: 1e4 });
+		assert.dom("[data-test-card-chooser-modal] [data-section-sid^=\"url:\"]").doesNotExist("no URL-paste section is offered for an out-of-scope card");
+		assert.dom("[data-test-card-chooser-modal] [data-test-search-sheet-empty]").containsText("is not in the realms this chooser is limited to", "the empty state explains the card is out of scope, not missing");
+		assert.dom("[data-test-card-chooser-modal] [data-test-search-label]").containsText("0 results", "the summary does not count the card");
+		assert.dom("[data-test-card-chooser-modal] [data-test-item-button]").doesNotExist("there is no tile to select");
+		assert.dom("[data-test-card-chooser-go-button]").isDisabled("a cross-realm card cannot be returned by the chooser");
+	});
+	(0, import_qunit.test)("renders a per-rule warning when a path is malformed", async function(assert) {
+		await renderRealmConfigEdit([{ path: "docs" }, { path: "/foo bar" }]);
+		let warningTexts = [...document.querySelectorAll("[data-test-path-warning]")].map((el) => el.textContent?.trim() ?? "");
+		assert.strictEqual(warningTexts.length, 2, "one warning per malformed rule");
+		assert.ok(warningTexts.some((t) => t.includes("Path must start with /")), "missing-slash warning is rendered");
+		assert.ok(warningTexts.some((t) => t.includes("Path may only contain letters, numbers")), "invalid-characters warning is rendered");
+	});
+	(0, import_qunit.test)("renders the aggregate duplicate-path warning when paths repeat", async function(assert) {
+		await renderRealmConfigEdit([
+			{ path: "/docs" },
+			{ path: "/docs" },
+			{ path: "/pricing" }
+		]);
+		assert.dom("[data-test-duplicate-path-warning]").exists("the duplicate banner is shown");
+		assert.dom("[data-test-duplicate-path-warning]").containsText("/docs", "the duplicate banner names the repeated path");
+	});
+	(0, import_qunit.test)("warns when a routing rule points to a card that no longer exists", async function(assert) {
+		await renderRealmConfigEdit([{ path: "/gone" }], { "hostRoutingRules.0.instance": { links: { self: "./does-not-exist" } } });
+		await waitFor("[data-test-dangling-routing-warning]");
+		assert.dom("[data-test-dangling-routing-warning]").exists("the dangling-routing banner is shown");
+		assert.dom("[data-test-dangling-routing-warning]").containsText("/gone", "the banner names the path with the dead target");
+	});
+	(0, import_qunit.test)("rules with unset paths warn as duplicates of explicit \"/\" rules", async function(assert) {
+		await renderRealmConfigEdit([{ path: "/" }, {}]);
+		assert.dom("[data-test-duplicate-path-warning]").exists("the duplicate banner is shown for visually-equal \"/\" rules");
+		assert.dom("[data-test-duplicate-path-warning]").containsText("/", "the duplicate banner names the conflicting path");
+	});
+	(0, import_qunit.test)("the chooser gets a consuming realm even when no RealmURLContext is provided (code submode)", async function(assert) {
+		await getService("loader-service").loader.import("@cardstack/base/card-api");
+		await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			permissions: { "@testuser:localhost": [
+				"read",
+				"write",
+				"realm-owner"
+			] },
+			contents: {
+				".realm.json": `{ "name": "${realmName}" }`,
+				"realm.json": { data: {
+					type: "card",
+					attributes: { hostRoutingRules: [{ path: "/docs" }] },
+					meta: { adoptsFrom: {
+						module: "@cardstack/base/realm-config",
+						name: "RealmConfig"
+					} }
+				} }
+			}
+		});
+		let realmConfig = await getService("store").get(`${testRealmURL}realm`);
+		let capturedOpts;
+		let originalChooser = globalThis._CARDSTACK_CARD_CHOOSER;
+		globalThis._CARDSTACK_CARD_CHOOSER = { chooseCard: async (_query, opts) => {
+			capturedOpts = opts;
+		} };
+		provide(PermissionsContextName, {
+			canRead: true,
+			canWrite: true
+		});
+		try {
+			await renderCard(getService("loader-service").loader, realmConfig, "edit");
+			await waitFor("[data-test-add-new=\"instance\"]");
+			await click("[data-test-add-new=\"instance\"]");
+			assert.ok(capturedOpts, "chooseCard was invoked");
+			assert.strictEqual(capturedOpts?.consumingRealm?.href, testRealmURL, "consumingRealm reaches the chooser via @consumingRealm, not RealmURLContext");
+			assert.true(capturedOpts?.lockConsumingRealm, "lockConsumingRealm is honored when a consumingRealm is actually present");
+		} finally {
+			globalThis._CARDSTACK_CARD_CHOOSER = originalChooser;
+		}
+	});
+	(0, import_qunit.test)("a rule with a redirect target renders the redirect editor", async function(assert) {
+		await renderRealmConfigEdit([{
+			path: "/tos",
+			redirectTo: "/terms",
+			statusCode: 301
+		}]);
+		assert.dom("[data-test-routing-rule-kind] [data-test-boxel-radio-option-id=\"redirect\"] input[type=\"radio\"]").isChecked("the kind toggle reflects the stored redirect");
+		assert.dom("[data-test-redirect-input]").hasValue("/terms", "the stored target is shown");
+		assert.dom("[data-test-status-code-select]").containsText("301", "the stored status code is selected");
+		assert.dom("[data-test-add-new=\"instance\"]").doesNotExist("the card chooser is not shown for a redirect rule");
+	});
+	(0, import_qunit.test)("switching a rule to a redirect swaps the target editor and validates the target", async function(assert) {
+		await renderRealmConfigEdit([{ path: "/docs" }]);
+		assert.dom("[data-test-redirect-input]").doesNotExist("a card rule shows no redirect editor");
+		await click("[data-test-routing-rule-kind] [data-test-boxel-radio-option-id=\"redirect\"] input[type=\"radio\"]");
+		assert.dom("[data-test-redirect-input]").exists();
+		assert.dom("[data-test-add-new=\"instance\"]").doesNotExist("the card chooser is replaced by the redirect editor");
+		await fillIn("[data-test-redirect-input]", "terms");
+		assert.dom("[data-test-redirect-warning]").containsText("Redirect target must be a path starting with / or a full http(s) URL", "a slash-less target warns");
+		await fillIn("[data-test-redirect-input]", "https://example.com/terms");
+		assert.dom("[data-test-redirect-warning]").doesNotExist("an external http(s) URL is allowed");
+		await fillIn("[data-test-redirect-input]", "/terms");
+		assert.dom("[data-test-redirect-warning]").doesNotExist("a realm-relative path is allowed");
+		await click("[data-test-routing-rule-kind] [data-test-boxel-radio-option-id=\"card\"] input[type=\"radio\"]");
+		assert.dom("[data-test-redirect-input]").doesNotExist("switching back to card removes the redirect editor");
+		assert.dom("[data-test-add-new=\"instance\"]").exists("switching back to card restores the chooser");
+	});
+	(0, import_qunit.test)("the shown editor follows the model when the rule changes elsewhere", async function(assert) {
+		await renderRealmConfigEdit([{
+			path: "/tos",
+			redirectTo: "/terms"
+		}]);
+		assert.dom("[data-test-redirect-input]").exists("starts on the redirect editor");
+		let realmConfig = await getService("store").get(`${testRealmURL}realm`);
+		realmConfig.hostRoutingRules[0].redirectTo = void 0;
+		await settled();
+		assert.dom("[data-test-redirect-input]").doesNotExist("clearing the target elsewhere flips this editor back");
+		assert.dom("[data-test-routing-rule-kind] [data-test-boxel-radio-option-id=\"card\"] input[type=\"radio\"]").isChecked("the toggle follows the model rather than a stale copy");
+	});
+	(0, import_qunit.test)("warns when redirect rules loop back on themselves", async function(assert) {
+		await renderRealmConfigEdit([
+			{
+				path: "/tos",
+				redirectTo: "/tos"
+			},
+			{
+				path: "/a",
+				redirectTo: "/b"
+			},
+			{
+				path: "/b",
+				redirectTo: "/a"
+			},
+			{
+				path: "/fine",
+				redirectTo: "/terms"
+			}
+		]);
+		assert.dom("[data-test-redirect-loop-warning]").exists("the redirect-loop banner is shown");
+		assert.dom("[data-test-redirect-loop-warning]").containsText("/tos", "the banner names the self-redirect");
+		assert.dom("[data-test-redirect-loop-warning]").containsText("/a", "the banner names both halves of the ring");
+		assert.dom("[data-test-redirect-loop-warning]").doesNotContainText("/fine", "a terminating redirect is not flagged as a loop");
+	});
+	(0, import_qunit.test)("no redirect-loop warning for rules that terminate", async function(assert) {
+		await renderRealmConfigEdit([{
+			path: "/tos",
+			redirectTo: "/terms"
+		}, {
+			path: "/blog",
+			redirectTo: "https://example.com/blog"
+		}]);
+		assert.dom("[data-test-redirect-loop-warning]").doesNotExist("no banner when nothing loops");
+	});
+	(0, import_qunit.test)("typing into the path input always stores a leading slash", async function(assert) {
+		await renderRealmConfigEdit([{}]);
+		assert.dom("[data-test-path-warning]").doesNotExist("no warning before any input");
+		await fillIn("[data-test-path-input] input", "docs");
+		assert.dom("[data-test-path-warning]").doesNotExist("typed text is stored with a leading slash, so the missing-slash warning does not fire");
+		await fillIn("[data-test-path-input] input", "/foo");
+		assert.dom("[data-test-path-warning]").doesNotExist("a typed leading slash is not doubled — the accessory remains the only slash");
+		await fillIn("[data-test-path-input] input", "//foo");
+		assert.dom("[data-test-path-warning]").doesNotExist("multiple leading slashes collapse to one");
+	});
+});
+//#endregion