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

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

@@ -1,290 +0,0 @@
-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-Cqcwrd-m.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-Dd8k0DNa.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-BoJoKzmX.js

@@ -1,274 +0,0 @@
-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-Cqcwrd-m.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-Dd8k0DNa.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