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

package/bundled-test-harness/assets/workspace-hosting-test-Ci7EEtHP.js

@@ -1,138 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { Br as testRealmURL, Rr as testRealmInfo } from "./runtime-common-BTaLJEw-.js";
-import { M as waitUntil, d as click, o as waitFor } from "./dist-BOAdzfkP.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { D as realmConfigCardJSON, F as setupLocalIndexing, L as setupRealmCacheTeardown, ct as setupApplicationTest, j as setupAcceptanceTestRealm, st as visitOperatorMode, t as setupMockMatrix, z as setupUserSubscription } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-//#region tests/acceptance/workspace-hosting-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var publishedRealmURL = "https://testuser.localhost/published-workspace/";
-var workspaceIndex = { data: {
-	type: "card",
-	meta: { adoptsFrom: {
-		module: "@cardstack/base/workspace",
-		name: "Workspace"
-	} }
-} };
-(0, import_qunit.module)("Acceptance | workspace hosting", function(hooks) {
-	setupApplicationTest(hooks);
-	setupLocalIndexing(hooks);
-	setupRealmCacheTeardown(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL]
-	});
-	let publishCalls;
-	let unpublishCalls;
-	hooks.beforeEach(async function() {
-		setupUserSubscription();
-		publishCalls = [];
-		unpublishCalls = [];
-		let { realm } = await setupAcceptanceTestRealm({
-			realmURL: testRealmURL,
-			mockMatrixUtils,
-			permissions: { "@testuser:localhost": [
-				"read",
-				"write",
-				"realm-owner"
-			] },
-			contents: {
-				"realm.json": realmConfigCardJSON({ name: "Hosted Workspace" }),
-				"index.json": workspaceIndex
-			}
-		});
-		realm.getRealmInfo = async () => ({
-			...testRealmInfo,
-			name: "Hosted Workspace",
-			publishable: true,
-			lastPublishedAt: { [publishedRealmURL]: String(Date.now()) }
-		});
-		let realmServer = getService("realm-server");
-		realmServer.publishRealm = async (sourceRealmURL, publishedURL) => {
-			publishCalls.push({
-				sourceRealmURL,
-				publishedRealmURL: publishedURL
-			});
-			return {
-				sourceRealmURL,
-				publishedRealmURL: publishedURL,
-				publishedRealmId: "1",
-				lastPublishedAt: String(Date.now()),
-				status: "published"
-			};
-		};
-		realmServer.unpublishRealm = async (publishedURL) => {
-			unpublishCalls.push(publishedURL);
-			return {
-				sourceRealmURL: null,
-				publishedRealmURL: publishedURL,
-				lastPublishedAt: null
-			};
-		};
-		realmServer.waitForRealmReady = async () => {};
-	});
-	async function visitWorkspaceSettings() {
-		await visitOperatorMode({ stacks: [[{
-			id: `${testRealmURL}index`,
-			format: "edit"
-		}]] });
-		await waitFor(".settings-title");
-	}
-	(0, import_qunit.test)("the hosting section lists each published site", async function(assert) {
-		await visitWorkspaceSettings();
-		assert.dom(`[data-test-unpublish-site="${publishedRealmURL}"]`).exists("the published site offers an unpublish action").hasText("Unpublish");
-	});
-	(0, import_qunit.test)("Unpublish reaches the unpublish-realm tool", async function(assert) {
-		await visitWorkspaceSettings();
-		await click(`[data-test-unpublish-site="${publishedRealmURL}"]`);
-		await waitUntil(() => unpublishCalls.length > 0);
-		assert.deepEqual(unpublishCalls, [publishedRealmURL], "the tool unpublished exactly the clicked destination");
-	});
-	(0, import_qunit.test)("a site that is unpublished stops being listed as live", async function(assert) {
-		await visitWorkspaceSettings();
-		await click(`[data-test-unpublish-site="${publishedRealmURL}"]`);
-		assert.dom(`[data-test-unpublish-site="${publishedRealmURL}"]`).doesNotExist("the row for the unpublished destination is gone");
-		assert.dom("[data-test-republish]").doesNotExist("Republish goes away with the last destination");
-		assert.dom("[data-test-hosting-error]").doesNotExist("no error is reported");
-		assert.dom(".settings").containsText("Not published", "the section falls back to its not-published copy");
-	});
-	(0, import_qunit.test)("an unpublish the server rejects keeps the row and says so", async function(assert) {
-		let realmServer = getService("realm-server");
-		realmServer.unpublishRealm = async () => {
-			throw new Error("destination is locked");
-		};
-		await visitWorkspaceSettings();
-		await click(`[data-test-unpublish-site="${publishedRealmURL}"]`);
-		assert.dom("[data-test-hosting-error]").hasText("Could not unpublish testuser.localhost: destination is locked", "the failure the tool reported is surfaced");
-		assert.dom(`[data-test-unpublish-site="${publishedRealmURL}"]`).exists("the site is still listed, because it is still published");
-	});
-	(0, import_qunit.test)("Republish reaches the publish-realm tool", async function(assert) {
-		await visitWorkspaceSettings();
-		await click("[data-test-republish]");
-		await waitUntil(() => publishCalls.length > 0);
-		assert.deepEqual(publishCalls, [{
-			sourceRealmURL: testRealmURL,
-			publishedRealmURL
-		}], "the tool republished the existing destination");
-		assert.dom(`[data-test-unpublish-site="${publishedRealmURL}"]`).exists("the destination is still listed after a republish");
-	});
-	(0, import_qunit.test)("either hosting action disables the other while it runs", async function(assert) {
-		let releaseUnpublish;
-		let realmServer = getService("realm-server");
-		let stalledUnpublish = realmServer.unpublishRealm;
-		realmServer.unpublishRealm = async (publishedURL) => {
-			await new Promise((resolve) => releaseUnpublish = resolve);
-			return stalledUnpublish.call(realmServer, publishedURL);
-		};
-		await visitWorkspaceSettings();
-		let clicked = click(`[data-test-unpublish-site="${publishedRealmURL}"]`);
-		await waitUntil(() => releaseUnpublish !== void 0);
-		await waitFor("[data-test-republish]:disabled");
-		assert.dom("[data-test-republish]").isDisabled("Republish cannot put the site back mid-unpublish");
-		assert.dom(`[data-test-unpublish-site="${publishedRealmURL}"]`).isDisabled("the in-flight destination cannot be unpublished twice");
-		releaseUnpublish();
-		await clicked;
-		assert.deepEqual(unpublishCalls, [publishedRealmURL], "the unpublish completed once released");
-	});
-});
-//#endregion

package/bundled-test-harness/assets/workspace-indexing-test-BPVxxY6W.js

@@ -1,71 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { F as setupLocalIndexing, P as setupIntegrationTestRealm, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-Dd8k0DNa.js";
-import { vt as setupBaseRealm, yt as setupWorkspaceCard } from "./base-realm-B17zVqh6.js";
-//#region tests/integration/workspace-indexing-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-(0, import_qunit.module)(`Integration | Workspace indexing/prerender safety`, function(hooks) {
-	setupRenderingTest(hooks);
-	setupBaseRealm(hooks);
-	setupWorkspaceCard(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks);
-	async function getInstance(realm, url) {
-		let maybeInstance = await realm.realmIndexQueryEngine.instance(url);
-		if (maybeInstance?.type === "instance-error") return;
-		return maybeInstance;
-	}
-	function countOccurrences(haystack, needle) {
-		return haystack.split(needle).length - 1;
-	}
-	(0, import_qunit.test)("indexing a Workspace renders its isolated shell and resolves pinned entry points without eagerly loading the Activity feed", async function(assert) {
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"pinned-a.json": { data: { meta: { adoptsFrom: {
-					module: "@cardstack/base/card-api",
-					name: "CardDef"
-				} } } },
-				"pinned-b.json": { data: { meta: { adoptsFrom: {
-					module: "@cardstack/base/card-api",
-					name: "CardDef"
-				} } } },
-				"ws.json": { data: {
-					relationships: {
-						"entryPoints.0": { links: { self: "./pinned-a" } },
-						"entryPoints.1": { links: { self: "./pinned-b" } }
-					},
-					meta: { adoptsFrom: {
-						module: "@cardstack/base/workspace",
-						name: "Workspace"
-					} }
-				} }
-			}
-		});
-		let instance = await getInstance(realm, new URL(`${testRealmURL}ws`));
-		assert.ok(instance, "the Workspace indexed cleanly (no render error on entry-point resolution)");
-		let isolatedHtml = instance?.isolatedHtml ?? "";
-		assert.ok(isolatedHtml.includes("data-test-workspace-index"), "the Workspace isolated shell rendered (not boilerplate, no crash)");
-		assert.ok(isolatedHtml.includes("data-test-workspace-tab=\"home\""), "the Home tab is present");
-		assert.ok(isolatedHtml.includes("data-test-workspace-tab=\"activity\""), "the Activity tab is present");
-		assert.ok(isolatedHtml.includes("Pinned"), "the Home segment rendered (the Pinned zone is present)");
-		assert.strictEqual(countOccurrences(isolatedHtml, "class=\"door\""), 2, "both pinned entry points rendered as doors");
-		assert.notOk(isolatedHtml.includes("activity-pane"), "the Activity pane did not render at index time");
-		assert.notOk(isolatedHtml.includes("feed-row"), "no Activity feed rows were eagerly loaded during indexing");
-	});
-	(0, import_qunit.test)("indexing a Workspace with no entry points still renders its shell cleanly", async function(assert) {
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "ws.json": { data: { meta: { adoptsFrom: {
-				module: "@cardstack/base/workspace",
-				name: "Workspace"
-			} } } } }
-		});
-		let isolatedHtml = (await getInstance(realm, new URL(`${testRealmURL}ws`)))?.isolatedHtml ?? "";
-		assert.ok(isolatedHtml.includes("data-test-workspace-index"), "the empty Workspace isolated shell rendered without error");
-		assert.strictEqual(countOccurrences(isolatedHtml, "class=\"door\""), 0, "no doors render when there are no entry points");
-		assert.notOk(isolatedHtml.includes("feed-row"), "no Activity feed rows were eagerly loaded during indexing");
-	});
-});
-//#endregion

package/bundled-test-harness/assets/workspace-test-CWr7vFbg.js

@@ -1,385 +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, Rc as Deferred } from "./runtime-common-BTaLJEw-.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 "./template-factory-ds9s0u8l.js";
-import { M as waitUntil, T as settled, a as find, c as triggerKeyEvent, d as click, k as visit, o as waitFor, s as fillIn, x as getSettledState } from "./dist-BOAdzfkP.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { D as realmConfigCardJSON, F as setupLocalIndexing, a as SYSTEM_CARD_FIXTURE_CONTENTS, ct as setupApplicationTest, j as setupAcceptanceTestRealm, mt as setupAuthEndpoints, t as setupMockMatrix, z as setupUserSubscription } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-//#region tests/acceptance/workspace-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var STACK = "[data-test-operator-mode-stack=\"0\"]";
-var WORKSPACE_NAME = "Test Workspace";
-var WORKSPACE_BUTTON = `[data-test-workspace-button="${WORKSPACE_NAME}"]`;
-(0, import_qunit.module)("Acceptance | workspace card", function(hooks) {
-	setupApplicationTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL]
-	});
-	let { createAndJoinRoom } = mockMatrixUtils;
-	hooks.beforeEach(async function() {
-		createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "room-test"
-		});
-		setupUserSubscription();
-		setupAuthEndpoints();
-		let loader = getService("loader-service").loader;
-		let { field, contains, CardDef, Component } = await loader.import("@cardstack/base/card-api");
-		let { default: StringField } = await loader.import("@cardstack/base/string");
-		let { Workspace } = await loader.import("@cardstack/base/workspace");
-		class Note extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
-					return contains(StringField);
-				});
-			}
-			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
-			static isolated = class Isolated extends Component {
-				static {
-					setComponentTemplate(templateFactory({
-						"id": "88EKxzt6",
-						"block": "[[[10,0],[14,\"data-test-note\",\"\"],[12],[8,[30,1,[\"cardTitle\"]],null,null,null],[13]],[\"@fields\"],[]]",
-						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/acceptance/workspace-test.gts",
-						"isStrictMode": true
-					}), this);
-				}
-			};
-		}
-		await setupAcceptanceTestRealm({
-			mockMatrixUtils,
-			contents: {
-				...SYSTEM_CARD_FIXTURE_CONTENTS,
-				"realm.json": realmConfigCardJSON({ name: WORKSPACE_NAME }),
-				"note.gts": { Note },
-				"index.json": new Workspace(),
-				"Note/1.json": new Note({ cardTitle: "First Note" }),
-				"welcome-song.mp3": "ID3 fake audio bytes",
-				"Remix/1.json": { data: {
-					attributes: { listingName: "Remixed Space" },
-					relationships: { remixedFrom: { links: { self: "../Note/1" } } },
-					meta: { adoptsFrom: {
-						module: "@cardstack/base/remix-card",
-						name: "RemixCard"
-					} }
-				} }
-			}
-		});
-	});
-	(0, import_qunit.test)("a realm indexed by Workspace renders its shell and switches segments", async function(assert) {
-		await visit("/");
-		assert.dom("[data-test-dashboard]").exists();
-		await click(WORKSPACE_BUTTON);
-		await waitFor(`${STACK} nav.tabs`);
-		assert.dom(`${STACK} nav.tabs [data-test-workspace-tab]`).exists({ count: 3 }, "Home, Library, and Activity tabs render");
-		assert.dom(`${STACK} nav.tabs [aria-current="true"]`).hasText("Home", "Home is the default segment");
-		await click(`${STACK} [data-test-workspace-tab="library"]`);
-		assert.dom(`${STACK} [data-test-library]`).exists("Library pane renders");
-		await click(`${STACK} [data-test-workspace-tab="activity"]`);
-		assert.dom(`${STACK} [data-test-activity]`).exists("Activity pane renders");
-	});
-	function findTypeChip(assert, label) {
-		let chip = [...document.querySelectorAll(`${STACK} [data-test-type-chip]`)].find((el) => el.textContent?.includes(label));
-		assert.ok(chip, `a pill for the ${label} card type is present`);
-		if (!(chip instanceof HTMLElement)) throw new Error(`no Browse pill labelled "${label}" was rendered`);
-		return chip;
-	}
-	(0, import_qunit.test)("the \"New card\" chooser searches across all available realms, not just this workspace", async function(assert) {
-		await visit("/");
-		await click(WORKSPACE_BUTTON);
-		await waitFor(`${STACK} nav.tabs`);
-		await click(`${STACK} [data-test-welcome-new-card]`);
-		await waitFor("[data-test-card-chooser-modal]");
-		await waitFor("[data-test-realm-picker] [data-test-boxel-picker-trigger]");
-		await click("[data-test-realm-picker] [data-test-boxel-picker-trigger]");
-		await waitFor("[data-test-boxel-picker-option-row]");
-		assert.dom(`[data-test-boxel-picker-option-row="${baseRealm.url}"]`).exists("a realm other than the workspace realm is selectable");
-		assert.dom(`[data-test-boxel-picker-option-row="${testRealmURL}"]`).exists("the workspace realm is also among the choices");
-	});
-	(0, import_qunit.test)("Home Browse lists a pill per card type with its instance count", async function(assert) {
-		await visit("/");
-		await click(WORKSPACE_BUTTON);
-		await waitFor(`${STACK} nav.tabs`);
-		await waitFor(`${STACK} [data-test-browse]`);
-		assert.dom(`${STACK} [data-test-browse]`).exists("the Home Browse module renders once the realm reports inventory");
-		let noteChip = findTypeChip(assert, "Note");
-		assert.dom(noteChip.querySelector("[data-test-type-chip-count]")).hasText("1", "the Note pill shows its single-instance count");
-	});
-	(0, import_qunit.test)("clicking a Home Browse pill opens the Library filtered to that type", async function(assert) {
-		await visit("/");
-		await click(WORKSPACE_BUTTON);
-		await waitFor(`${STACK} [data-test-browse]`);
-		let noteChip = findTypeChip(assert, "Note");
-		assert.ok(noteChip.getAttribute("data-test-type-chip"), "the Note pill carries the type id it filters on");
-		await click(noteChip);
-		assert.dom(`${STACK} nav.tabs [aria-current="true"]`).hasText("Library", "the pill switches to the Library segment");
-		assert.dom(`${STACK} [data-test-selected-filter="Note"]`).exists("the Library opens with the clicked type pre-selected");
-	});
-	(0, import_qunit.test)("the Library rail lists a row per card type with its count", async function(assert) {
-		await visit("/");
-		await click(WORKSPACE_BUTTON);
-		await waitFor(`${STACK} nav.tabs`);
-		await click(`${STACK} [data-test-workspace-tab="library"]`);
-		await waitFor(`${STACK} [data-test-rail-group]`);
-		assert.dom(`${STACK} [data-test-boxel-filter-list-button="Note"] [data-test-filter-list-count]`).hasText("1", "the Note rail row shows its single-instance count");
-	});
-	(0, import_qunit.test)("Escape on a focused search result dismisses the results and keeps the workspace open", async function(assert) {
-		await visit("/");
-		await click(WORKSPACE_BUTTON);
-		await waitFor(`${STACK} nav.tabs`);
-		await fillIn(`${STACK} [data-test-workspace-search]`, "First");
-		await waitFor(`${STACK} [data-test-search-result]`);
-		let result = find(`${STACK} [data-test-search-result]`);
-		result.focus();
-		await triggerKeyEvent(result, "keydown", "Escape");
-		assert.dom(`${STACK} [data-test-workspace-index]`).exists("the workspace card is still open");
-		assert.dom(`${STACK} [data-test-search-result]`).doesNotExist("the results are dismissed");
-		assert.dom(`${STACK} [data-test-workspace-search]`).hasValue("", "the term is cleared");
-	});
-	(0, import_qunit.test)("a remix surfaces in the Activity feed as a first-class event", async function(assert) {
-		await visit("/");
-		await click(WORKSPACE_BUTTON);
-		await waitFor(`${STACK} nav.tabs`);
-		await click(`${STACK} [data-test-workspace-tab="activity"]`);
-		await waitFor(`${STACK} [data-test-feed-verb="Remixed"]`);
-		assert.dom(`${STACK} [data-test-feed-verb="Remixed"]`).hasText("Remixed", "the remix reads as a Remixed event, not a save");
-		await waitFor(`${STACK} [data-test-feed-remix-source]`);
-		assert.dom(`${STACK} [data-test-feed-remix-source]`).hasText("from First Note", "the event names the source it was cloned from");
-	});
-	(0, import_qunit.test)("an uploaded file surfaces in the Activity feed alongside cards", async function(assert) {
-		await visit("/");
-		await click(WORKSPACE_BUTTON);
-		await waitFor(`${STACK} nav.tabs`);
-		await click(`${STACK} [data-test-workspace-tab="activity"]`);
-		await waitFor(`${STACK} [data-test-feed-row]`);
-		let rows = [...document.querySelectorAll(`${STACK} [data-test-feed-row]`)];
-		let titleOf = (row) => row.querySelector("[data-test-feed-title]")?.textContent?.trim();
-		let fileRow = rows.find((row) => titleOf(row) === "welcome-song.mp3");
-		assert.ok(fileRow, `the uploaded audio file appears in the feed (saw: ${rows.map(titleOf).join(", ")})`);
-		let when = fileRow.querySelector("[data-test-feed-when]")?.textContent?.trim() ?? "";
-		assert.notStrictEqual(when, "—", "the file row carries a real timestamp, not the missing-date placeholder");
-		assert.notStrictEqual(when, "", "the file row renders its timestamp rail");
-		assert.notOk(rows.some((row) => titleOf(row) === "note.gts"), "a source module does not appear in the feed");
-	});
-	(0, import_qunit.test)("opening a file feed row opens the file, not a card", async function(assert) {
-		await visit("/");
-		await click(WORKSPACE_BUTTON);
-		await waitFor(`${STACK} nav.tabs`);
-		await click(`${STACK} [data-test-workspace-tab="activity"]`);
-		await waitFor(`${STACK} [data-test-feed-row]`);
-		await click(`${STACK} [aria-label="Open welcome-song.mp3"]`);
-		await waitFor(`[data-test-stack-card="${testRealmURL}welcome-song.mp3"]`);
-		assert.dom(`[data-test-stack-card="${testRealmURL}welcome-song.mp3"]`).exists("the file opens as a file stack item");
-	});
-});
-(0, import_qunit.module)("Acceptance | workspace card | Library pages", function(hooks) {
-	setupApplicationTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL]
-	});
-	let { createAndJoinRoom } = mockMatrixUtils;
-	let realm;
-	const PAGE_SIZE = 5;
-	const NOTE_COUNT = 7;
-	const LAST_NOTE = noteId(NOTE_COUNT);
-	const GRID_ITEM = `${STACK} [data-test-cards-grid-cards] [data-test-cards-grid-item]`;
-	const PAGINATION = `${STACK} [data-test-card-list-pagination]`;
-	hooks.beforeEach(async function() {
-		createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "room-test"
-		});
-		setupUserSubscription();
-		setupAuthEndpoints();
-		let loader = getService("loader-service").loader;
-		let { field, contains, CardDef } = await loader.import("@cardstack/base/card-api");
-		let { default: StringField } = await loader.import("@cardstack/base/string");
-		let { Workspace } = await loader.import("@cardstack/base/workspace");
-		class Note extends CardDef {
-			static displayName = "Note";
-			static {
-				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
-					return contains(StringField);
-				});
-			}
-			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
-		}
-		class Memo extends CardDef {
-			static displayName = "Memo";
-			static {
-				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
-					return contains(StringField);
-				});
-			}
-			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
-		}
-		class PagedWorkspace extends Workspace {
-			static libraryPageSize = PAGE_SIZE;
-		}
-		let notes = {};
-		for (let i = 1; i <= NOTE_COUNT; i++) {
-			let n = String(i).padStart(3, "0");
-			notes[`${noteId(i)}.json`] = new Note({ cardTitle: `Note ${n}` });
-		}
-		({realm} = await setupAcceptanceTestRealm({
-			mockMatrixUtils,
-			contents: {
-				...SYSTEM_CARD_FIXTURE_CONTENTS,
-				"realm.json": realmConfigCardJSON({ name: WORKSPACE_NAME }),
-				"note.gts": {
-					Note,
-					Memo,
-					PagedWorkspace
-				},
-				"index.json": new PagedWorkspace(),
-				"Memo/1.json": new Memo({ cardTitle: "Only Memo" }),
-				...notes
-			}
-		}));
-	});
-	async function openLibraryFilter(name) {
-		await visit("/");
-		await click(WORKSPACE_BUTTON);
-		await waitFor(`${STACK} nav.tabs`);
-		await click(`${STACK} [data-test-workspace-tab="library"]`);
-		await waitFor(`${STACK} [data-test-boxel-filter-list-button="${name}"]`);
-		await click(`${STACK} [data-test-boxel-filter-list-button="${name}"]`);
-	}
-	function noteId(i) {
-		return `Note/${String(i).padStart(3, "0")}`;
-	}
-	function gridItemCount() {
-		return document.querySelectorAll(GRID_ITEM).length;
-	}
-	function describeLibrary() {
-		let ids = [...document.querySelectorAll(GRID_ITEM)].map((el) => (el.getAttribute("data-test-cards-grid-item") ?? "?").replace(testRealmURL, ""));
-		let page = document.querySelector(`${PAGINATION} [aria-current="page"]`)?.textContent?.trim() ?? "<no page controls>";
-		let loading = Boolean(document.querySelector(`${STACK} [data-test-card-list-loading]`));
-		let s = getSettledState();
-		return [
-			`grid items (${ids.length}): [${ids.join(", ")}]`,
-			`current page: ${page}`,
-			`loading state shown: ${loading}`,
-			`settled state: hasRunLoop=${s.hasRunLoop} hasPendingTimers=${s.hasPendingTimers} hasPendingWaiters=${s.hasPendingWaiters} hasPendingRequests=${s.hasPendingRequests} isRenderPending=${s.isRenderPending}`
-		].join("; ");
-	}
-	async function waitForGridItems(count) {
-		let startedAt = Date.now();
-		try {
-			await waitUntil(() => gridItemCount() === count);
-		} catch {
-			throw new Error(`expected ${count} grid items, gave up after ${Date.now() - startedAt}ms; ${describeLibrary()}`);
-		}
-	}
-	(0, import_qunit.test)("a filter with more rows than a page steps through them page by page", async function(assert) {
-		await openLibraryFilter("Note");
-		await waitForGridItems(PAGE_SIZE);
-		assert.dom(PAGINATION).exists("the Library offers page controls");
-		assert.dom(`${PAGINATION} [aria-current="page"]`).hasText("1");
-		assert.dom(`${GRID_ITEM}[data-test-cards-grid-item="${testRealmURL}${LAST_NOTE}"]`).doesNotExist("the last note is past the first page");
-		await click(`${PAGINATION} [aria-label="Next"]`);
-		await waitForGridItems(NOTE_COUNT - PAGE_SIZE);
-		assert.dom(`${PAGINATION} [aria-current="page"]`).hasText("2");
-		assert.dom(`${GRID_ITEM}[data-test-cards-grid-item="${testRealmURL}${LAST_NOTE}"]`).exists("the second page holds the rest");
-		assert.dom(`${GRID_ITEM}[data-test-cards-grid-item="${testRealmURL}${noteId(1)}"]`).doesNotExist("and not the first page again");
-	});
-	(0, import_qunit.test)("the next page shows a loading state, not the last page, until it arrives", async function(assert) {
-		let secondPageRequested = new Deferred();
-		let releaseSecondPage = new Deferred();
-		getService("network").virtualNetwork.mount(async (request) => {
-			if (request.url.endsWith("/_federated-search") && (await request.clone().json())?.page?.number === 1) {
-				secondPageRequested.fulfill();
-				await releaseSecondPage.promise;
-			}
-			return null;
-		}, { prepend: true });
-		await openLibraryFilter("Note");
-		await waitForGridItems(PAGE_SIZE);
-		let clicked = click(`${PAGINATION} [aria-label="Next"]`);
-		try {
-			await secondPageRequested.promise;
-			await waitFor(`${STACK} [data-test-card-list-loading]`);
-			assert.dom(GRID_ITEM).doesNotExist("the first page is not left up as if it were the next");
-			assert.dom(`${PAGINATION} [aria-current="page"]`).hasText("2", "the controls already point at the page being loaded");
-		} finally {
-			releaseSecondPage.fulfill();
-		}
-		await clicked;
-		await waitForGridItems(NOTE_COUNT - PAGE_SIZE);
-		assert.dom(`${STACK} [data-test-card-list-loading]`).doesNotExist();
-	});
-	(0, import_qunit.test)("a page emptied by deletions moves back to the last page", async function(assert) {
-		await openLibraryFilter("Note");
-		await waitForGridItems(PAGE_SIZE);
-		await click(`${PAGINATION} [aria-label="Next"]`);
-		await waitForGridItems(NOTE_COUNT - PAGE_SIZE);
-		for (let i = 6; i <= NOTE_COUNT; i++) await realm.delete(`${noteId(i)}.json`);
-		let deletedAt = Date.now();
-		await settled();
-		let settledAfterMs = Date.now() - deletedAt;
-		if (gridItemCount() !== PAGE_SIZE) console.warn(`[library-pages] settled ${settledAfterMs}ms after the deletions with the grid not yet on the last page; ${describeLibrary()}`);
-		await waitForGridItems(PAGE_SIZE);
-		assert.dom(`${GRID_ITEM}[data-test-cards-grid-item="${testRealmURL}${noteId(1)}"]`).exists("the grid shows the one page left");
-		assert.dom(PAGINATION).doesNotExist("and offers no controls for a single page");
-	});
-	(0, import_qunit.test)("changing the filter starts again at page 1", async function(assert) {
-		await openLibraryFilter("Note");
-		await waitForGridItems(PAGE_SIZE);
-		await click(`${PAGINATION} [aria-label="Next"]`);
-		await waitForGridItems(NOTE_COUNT - PAGE_SIZE);
-		await click(`${STACK} [data-test-boxel-filter-list-button="Memo"]`);
-		await waitForGridItems(1);
-		assert.dom(PAGINATION).doesNotExist("a filter that fits on one page shows no page controls");
-		await click(`${STACK} [data-test-boxel-filter-list-button="Note"]`);
-		await waitForGridItems(PAGE_SIZE);
-		assert.dom(`${PAGINATION} [aria-current="page"]`).hasText("1");
-	});
-	(0, import_qunit.test)("a search term that still reaches the page starts again at page 1", async function(assert) {
-		await openLibraryFilter("Note");
-		await waitForGridItems(PAGE_SIZE);
-		await click(`${PAGINATION} [aria-label="Next"]`);
-		await waitForGridItems(NOTE_COUNT - PAGE_SIZE);
-		await fillIn(`${STACK} [data-test-workspace-search]`, "Note");
-		await waitForGridItems(PAGE_SIZE);
-		assert.dom(`${PAGINATION} [aria-current="page"]`).hasText("1");
-		assert.dom(`${GRID_ITEM}[data-test-cards-grid-item="${testRealmURL}${noteId(1)}"]`).exists("the grid shows the first page of the narrowed list");
-	});
-	(0, import_qunit.test)("a search term typed past page 1 keeps the rows up while it loads", async function(assert) {
-		let termRequested = new Deferred();
-		let releaseTerm = new Deferred();
-		getService("network").virtualNetwork.mount(async (request) => {
-			if (request.url.endsWith("/_federated-search")) {
-				let body = await request.clone().json();
-				if (body?.page?.size === PAGE_SIZE && JSON.stringify(body.filter).includes("Note 00")) {
-					termRequested.fulfill();
-					await releaseTerm.promise;
-				}
-			}
-			return null;
-		}, { prepend: true });
-		await openLibraryFilter("Note");
-		await waitForGridItems(PAGE_SIZE);
-		await click(`${PAGINATION} [aria-label="Next"]`);
-		await waitForGridItems(NOTE_COUNT - PAGE_SIZE);
-		let typed = fillIn(`${STACK} [data-test-workspace-search]`, "Note 00");
-		try {
-			await termRequested.promise;
-			await waitUntil(() => find(`${PAGINATION} [aria-current="page"]`)?.textContent?.trim() === "1");
-			assert.dom(GRID_ITEM).exists({ count: NOTE_COUNT - PAGE_SIZE }, "the rows on screen stay up until the narrowed list arrives");
-		} finally {
-			releaseTerm.fulfill();
-		}
-		await typed;
-		await waitForGridItems(PAGE_SIZE);
-		assert.dom(`${PAGINATION} [aria-current="page"]`).hasText("1");
-	});
-});
-//#endregion

package/bundled-test-harness/assets/workspace-test-INNpQovc.js

@@ -1,51 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { lt as setupRenderingTest } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-import { G as Workspace, vt as setupBaseRealm, yt as setupWorkspaceCard } from "./base-realm-B17zVqh6.js";
-import { t as renderCard } from "./render-component-B15Z0e2v.js";
-//#region tests/integration/components/workspace-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-(0, import_qunit.module)("Integration | Card | workspace", function(hooks) {
-	setupRenderingTest(hooks);
-	setupBaseRealm(hooks);
-	setupWorkspaceCard(hooks);
-	let loader;
-	hooks.beforeEach(function() {
-		loader = getService("loader-service").loader;
-	});
-	(0, import_qunit.test)("isolated format renders the Home/Library/Activity tab shell", async function(assert) {
-		let card = new Workspace({});
-		await renderCard(loader, card, "isolated");
-		assert.dom("nav.tabs").exists("renders the sections nav");
-		assert.dom("nav.tabs [data-test-workspace-tab]").exists({ count: 3 }, "Home, Library, and Activity tabs");
-		assert.dom("nav.tabs [aria-current=\"true\"]").hasText("Home", "Home is the default active segment");
-	});
-	(0, import_qunit.test)("Home omits the Browse module when the realm has no inventory", async function(assert) {
-		let card = new Workspace({});
-		await renderCard(loader, card, "isolated");
-		assert.dom("nav.tabs [aria-current=\"true\"]").hasText("Home", "Home is the active segment");
-		assert.dom("[data-test-browse]").doesNotExist("Browse stays hidden until the realm reports inventory");
-	});
-	(0, import_qunit.test)("edit format renders workspace settings", async function(assert) {
-		let card = new Workspace({});
-		await renderCard(loader, card, "edit");
-		assert.dom("[data-test-settings-title]").hasText("Workspace settings");
-	});
-	(0, import_qunit.module)("missing RealmConfig", function() {
-		(0, import_qunit.test)("Home renders without a linked RealmConfig", async function(assert) {
-			let card = new Workspace({});
-			await renderCard(loader, card, "isolated");
-			assert.dom("[data-test-workspace-index]").exists("the isolated shell renders");
-			assert.dom("nav.tabs [aria-current=\"true\"]").hasText("Home", "Home is active and its stage rendered without error");
-		});
-		(0, import_qunit.test)("settings render, omitting the config-owned identity inputs", async function(assert) {
-			let card = new Workspace({});
-			await renderCard(loader, card, "edit");
-			assert.dom("[data-test-settings-title]").hasText("Workspace settings", "the settings form still renders");
-			assert.dom("input[placeholder=\"Workspace name\"]").doesNotExist("the config-owned name input is omitted, not errored");
-			assert.dom("input[placeholder=\"https://…\"]").doesNotExist("the config-owned icon input is omitted, not errored");
-		});
-	});
-});
-//#endregion