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

package/bundled-test-harness/assets/markdown-skill-frontmatter-test-VwJi3Paj.js

@@ -1,146 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { Br as testRealmURL, Go as identifyCard, r as FRONTMATTER_PARSE_ERROR_SYMBOL } from "./runtime-common-BTaLJEw-.js";
-import { n as buildFileResource } from "./file-def-attributes-extractor-Dg_reo87.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { F as setupLocalIndexing, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-import { D as createFromSerialized } from "./card-api-Cc8uZunB.js";
-//#region tests/integration/components/markdown-skill-frontmatter-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var FILE_FIELD_META = Symbol.for("boxel:file-field-meta");
-var loader;
-function streamOf(markdown) {
-	return async () => new TextEncoder().encode(markdown);
-}
-var SKILL_MD = `---
-name: Realm Sync
-description: Sync workspace files
-boxel:
-  kind: skill
-  tools:
-    - codeRef:
-        module: '@cardstack/boxel-host/commands/realm-sync'
-        name: SyncCommand
-      requiresApproval: true
----
-# Realm Sync
-
-Body paragraph.
-`;
-var LEGACY_SKILL_MD = SKILL_MD.replace("  tools:", "  commands:");
-(0, import_qunit.module)("Integration | markdown skill frontmatter", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	setupMockMatrix(hooks);
-	hooks.beforeEach(function() {
-		loader = getService("loader-service").loader;
-	});
-	async function loadBase() {
-		let { MarkdownDef } = await loader.import("@cardstack/base/markdown-file-def");
-		let { SkillFrontmatterField } = await loader.import("@cardstack/base/skill-frontmatter-field");
-		let { FrontmatterField } = await loader.import("@cardstack/base/frontmatter-field");
-		let { parseFrontmatter } = await loader.import("@cardstack/base/frontmatter-parse");
-		return {
-			MarkdownDef,
-			SkillFrontmatterField,
-			FrontmatterField,
-			parseFrontmatter
-		};
-	}
-	(0, import_qunit.test)("parseFrontmatter splits the YAML block from the body", async function(assert) {
-		let { parseFrontmatter } = await loadBase();
-		let { data, body } = parseFrontmatter(SKILL_MD);
-		assert.strictEqual(data.name, "Realm Sync", "top-level name parsed");
-		assert.strictEqual(data.boxel.kind, "skill", "boxel.kind parsed");
-		assert.strictEqual(data.boxel.tools[0].codeRef.name, "SyncCommand", "nested boxel.tools codeRef parsed");
-		assert.true(body.startsWith("# Realm Sync"), "body excludes the frontmatter block");
-		let plain = parseFrontmatter("# Just markdown\n\nNo frontmatter.");
-		assert.deepEqual(plain.data, {}, "no frontmatter -> empty data");
-		assert.strictEqual(plain.body, "# Just markdown\n\nNo frontmatter.", "no frontmatter -> body verbatim");
-	});
-	(0, import_qunit.test)("extractAttributes surfaces searchable kind, raw frontmatter, and routes the SkillFrontmatterField marker", async function(assert) {
-		let { MarkdownDef, SkillFrontmatterField } = await loadBase();
-		let url = `${testRealmURL}skills/realm-sync/SKILL.md`;
-		let attrs = await MarkdownDef.extractAttributes(url, streamOf(SKILL_MD), {});
-		assert.strictEqual(attrs.kind, "skill", "direct searchable kind written");
-		assert.true(attrs.content.startsWith("# Realm Sync"), "content is the body — the frontmatter block is stripped");
-		assert.notOk(attrs.content.includes("boxel:"), "content excludes the raw frontmatter");
-		assert.strictEqual(attrs.frontmatter.rawContent.boxel.kind, "skill", "rawContent holds the whole frontmatter (incl. boxel namespace)");
-		assert.strictEqual(attrs.frontmatter.rawContent.name, "Realm Sync", "rawContent includes shared top-level keys");
-		assert.strictEqual(attrs.frontmatter.name, "Realm Sync", "typed name sourced from shared top-level name");
-		assert.true(attrs.frontmatter.tools[0].requiresApproval, "typed tools sourced from the boxel namespace");
-		let routed = attrs[FILE_FIELD_META];
-		assert.deepEqual(routed?.frontmatter?.adoptsFrom, identifyCard(SkillFrontmatterField), "routed per-field meta points frontmatter at SkillFrontmatterField");
-	});
-	(0, import_qunit.test)("the legacy boxel.commands key still parses into typed tools", async function(assert) {
-		let { MarkdownDef, SkillFrontmatterField } = await loadBase();
-		let url = `${testRealmURL}skills/realm-sync/SKILL.md`;
-		let attrs = await MarkdownDef.extractAttributes(url, streamOf(LEGACY_SKILL_MD), {});
-		assert.strictEqual(attrs.kind, "skill", "kind still extracted");
-		assert.strictEqual(attrs.frontmatter.tools[0].codeRef.name, "SyncCommand", "legacy boxel.commands entries land on the tools field");
-		let routed = attrs[FILE_FIELD_META];
-		assert.deepEqual(routed?.frontmatter?.adoptsFrom, identifyCard(SkillFrontmatterField), "legacy key still routes the SkillFrontmatterField marker");
-	});
-	(0, import_qunit.test)("write -> read round-trip rehydrates frontmatter as SkillFrontmatterField with tools", async function(assert) {
-		let { MarkdownDef, SkillFrontmatterField } = await loadBase();
-		let url = `${testRealmURL}skills/realm-sync/SKILL.md`;
-		let cleaned = { ...await MarkdownDef.extractAttributes(url, streamOf(SKILL_MD), {}) };
-		let cleanedBag = cleaned;
-		let fieldsMeta = cleanedBag[FILE_FIELD_META];
-		delete cleanedBag[FILE_FIELD_META];
-		let resource = buildFileResource(url, cleaned, identifyCard(MarkdownDef), void 0, fieldsMeta);
-		assert.deepEqual(resource.meta.fields?.frontmatter?.adoptsFrom, identifyCard(SkillFrontmatterField), "buildFileResource now threads meta.fields (gap closed)");
-		let instance = await createFromSerialized(resource, { data: resource }, void 0);
-		assert.true(instance.frontmatter instanceof SkillFrontmatterField, "frontmatter rehydrated as SkillFrontmatterField subclass");
-		assert.strictEqual(instance.frontmatter.name, "Realm Sync", "typed subclass field survives round-trip");
-		assert.strictEqual(instance.frontmatter.rawContent.boxel.kind, "skill", "rawContent survives round-trip");
-		assert.strictEqual(instance.frontmatter.tools.length, 1, "tools survive round-trip");
-		assert.strictEqual(instance.frontmatter.tools[0].codeRef.name, "SyncCommand", "tool codeRef survives round-trip");
-	});
-	(0, import_qunit.test)("a pre-rename index row (frontmatter.commands attribute) rehydrates via the legacy field", async function(assert) {
-		let { MarkdownDef, SkillFrontmatterField } = await loadBase();
-		let url = `${testRealmURL}skills/realm-sync/SKILL.md`;
-		let cleaned = { ...await MarkdownDef.extractAttributes(url, streamOf(SKILL_MD), {}) };
-		let cleanedBag = cleaned;
-		let fieldsMeta = cleanedBag[FILE_FIELD_META];
-		delete cleanedBag[FILE_FIELD_META];
-		cleaned.frontmatter = { ...cleaned.frontmatter };
-		cleaned.frontmatter.commands = cleaned.frontmatter.tools;
-		delete cleaned.frontmatter.tools;
-		let resource = buildFileResource(url, cleaned, identifyCard(MarkdownDef), void 0, fieldsMeta);
-		let instance = await createFromSerialized(resource, { data: resource }, void 0);
-		assert.true(instance.frontmatter instanceof SkillFrontmatterField, "frontmatter still rehydrates as SkillFrontmatterField");
-		assert.strictEqual(instance.frontmatter.tools.length, 0, "the tools field is empty on a pre-rename row");
-		assert.strictEqual(instance.frontmatter.commands[0].codeRef.name, "SyncCommand", "the legacy commands field carries the value until the realm reindexes");
-	});
-	(0, import_qunit.test)("invalid frontmatter YAML routes a parse-error marker and still indexes the body", async function(assert) {
-		let { MarkdownDef } = await loadBase();
-		let url = `${testRealmURL}skills/bad/SKILL.md`;
-		let attrs = await MarkdownDef.extractAttributes(url, streamOf(`---
-name: Bad Skill
-boxel: { kind: skill, tools: [
----
-# Bad Skill
-
-Body paragraph.
-`), {});
-		let routed = attrs[FRONTMATTER_PARSE_ERROR_SYMBOL];
-		assert.strictEqual(typeof routed?.message, "string", "routes a frontmatter parse error carrying a message string");
-		assert.true((routed?.message?.length ?? 0) > 0, "the routed parse-error message is non-empty");
-		assert.strictEqual(attrs.kind, void 0, "no searchable kind — the frontmatter was dropped");
-		assert.strictEqual(attrs.frontmatter, void 0, "no typed frontmatter value when the YAML failed to parse");
-		assert.strictEqual(attrs[FILE_FIELD_META], void 0, "no routed field meta when the frontmatter was dropped");
-		assert.true(attrs.content.includes("Body paragraph."), "body is still indexed despite the parse failure");
-	});
-	(0, import_qunit.test)("plain markdown (no frontmatter) carries no kind and no frontmatter value", async function(assert) {
-		let { MarkdownDef } = await loadBase();
-		let url = `${testRealmURL}notes/readme.md`;
-		let attrs = await MarkdownDef.extractAttributes(url, streamOf("# Readme\n\nHello."), {});
-		assert.strictEqual(attrs.kind, void 0, "no kind for plain markdown");
-		assert.strictEqual(attrs.frontmatter, void 0, "no frontmatter value for plain markdown");
-		assert.strictEqual(attrs[FILE_FIELD_META], void 0, "no routed field meta for plain markdown");
-		assert.strictEqual(attrs.title, "Readme", "title still extracted");
-		assert.true(attrs.content.includes("Hello."), "content still extracted");
-	});
-});
-//#endregion

package/bundled-test-harness/assets/markdown-skill-search-test-ysCdf0xM.js

@@ -1,80 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
-import { D as baseRRI } from "./constants-Icc0nFW-.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { F as setupLocalIndexing, L as setupRealmCacheTeardown, P as setupIntegrationTestRealm, Z as withCachedRealmSetup, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-import { t as searchCardsForTest } from "./search-cards-DxcB56HL.js";
-//#region tests/integration/markdown-skill-search-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var SKILL_MD = `---
-name: Realm Sync
-description: Sync workspace files
-boxel:
-  kind: skill
-  tools:
-    - codeRef:
-        module: '@cardstack/boxel-host/commands/realm-sync'
-        name: SyncCommand
-      requiresApproval: true
----
-# Realm Sync
-`;
-var RECIPE_MD = `---
-name: Pasta
-boxel:
-  kind: recipe
----
-# Pasta
-`;
-var PLAIN_MD = `# Just a note
-
-Nothing special here.
-`;
-var markdownRef = {
-	module: baseRRI("markdown-file-def"),
-	name: "MarkdownDef"
-};
-(0, import_qunit.module)("Integration | markdown skill search", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks);
-	setupRealmCacheTeardown(hooks);
-	let queryEngine;
-	hooks.beforeEach(async function() {
-		let { realm } = await withCachedRealmSetup(async () => setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"skills/realm-sync/SKILL.md": SKILL_MD,
-				"recipes/pasta/SKILL.md": RECIPE_MD,
-				"notes/plain.md": PLAIN_MD
-			}
-		}));
-		queryEngine = realm.realmIndexQueryEngine;
-	});
-	(0, import_qunit.test)("finds MarkdownDef files where boxel.kind is \"skill\"", async function(assert) {
-		let result = await searchCardsForTest(queryEngine, { filter: {
-			on: markdownRef,
-			eq: { kind: "skill" }
-		} });
-		assert.deepEqual(result.data.map((entry) => entry.id), [`${testRealmURL}skills/realm-sync/SKILL.md`], "only the skill markdown file matches kind: skill");
-		assert.strictEqual(result.data[0]?.type, "file-meta", "the match is a file-meta resource (an indexed MarkdownDef file)");
-	});
-	(0, import_qunit.test)("all three markdown files index as MarkdownDef (kind only discriminates the filter)", async function(assert) {
-		let ids = (await searchCardsForTest(queryEngine, { filter: { type: markdownRef } })).data.map((entry) => entry.id);
-		assert.ok(ids.includes(`${testRealmURL}skills/realm-sync/SKILL.md`), "skill file is a MarkdownDef");
-		assert.ok(ids.includes(`${testRealmURL}recipes/pasta/SKILL.md`), "recipe file is also a MarkdownDef (different kind, not a different type)");
-		assert.ok(ids.includes(`${testRealmURL}notes/plain.md`), "plain markdown is a MarkdownDef too");
-	});
-	(0, import_qunit.test)("reading a skill markdown file rehydrates frontmatter as SkillFrontmatterField", async function(assert) {
-		let { SkillFrontmatterField } = await getService("loader-service").loader.import("@cardstack/base/skill-frontmatter-field");
-		let store = getService("store");
-		let url = `${testRealmURL}skills/realm-sync/SKILL.md`;
-		let instance = await store.get(url, { type: "file-meta" });
-		assert.strictEqual(instance?.kind, "skill", "kind read back as skill");
-		assert.true(instance?.frontmatter instanceof SkillFrontmatterField, "frontmatter rehydrated as SkillFrontmatterField, not the base FrontmatterField");
-		assert.strictEqual(instance.frontmatter.tools.length, 1, "typed tools survive the realm file-meta read");
-		assert.strictEqual(instance.frontmatter.tools[0].codeRef.name, "SyncCommand", "tool codeRef survives the realm file-meta read");
-	});
-});
-//#endregion

package/bundled-test-harness/assets/matrix-service-account-switch-sessions-test-K2JuMy36.js

@@ -1,63 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
-import { s as ensureTrailingSlash } from "./paths-C9-NYXnM.js";
-import { O as baseRealm } from "./constants-Icc0nFW-.js";
-import { t as config } from "./environment-DIUJgBKt.js";
-import { n as src_default } from "./src-DPaAwa4H.js";
-import { d as RealmServerSessionLocalStorageKey, h as SessionLocalStorageKey } from "./local-storage-keys-CS7XLz7J.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { F as setupLocalIndexing, P as setupIntegrationTestRealm, Tt as testRealmSecretSeed, lt as setupRenderingTest, t as setupMockMatrix, wt as createJWT } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-//#region tests/integration/matrix-service-account-switch-sessions-test.ts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var testRealmServerURL = ensureTrailingSlash(config.realmServerURL);
-var SIGNED_IN_USER = "@testuser:localhost";
-var PREVIOUS_USER = "@previous-account:localhost";
-var PREVIOUS_ACCOUNT_REALM = `${new URL(testRealmURL).origin}/previous-account/personal/`;
-function claimsOf(token) {
-	return JSON.parse(atob(token.split(".")[1]));
-}
-(0, import_qunit.module)("Integration | matrix-service | sessions left by another account", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: SIGNED_IN_USER,
-		activeRealms: [baseRealm.url, testRealmURL],
-		activeRealmServers: [testRealmServerURL]
-	});
-	hooks.beforeEach(async function() {
-		await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {},
-			startMatrix: false
-		});
-		src_default.localStorage.setItem(RealmServerSessionLocalStorageKey, createJWT({
-			user: PREVIOUS_USER,
-			sessionRoom: "previous-account-room"
-		}, "1d", testRealmSecretSeed));
-		src_default.localStorage.setItem(SessionLocalStorageKey, JSON.stringify({ [PREVIOUS_ACCOUNT_REALM]: createJWT({
-			user: PREVIOUS_USER,
-			realm: PREVIOUS_ACCOUNT_REALM,
-			sessionRoom: "previous-account-realm-room",
-			permissions: [
-				"read",
-				"write",
-				"realm-owner"
-			],
-			realmServerURL: testRealmServerURL
-		}, "1d", testRealmSecretSeed) }));
-		let matrixService = getService("matrix-service");
-		await matrixService.ready;
-		await matrixService.start();
-	});
-	(0, import_qunit.test)("booting as a different user replaces the previous account’s sessions", async function(assert) {
-		let realmServer = getService("realm-server");
-		assert.strictEqual(claimsOf(realmServer.token).user, SIGNED_IN_USER, "the realm-server session is minted for the signed-in user");
-		assert.strictEqual(claimsOf(src_default.localStorage.getItem(RealmServerSessionLocalStorageKey)).user, SIGNED_IN_USER, "the stored realm-server session is the signed-in user’s");
-		let stored = JSON.parse(src_default.localStorage.getItem("boxel-session") ?? "{}");
-		assert.notOk(PREVIOUS_ACCOUNT_REALM in stored, "the previous account’s realm session is gone");
-		assert.deepEqual([...new Set(Object.values(stored).map((t) => claimsOf(t).user))], Object.keys(stored).length ? [SIGNED_IN_USER] : [], "every stored realm session is the signed-in user’s");
-		assert.notOk(realmServer.userRealmIdentifiers.some((r) => String(r).includes("previous-account")), "the realm list is not the previous account’s");
-	});
-});
-//#endregion

package/bundled-test-harness/assets/matrix-service-boot-assembly-test-CkdL_-os.js

@@ -1,300 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
-import { s as ensureTrailingSlash, w as ri } from "./paths-C9-NYXnM.js";
-import { O as baseRealm } from "./constants-Icc0nFW-.js";
-import { t as config } from "./environment-DIUJgBKt.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { F as setupLocalIndexing, P as setupIntegrationTestRealm, ft as setRealmAuthFailure, ht as setupPublicReadableRealms, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-//#region tests/integration/matrix-service-boot-assembly-test.ts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var testRealmServerURL = ensureTrailingSlash(config.realmServerURL);
-var normalizedTrustedServerURL = ensureTrailingSlash(new URL(config.resolvedBaseRealmURL).origin);
-(0, import_qunit.module)("Integration | matrix-service | boot assembly with trusted servers", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [baseRealm.url, testRealmURL],
-		activeRealmServers: [testRealmServerURL]
-	});
-	hooks.beforeEach(async function() {
-		await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {},
-			startMatrix: false
-		});
-		await getService("realm-server").setAvailableRealmIdentifiers([]);
-		let matrixService = getService("matrix-service");
-		await matrixService.ready;
-		await matrixService.start();
-	});
-	(0, import_qunit.test)("boot populates availableRealmIdentifiers when `app.boxel.realm-servers` is set", async function(assert) {
-		let realmServer = getService("realm-server");
-		assert.ok(realmServer.availableRealmIdentifiers.includes(ri(testRealmURL)), "testRealmURL is present in availableRealmIdentifiers");
-	});
-	(0, import_qunit.test)("fetchUserRealmsFromTrustedServers returns realms advertised by `_realm-auth`", async function(assert) {
-		let realms = await getService("realm-server").fetchUserRealmsFromTrustedServers([testRealmServerURL]);
-		assert.deepEqual(realms, [testRealmURL], "returns the trusted server’s realms");
-	});
-	(0, import_qunit.test)("a realm readable only through the public grant is not listed as the user's own", async function(assert) {
-		let publicOnlyRealmURL = "http://test-realm/someone-else/public/";
-		setupPublicReadableRealms([publicOnlyRealmURL]);
-		let realmServer = getService("realm-server");
-		let realms = await realmServer.fetchUserRealmsFromTrustedServers([testRealmServerURL]);
-		assert.deepEqual(realms, [testRealmURL], "the realm list leaves out the public-only realm");
-		let tokens = await realmServer.fetchTokensForAccessibleRealms();
-		assert.ok(tokens[publicOnlyRealmURL], "sessions are still minted for the public-only realm");
-	});
-	(0, import_qunit.test)("fetchUserRealmsFromTrustedServers returns [] for an empty input", async function(assert) {
-		let realms = await getService("realm-server").fetchUserRealmsFromTrustedServers([]);
-		assert.deepEqual(realms, [], "short-circuits without any HTTP call");
-	});
-	(0, import_qunit.test)("fetchUserRealmsFromTrustedServers rejects non-own realm-server URLs", async function(assert) {
-		let realmServer = getService("realm-server");
-		await assert.rejects(realmServer.fetchUserRealmsFromTrustedServers(["https://other-server.example/"]), /Multi-realm server support is not yet implemented/);
-	});
-});
-(0, import_qunit.module)("Integration | matrix-service | trusted-servers result survives legacy event", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [],
-		activeRealmServers: [testRealmServerURL]
-	});
-	hooks.beforeEach(async function() {
-		await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {},
-			startMatrix: false
-		});
-		await getService("realm-server").setAvailableRealmIdentifiers([]);
-		let matrixService = getService("matrix-service");
-		await matrixService.ready;
-		await matrixService.start();
-	});
-	(0, import_qunit.test)("legacy realms event does not overwrite the trusted-servers boot result", async function(assert) {
-		let realmServer = getService("realm-server");
-		assert.ok(realmServer.availableRealmIdentifiers.includes(ri(testRealmURL)), "testRealmURL from _realm-auth survives the legacy event");
-	});
-});
-(0, import_qunit.module)("Integration | matrix-service | boot assembly fallback to legacy realms", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [baseRealm.url, testRealmURL]
-	});
-	hooks.beforeEach(async function() {
-		await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {},
-			startMatrix: false
-		});
-		await getService("realm-server").setAvailableRealmIdentifiers([]);
-		let matrixService = getService("matrix-service");
-		await matrixService.ready;
-		await matrixService.start();
-	});
-	(0, import_qunit.test)("boot still populates realms from `app.boxel.realms`", async function(assert) {
-		let realmServer = getService("realm-server");
-		assert.ok(realmServer.availableRealmIdentifiers.includes(ri(testRealmURL)), "testRealmURL is present in availableRealmIdentifiers");
-	});
-});
-(0, import_qunit.module)("Integration | matrix-service | lazy migration seeds realm-servers", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL]
-	});
-	hooks.beforeEach(async function() {
-		await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {},
-			startMatrix: false
-		});
-		await getService("realm-server").setAvailableRealmIdentifiers([]);
-		let matrixService = getService("matrix-service");
-		await matrixService.ready;
-		await matrixService.start();
-	});
-	(0, import_qunit.test)("boot writes `app.boxel.realm-servers` with the backing realm-server", async function(assert) {
-		let realmServers = await getService("matrix-service").getRealmServersFromAccountData();
-		assert.deepEqual(realmServers, [normalizedTrustedServerURL], "the realm-server backing testRealmURL is persisted (own server, not the base-realm origin)");
-	});
-	(0, import_qunit.test)("boot retains the legacy `app.boxel.realms` key", async function(assert) {
-		assert.deepEqual(mockMatrixUtils.getActiveRealms(), [testRealmURL], "app.boxel.realms is left intact for rollback safety");
-	});
-	(0, import_qunit.test)("boot still assembles the available realms", async function(assert) {
-		let realmServer = getService("realm-server");
-		assert.ok(realmServer.availableRealmIdentifiers.includes(ri(testRealmURL)), "testRealmURL is present in availableRealmIdentifiers");
-	});
-	(0, import_qunit.test)("the migration self-write echo does not flip the boot to the trusted path", async function(assert) {
-		let matrixService = getService("matrix-service");
-		let realmServer = getService("realm-server");
-		assert.deepEqual(matrixService.bootAssemblyDebug, {
-			trustedRealmServersAuthoritative: false,
-			bootedFromLegacyRealmsList: true
-		}, "the session stays on the legacy path despite the realm-servers echo");
-		assert.ok(realmServer.availableRealmIdentifiers.includes(ri(testRealmURL)), "the legacy-assembled realm survives the echo");
-	});
-	(0, import_qunit.test)("a re-boot of the same session after migration stays on the legacy path", async function(assert) {
-		let matrixService = getService("matrix-service");
-		let realmServer = getService("realm-server");
-		await matrixService.start();
-		assert.deepEqual(await matrixService.getRealmServersFromAccountData(), [normalizedTrustedServerURL], "realm-servers stays as migrated — not re-derived or duplicated");
-		assert.ok(realmServer.availableRealmIdentifiers.includes(ri(testRealmURL)), "testRealmURL from the legacy list survives the re-boot");
-	});
-});
-(0, import_qunit.module)("Integration | matrix-service | graceful degradation when a trusted server is unreachable", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [baseRealm.url, testRealmURL],
-		activeRealmServers: [testRealmServerURL]
-	});
-	hooks.beforeEach(async function() {
-		await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {},
-			startMatrix: false
-		});
-		await getService("realm-server").setAvailableRealmIdentifiers([]);
-		setRealmAuthFailure(true);
-		let matrixService = getService("matrix-service");
-		await matrixService.ready;
-		await matrixService.start();
-	});
-	(0, import_qunit.test)("boot completes without dropping the reachable base realm", async function(assert) {
-		let realmServer = getService("realm-server");
-		assert.ok(realmServer.availableRealmIdentifiers.includes(ri(baseRealm.url)), "the base realm still loads when a trusted server is unreachable");
-		assert.notOk(realmServer.availableRealmIdentifiers.includes(ri(testRealmURL)), "the unreachable server’s realm is not in the list yet");
-	});
-	(0, import_qunit.test)("the unreachable trusted server is recorded so a notice can name it", async function(assert) {
-		let realmServer = getService("realm-server");
-		assert.deepEqual(realmServer.unreachableRealmServers, [testRealmServerURL], "the unreachable trusted server is recorded");
-	});
-	(0, import_qunit.test)("retry recovers the realm and clears the notice once the server is reachable", async function(assert) {
-		let realmServer = getService("realm-server");
-		let matrixService = getService("matrix-service");
-		setRealmAuthFailure(false);
-		let allRecovered = await matrixService.retryUnreachableRealmServers();
-		assert.ok(allRecovered, "retry reports all servers recovered");
-		assert.ok(realmServer.availableRealmIdentifiers.includes(ri(testRealmURL)), "the previously-unreachable realm now appears");
-		assert.deepEqual(realmServer.unreachableRealmServers, [], "the notice clears once the server is reachable");
-	});
-});
-(0, import_qunit.module)("Integration | matrix-service | account-data refresh survives a transient outage", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [baseRealm.url, testRealmURL],
-		activeRealmServers: [testRealmServerURL]
-	});
-	hooks.beforeEach(async function() {
-		await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {},
-			startMatrix: false
-		});
-		await getService("realm-server").setAvailableRealmIdentifiers([]);
-		let matrixService = getService("matrix-service");
-		await matrixService.ready;
-		await matrixService.start();
-	});
-	(0, import_qunit.test)("a refresh while the server is unreachable keeps the already-loaded realm", async function(assert) {
-		let realmServer = getService("realm-server");
-		let matrixService = getService("matrix-service");
-		assert.ok(realmServer.availableRealmIdentifiers.includes(ri(testRealmURL)), "the realm is loaded after a healthy boot");
-		setRealmAuthFailure(true);
-		await matrixService.applyTrustedRealmServersAccountData([testRealmServerURL]);
-		assert.ok(realmServer.availableRealmIdentifiers.includes(ri(testRealmURL)), "the transiently-unreachable realm is not wiped from the list");
-		assert.deepEqual(realmServer.unreachableRealmServers, [testRealmServerURL], "the server is recorded as unreachable so the notice shows");
-	});
-});
-(0, import_qunit.module)("Integration | matrix-service | already-migrated account is untouched", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL],
-		activeRealmServers: [testRealmServerURL]
-	});
-	hooks.beforeEach(async function() {
-		await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {},
-			startMatrix: false
-		});
-		await getService("realm-server").setAvailableRealmIdentifiers([]);
-		let matrixService = getService("matrix-service");
-		await matrixService.ready;
-		await matrixService.start();
-	});
-	(0, import_qunit.test)("boot leaves `app.boxel.realm-servers` unchanged", async function(assert) {
-		let matrixService = getService("matrix-service");
-		assert.deepEqual(await matrixService.getRealmServersFromAccountData(), [testRealmServerURL], "the existing realm-servers list is neither rewritten nor duplicated");
-	});
-});
-(0, import_qunit.module)("Integration | matrix-service | boot seeds own realm server for a keyless account", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, { loggedInAs: "@testuser:localhost" });
-	hooks.beforeEach(async function() {
-		await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {},
-			startMatrix: false
-		});
-		await getService("realm-server").setAvailableRealmIdentifiers([]);
-		let matrixService = getService("matrix-service");
-		await matrixService.ready;
-		await matrixService.start();
-	});
-	(0, import_qunit.test)("boot assembles the permissioned realm from `_realm-auth`", async function(assert) {
-		let realmServer = getService("realm-server");
-		assert.ok(realmServer.availableRealmIdentifiers.includes(ri(testRealmURL)), "testRealmURL from _realm-auth appears despite no account-data keys");
-	});
-	(0, import_qunit.test)("boot persists the own realm server into `app.boxel.realm-servers`", async function(assert) {
-		let matrixService = getService("matrix-service");
-		assert.deepEqual(await matrixService.getRealmServersFromAccountData(), [testRealmServerURL], "the trusted-servers key is seeded with the host’s own realm server");
-	});
-	(0, import_qunit.test)("boot takes the authoritative trusted-servers path", async function(assert) {
-		let matrixService = getService("matrix-service");
-		assert.deepEqual(matrixService.bootAssemblyDebug, {
-			trustedRealmServersAuthoritative: true,
-			bootedFromLegacyRealmsList: false
-		}, "permissions are the source of truth — no legacy-list dependency");
-	});
-});
-(0, import_qunit.module)("Integration | matrix-service | boot seed leaves a legacy account alone", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL]
-	});
-	hooks.beforeEach(async function() {
-		await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {},
-			startMatrix: false
-		});
-		await getService("realm-server").setAvailableRealmIdentifiers([]);
-		let matrixService = getService("matrix-service");
-		await matrixService.ready;
-		await matrixService.start();
-	});
-	(0, import_qunit.test)("the account stays on the legacy path (the seed does not fire)", async function(assert) {
-		let matrixService = getService("matrix-service");
-		assert.deepEqual(matrixService.bootAssemblyDebug, {
-			trustedRealmServersAuthoritative: false,
-			bootedFromLegacyRealmsList: true
-		}, "a legacy-list account is untouched by the keyless seed");
-	});
-});
-//#endregion