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

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

@@ -0,0 +1,138 @@
+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-FjsXmU7-.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-B34T3kqD.js

@@ -0,0 +1,71 @@
+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-FjsXmU7-.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-CJivgv-m.js

@@ -0,0 +1,51 @@
+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-FjsXmU7-.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

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

@@ -0,0 +1,385 @@
+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-FjsXmU7-.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