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

package/bundled-test-harness/assets/file-preview-live-reload-test-MzwGwasU.js

@@ -0,0 +1,310 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
+import { M as waitUntil } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, I as setupOnSave, a as SYSTEM_CARD_FIXTURE_CONTENTS, ct as setupApplicationTest, j as setupAcceptanceTestRealm, mt as setupAuthEndpoints, st as visitOperatorMode, t as setupMockMatrix, z as setupUserSubscription } from "./mock-matrix-FjsXmU7-.js";
+import { t as setupTestRealmServiceWorker } from "./test-realm-service-worker-OVn3b7N-.js";
+//#region tests/acceptance/interact-submode/file-preview-live-reload-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var encoder = new TextEncoder();
+function svgImage(width) {
+	return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="10" viewBox="0 0 ${width} 10"><rect width="${width}" height="10" fill="#38f"/></svg>`;
+}
+function wavOfSeconds(seconds) {
+	let sampleRate = 8e3;
+	let dataSize = sampleRate * seconds;
+	let bytes = new Uint8Array(44 + dataSize).fill(128, 44);
+	let view = new DataView(bytes.buffer);
+	bytes.set(encoder.encode("RIFF"), 0);
+	view.setUint32(4, 36 + dataSize, true);
+	bytes.set(encoder.encode("WAVEfmt "), 8);
+	view.setUint32(16, 16, true);
+	view.setUint16(20, 1, true);
+	view.setUint16(22, 1, true);
+	view.setUint32(24, sampleRate, true);
+	view.setUint32(28, sampleRate, true);
+	view.setUint16(32, 1, true);
+	view.setUint16(34, 8, true);
+	bytes.set(encoder.encode("data"), 36);
+	view.setUint32(40, dataSize, true);
+	return bytes;
+}
+function ebml(id, body) {
+	let idBytes = [];
+	for (let value = id; value > 0; value = Math.floor(value / 256)) idBytes.unshift(value & 255);
+	let size = [
+		1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	];
+	let length = body.length;
+	for (let i = 7; i > 0 && length > 0; i--) {
+		size[i] = length & 255;
+		length = Math.floor(length / 256);
+	}
+	return [
+		...idBytes,
+		...size,
+		...body
+	];
+}
+function webmTitled(title) {
+	let header = ebml(440786851, ebml(17030, [1]));
+	let info = ebml(357149030, ebml(31657, [...encoder.encode(title)]));
+	return new Uint8Array([...header, ...ebml(408125543, info)]);
+}
+function pdfTitled(title) {
+	return `%PDF-1.7
+1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj
+2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1>>endobj
+3 0 obj<</Type/Page/Parent 2 0 R>>endobj
+4 0 obj<</Title(${title})>>endobj\ntrailer<</Root 1 0 R/Info 4 0 R>>
+%%EOF
+`;
+}
+function stlTriangle(width, height) {
+	return [
+		"solid tri",
+		" facet normal 0 0 1",
+		"  outer loop",
+		"   vertex 0 0 0",
+		`   vertex ${width} 0 0`,
+		`   vertex 0 ${height} 0`,
+		"  endloop",
+		" endfacet",
+		"endsolid tri"
+	].join("\n");
+}
+function fontWithMarker(marker) {
+	return new Uint8Array([
+		0,
+		1,
+		0,
+		0,
+		...new Array(8).fill(0),
+		...encoder.encode(marker)
+	]);
+}
+async function textAt(url) {
+	return await (await fetch(url)).text();
+}
+function pdfObjectData() {
+	return document.querySelector("[data-test-pdf-viewer]")?.getAttribute("data") ?? "";
+}
+(0, import_qunit.module)("Acceptance | interact submode | file preview live reload", function(hooks) {
+	let realm;
+	setupApplicationTest(hooks);
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	setupTestRealmServiceWorker(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL]
+	});
+	hooks.beforeEach(async function() {
+		mockMatrixUtils.createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "room-test"
+		});
+		setupUserSubscription();
+		setupAuthEndpoints();
+		({realm} = await setupAcceptanceTestRealm({
+			mockMatrixUtils,
+			contents: {
+				...SYSTEM_CARD_FIXTURE_CONTENTS,
+				"picture.svg": svgImage(20),
+				"tone.wav": wavOfSeconds(2),
+				"clip.webm": webmTitled("first cut"),
+				"report.pdf": pdfTitled("First draft"),
+				"part.stl": stlTriangle(2, 4),
+				"face.ttf": fontWithMarker("first")
+			}
+		}));
+	});
+	async function openInInteractStack(path) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}${path}`,
+			format: "isolated",
+			type: "file"
+		}]] });
+	}
+	(0, import_qunit.test)("image preview shows the new picture after its file is written", async function(assert) {
+		await openInInteractStack("picture.svg");
+		let image = () => document.querySelector("[data-test-image-preview]");
+		await waitUntil(() => image()?.complete && image().naturalWidth === 20, {
+			timeout: 5e3,
+			timeoutMessage: "the first picture did not load"
+		});
+		await realm.write("picture.svg", svgImage(60));
+		await waitUntil(() => image()?.complete && image().naturalWidth === 60, {
+			timeout: 5e3,
+			timeoutMessage: "the image preview kept the first picture"
+		});
+		assert.strictEqual(image().naturalWidth, 60, "the image element decoded the rewritten file");
+	});
+	(0, import_qunit.test)("audio preview loads the new track after its file is written", async function(assert) {
+		await openInInteractStack("tone.wav");
+		let player = () => document.querySelector("[data-test-audio-player]");
+		await waitUntil(() => player()?.duration === 2, {
+			timeout: 5e3,
+			timeoutMessage: "the first track did not load"
+		});
+		await realm.write("tone.wav", wavOfSeconds(3));
+		await waitUntil(() => player()?.duration === 3, {
+			timeout: 5e3,
+			timeoutMessage: "the audio player kept the first track"
+		});
+		assert.strictEqual(player().duration, 3, "the player loaded the rewritten file");
+	});
+	(0, import_qunit.test)("video preview hands its player the new bytes after its file is written", async function(assert) {
+		await openInInteractStack("clip.webm");
+		let playerSrc = () => document.querySelector("[data-test-video-player]")?.getAttribute("src") ?? "";
+		await waitUntil(() => playerSrc().startsWith("blob:"), {
+			timeout: 5e3,
+			timeoutMessage: "the video player did not receive the first file"
+		});
+		assert.true((await textAt(playerSrc())).includes("first cut"), "the player starts with the first file");
+		let firstSrc = playerSrc();
+		await realm.write("clip.webm", webmTitled("second cut"));
+		await waitUntil(() => playerSrc() !== firstSrc && playerSrc().startsWith("blob:"), {
+			timeout: 5e3,
+			timeoutMessage: "the video player kept the first file"
+		});
+		assert.true((await textAt(playerSrc())).includes("second cut"), "the player holds the rewritten file");
+	});
+	(0, import_qunit.test)("PDF viewer hands its object the new document after its file is written", async function(assert) {
+		await openInInteractStack("report.pdf");
+		await waitUntil(() => pdfObjectData().startsWith("blob:"), {
+			timeout: 5e3,
+			timeoutMessage: "the PDF viewer did not receive the first document"
+		});
+		assert.true((await textAt(pdfObjectData())).includes("First draft"), "the viewer starts with the first document");
+		let firstData = pdfObjectData();
+		await realm.write("report.pdf", pdfTitled("Second draft"));
+		await waitUntil(() => pdfObjectData() !== firstData && pdfObjectData().startsWith("blob:"), {
+			timeout: 5e3,
+			timeoutMessage: "the PDF viewer kept the first document"
+		});
+		assert.true((await textAt(pdfObjectData())).includes("Second draft"), "the viewer holds the rewritten document");
+	});
+	(0, import_qunit.module)("PDF viewer while it refetches", function(hooks) {
+		let holding;
+		let heldFetches;
+		let release;
+		let released;
+		let nativeFetch;
+		hooks.beforeEach(function() {
+			holding = false;
+			heldFetches = 0;
+			released = new Promise((resolve) => release = resolve);
+			nativeFetch = globalThis.fetch;
+			globalThis.fetch = async (input, init) => {
+				let url = input instanceof Request ? input.url : String(input);
+				if (holding && url.includes("report.pdf")) {
+					heldFetches++;
+					await released;
+				}
+				return nativeFetch(input, init);
+			};
+		});
+		hooks.afterEach(function() {
+			release();
+			globalThis.fetch = nativeFetch;
+		});
+		(0, import_qunit.test)("PDF viewer keeps the document it shows loadable until the rewritten one arrives", async function(assert) {
+			await openInInteractStack("report.pdf");
+			await waitUntil(() => pdfObjectData().startsWith("blob:"), {
+				timeout: 5e3,
+				timeoutMessage: "the PDF viewer did not receive the first document"
+			});
+			let firstData = pdfObjectData();
+			holding = true;
+			await realm.write("report.pdf", pdfTitled("Second draft"));
+			await waitUntil(() => heldFetches > 0, {
+				timeout: 5e3,
+				timeoutMessage: "the PDF viewer did not refetch the document"
+			});
+			assert.strictEqual(pdfObjectData(), firstData, "the viewer keeps showing the first document while it refetches");
+			assert.true((await textAt(firstData)).includes("First draft"), "the document on screen is still loadable during the refetch");
+			release();
+			await waitUntil(() => pdfObjectData() !== firstData && pdfObjectData().startsWith("blob:"), {
+				timeout: 5e3,
+				timeoutMessage: "the PDF viewer kept the first document"
+			});
+			assert.true((await textAt(pdfObjectData())).includes("Second draft"), "the viewer holds the rewritten document");
+			await assert.rejects(textAt(firstData), "the replaced document is released");
+		});
+	});
+	(0, import_qunit.module)("3D viewer", function(hooks) {
+		let fetchedModels;
+		let nativeFetch;
+		hooks.beforeEach(function() {
+			fetchedModels = [];
+			nativeFetch = globalThis.fetch;
+			globalThis.fetch = async (input, init) => {
+				let response = await nativeFetch(input, init);
+				if ((input instanceof Request ? input.url : String(input)).includes("part.stl")) fetchedModels.push(response.clone().text());
+				return response;
+			};
+		});
+		hooks.afterEach(function() {
+			globalThis.fetch = nativeFetch;
+		});
+		async function lastFetchedModel() {
+			return await fetchedModels[fetchedModels.length - 1];
+		}
+		(0, import_qunit.test)("3D viewer fetches the new geometry after its file is written", async function(assert) {
+			await openInInteractStack("part.stl");
+			await waitUntil(() => fetchedModels.length > 0, {
+				timeout: 15e3,
+				timeoutMessage: "the viewer did not fetch the first model"
+			});
+			assert.true((await lastFetchedModel()).includes("vertex 2 0 0"), "the viewer starts with the first model");
+			let firstCount = fetchedModels.length;
+			await realm.write("part.stl", stlTriangle(6, 8));
+			await waitUntil(() => fetchedModels.length > firstCount, {
+				timeout: 15e3,
+				timeoutMessage: "the 3D viewer did not refetch the model"
+			});
+			assert.true((await lastFetchedModel()).includes("vertex 6 0 0"), "the viewer fetched the rewritten model");
+		});
+	});
+	(0, import_qunit.module)("font specimen", function(hooks) {
+		let requestedFaces;
+		let NativeFontFace;
+		hooks.beforeEach(function() {
+			requestedFaces = [];
+			NativeFontFace = globalThis.FontFace;
+			globalThis.FontFace = class extends NativeFontFace {
+				constructor(family, source, descriptors) {
+					super(family, source, descriptors);
+					if (typeof source === "string") requestedFaces.push(source);
+				}
+			};
+		});
+		hooks.afterEach(function() {
+			globalThis.FontFace = NativeFontFace;
+		});
+		(0, import_qunit.test)("font specimen loads the new face after its file is written", async function(assert) {
+			await openInInteractStack("face.ttf");
+			await waitUntil(() => requestedFaces.length > 0, {
+				timeout: 5e3,
+				timeoutMessage: "the specimen did not load the first face"
+			});
+			let firstFace = requestedFaces[requestedFaces.length - 1];
+			assert.true(firstFace.includes("face.ttf"), "the specimen loads the file as its face");
+			await realm.write("face.ttf", fontWithMarker("second"));
+			await waitUntil(() => requestedFaces.some((face) => face !== firstFace), {
+				timeout: 5e3,
+				timeoutMessage: "the specimen kept the first face"
+			});
+			assert.true(requestedFaces[requestedFaces.length - 1].includes("face.ttf?rev="), "the specimen loads the rewritten file as a new face");
+		});
+	});
+});
+//#endregion

package/bundled-test-harness/assets/file-resource-primitives-test-D3GmfqNs.js

@@ -0,0 +1,255 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./template-factory-ds9s0u8l.js";
+import { M as waitUntil, h as render } from "./dist-BOAdzfkP.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";
+//#region tests/integration/components/file-resource-primitives-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Integration | FileDef resource primitives", function(hooks) {
+	setupRenderingTest(hooks);
+	let loader;
+	let FileDef;
+	let FileResource;
+	let FileImage;
+	let FileAudio;
+	let FileVideo;
+	let FileObject;
+	let applyFileFont;
+	let fileResourceURL;
+	let fileElementURL;
+	hooks.beforeEach(async function() {
+		loader = getService("loader-service").loader;
+		FileDef = (await loader.import(`@cardstack/base/card-api`)).FileDef;
+		({FileResource, FileImage, FileAudio, FileVideo, FileObject, applyFileFont, fileResourceURL, fileElementURL} = await loader.import("@cardstack/base/file-formats/file-resources"));
+	});
+	function imageFile() {
+		return new FileDef({
+			id: "http://example.com/img/hero.png",
+			url: "http://example.com/img/hero.png",
+			sourceUrl: "http://example.com/img/hero.png",
+			name: "hero.png",
+			contentType: "image/png"
+		});
+	}
+	(0, import_qunit.test)("one URL precedence order applies to every primitive", function(assert) {
+		let file = {
+			url: "http://example.com/from-url",
+			id: "http://example.com/from-id",
+			sourceUrl: "http://example.com/from-source"
+		};
+		assert.strictEqual(fileResourceURL(file, "http://example.com/explicit"), "http://example.com/explicit", "an explicit URL wins");
+		assert.strictEqual(fileResourceURL(file), "http://example.com/from-url");
+		assert.strictEqual(fileResourceURL({
+			id: file.id,
+			sourceUrl: file.sourceUrl
+		}), "http://example.com/from-id");
+		assert.strictEqual(fileResourceURL({ sourceUrl: file.sourceUrl }), "http://example.com/from-source");
+		assert.strictEqual(fileResourceURL(void 0), "");
+		assert.strictEqual(fileResourceURL(null, new URL("http://example.com/a.png")), "http://example.com/a.png", "a URL object normalizes the same as a string");
+	});
+	(0, import_qunit.test)("an element URL resolved from the file carries its content revision", function(assert) {
+		let file = {
+			url: "http://example.com/img/hero.png",
+			contentHash: "abc123",
+			lastModified: 17e8
+		};
+		assert.strictEqual(fileElementURL(file), "http://example.com/img/hero.png?rev=abc123%3A1700000000", "the hash and modification time both name the revision");
+		assert.strictEqual(fileElementURL({
+			...file,
+			url: "http://example.com/img/hero.png?w=2#top"
+		}), "http://example.com/img/hero.png?w=2&rev=abc123%3A1700000000#top", "an existing query and fragment are kept");
+		assert.strictEqual(fileElementURL(file, "http://example.com/explicit.png"), "http://example.com/explicit.png", "an explicit URL passes through as given");
+		assert.strictEqual(fileElementURL({ url: "http://example.com/img/hero.png" }), "http://example.com/img/hero.png", "a file with no revision keeps its own URL");
+		assert.strictEqual(fileElementURL({
+			...file,
+			url: "blob:http://example.com/1234"
+		}), "blob:http://example.com/1234", "an object URL passes through");
+	});
+	(0, import_qunit.test)("a primitive loads the revisioned URL while FileResource yields the clean one", async function(assert) {
+		let file = {
+			url: "http://example.com/img/hero.png",
+			name: "hero.png",
+			contentType: "image/png",
+			contentHash: "abc123",
+			lastModified: 17e8
+		};
+		await render(templateFactory({
+			"id": "7uip4PgB",
+			"block": "[[[10,0],[14,0,\"probe\"],[12],[8,[32,0],null,[[\"@file\"],[[32,1]]],null],[8,[32,2],null,[[\"@file\"],[[32,1]]],[[\"default\"],[[[[1,\"\\n           \"],[10,1],[14,0,\"url\"],[12],[1,[30,1,[\"url\"]]],[13],[1,\"\\n           \"],[10,1],[14,0,\"element-url\"],[12],[1,[30,1,[\"elementUrl\"]]],[13],[1,\"\\n           \"],[10,1],[14,0,\"bg\"],[12],[1,[30,1,[\"backgroundImage\"]]],[13],[1,\"\\n         \"]],[1]]]]],[13]],[\"resource\"],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/file-resource-primitives-test.gts",
+			"scope": () => [
+				FileImage,
+				file,
+				FileResource
+			],
+			"isStrictMode": true
+		}));
+		assert.dom(".probe img").hasAttribute("src", "http://example.com/img/hero.png?rev=abc123%3A1700000000");
+		assert.dom(".url").hasText("http://example.com/img/hero.png");
+		assert.dom(".element-url").hasText("http://example.com/img/hero.png?rev=abc123%3A1700000000");
+		assert.dom(".bg").hasText("url(\"http://example.com/img/hero.png?rev=abc123%3A1700000000\")");
+	});
+	(0, import_qunit.test)("FileResource yields resolved facts and emits no DOM of its own", async function(assert) {
+		let file = imageFile();
+		await render(templateFactory({
+			"id": "iAIW+8pW",
+			"block": "[[[10,0],[14,0,\"probe\"],[12],[8,[32,0],null,[[\"@file\"],[[32,1]]],[[\"default\"],[[[[1,\"\\n           \"],[10,1],[14,0,\"url\"],[12],[1,[30,1,[\"url\"]]],[13],[1,\"\\n           \"],[10,1],[14,0,\"kind\"],[12],[1,[30,1,[\"profile\",\"kind\"]]],[13],[1,\"\\n           \"],[10,1],[14,0,\"family\"],[12],[1,[30,1,[\"profile\",\"family\"]]],[13],[1,\"\\n           \"],[10,1],[14,0,\"has\"],[12],[1,[52,[30,1,[\"hasURL\"]],\"yes\",\"no\"]],[13],[1,\"\\n         \"]],[1]]]]],[13]],[\"resource\"],[\"if\"]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/file-resource-primitives-test.gts",
+			"scope": () => [FileResource, file],
+			"isStrictMode": true
+		}));
+		assert.dom(".url").hasText("http://example.com/img/hero.png");
+		assert.dom(".kind").hasText("PNG image");
+		assert.dom(".family").hasText("image");
+		assert.dom(".has").hasText("yes");
+		assert.strictEqual(document.querySelectorAll(".probe > *").length, 4, "only the yielded block content renders — no wrapper element");
+	});
+	(0, import_qunit.test)("FileResource reports a file with no resource as having no URL", async function(assert) {
+		let file = new FileDef({});
+		await render(templateFactory({
+			"id": "KXAZPMJ/",
+			"block": "[[[8,[32,0],null,[[\"@file\"],[[32,1]]],[[\"default\"],[[[[1,\"\\n           \"],[10,1],[14,0,\"has\"],[12],[1,[52,[30,1,[\"hasURL\"]],\"yes\",\"no\"]],[13],[1,\"\\n         \"]],[1]]]]]],[\"resource\"],[\"if\"]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/file-resource-primitives-test.gts",
+			"scope": () => [FileResource, file],
+			"isStrictMode": true
+		}));
+		assert.dom(".has").hasText("no");
+	});
+	(0, import_qunit.test)("FileResource keeps a quoted URL from escaping the background declaration", async function(assert) {
+		let file = new FileDef({
+			url: "http://example.com/a\".png\";color:red;--x:\"",
+			name: "a.png"
+		});
+		await render(templateFactory({
+			"id": "weoKXY4r",
+			"block": "[[[8,[32,0],null,[[\"@file\"],[[32,1]]],[[\"default\"],[[[[1,\"\\n           \"],[10,1],[14,0,\"bg\"],[15,5,[30,1,[\"backgroundStyle\"]]],[12],[13],[1,\"\\n         \"]],[1]]]]]],[\"resource\"],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/file-resource-primitives-test.gts",
+			"scope": () => [FileResource, file],
+			"isStrictMode": true
+		}));
+		assert.notStrictEqual(getComputedStyle(document.querySelector(".bg")).color, "rgb(255, 0, 0)", "the injected declaration did not take effect");
+	});
+	(0, import_qunit.test)("FileImage emits exactly one img and passes attributes through", async function(assert) {
+		let file = imageFile();
+		await render(templateFactory({
+			"id": "sAkkAPBZ",
+			"block": "[[[10,0],[14,0,\"probe\"],[12],[8,[32,0],[[24,0,\"hero\"]],[[\"@file\",\"@loading\"],[[32,1],\"lazy\"]],null],[13]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/file-resource-primitives-test.gts",
+			"scope": () => [FileImage, file],
+			"isStrictMode": true
+		}));
+		assert.strictEqual(document.querySelectorAll(".probe img").length, 1);
+		assert.dom(".probe img").hasAttribute("src", "http://example.com/img/hero.png").hasAttribute("alt", "hero.png").hasAttribute("loading", "lazy").hasClass("hero");
+		assert.strictEqual(document.querySelector(".probe").children.length, 1, "no wrapper element around the img");
+	});
+	(0, import_qunit.test)("FileImage renders nothing rather than a broken image when there is no URL", async function(assert) {
+		let file = new FileDef({ name: "x.png" });
+		await render(templateFactory({
+			"id": "gim6MZPR",
+			"block": "[[[10,0],[14,0,\"probe\"],[12],[8,[32,0],null,[[\"@file\"],[[32,1]]],null],[13]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/file-resource-primitives-test.gts",
+			"scope": () => [FileImage, file],
+			"isStrictMode": true
+		}));
+		assert.dom(".probe img").doesNotExist();
+	});
+	(0, import_qunit.test)("FileAudio emits exactly one native player with controls by default", async function(assert) {
+		let file = new FileDef({
+			url: "http://example.com/a/take.mp3",
+			name: "take.mp3",
+			contentType: "audio/mpeg"
+		});
+		await render(templateFactory({
+			"id": "gim6MZPR",
+			"block": "[[[10,0],[14,0,\"probe\"],[12],[8,[32,0],null,[[\"@file\"],[[32,1]]],null],[13]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/file-resource-primitives-test.gts",
+			"scope": () => [FileAudio, file],
+			"isStrictMode": true
+		}));
+		assert.strictEqual(document.querySelectorAll(".probe audio").length, 1);
+		assert.dom(".probe audio").hasAttribute("src", "http://example.com/a/take.mp3").hasAttribute("controls");
+		assert.strictEqual(document.querySelector(".probe").children.length, 1);
+	});
+	(0, import_qunit.test)("FileVideo emits exactly one native player with the poster applied", async function(assert) {
+		let file = new FileDef({
+			url: "http://example.com/v/clip.mp4",
+			name: "clip.mp4",
+			contentType: "video/mp4"
+		});
+		await render(templateFactory({
+			"id": "J/0ZQg2o",
+			"block": "[[[10,0],[14,0,\"probe\"],[12],[8,[32,0],null,[[\"@file\",\"@poster\"],[[32,1],\"http://example.com/v/poster.jpg\"]],null],[13]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/file-resource-primitives-test.gts",
+			"scope": () => [FileVideo, file],
+			"isStrictMode": true
+		}));
+		assert.strictEqual(document.querySelectorAll(".probe video").length, 1);
+		assert.dom(".probe video").hasAttribute("src", "http://example.com/v/clip.mp4").hasAttribute("poster", "http://example.com/v/poster.jpg").hasAttribute("playsinline");
+	});
+	(0, import_qunit.test)("FileAudio falls back to the canonical source when the blob fetch fails", async function(assert) {
+		let file = new FileDef({
+			url: "http://127.0.0.1:1/a/take.mp3",
+			name: "take.mp3"
+		});
+		await render(templateFactory({
+			"id": "vx9g8Iys",
+			"block": "[[[8,[32,0],null,[[\"@file\",\"@loadAsBlob\"],[[32,1],true]],null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/file-resource-primitives-test.gts",
+			"scope": () => [FileAudio, file],
+			"isStrictMode": true
+		}));
+		await waitUntil(() => document.querySelector("audio")?.getAttribute("src") === "http://127.0.0.1:1/a/take.mp3");
+		assert.dom("audio").hasAttribute("src", "http://127.0.0.1:1/a/take.mp3", "the element is playable from the canonical URL");
+		assert.notOk(document.querySelector("audio").src.startsWith("blob:"), "no object URL was left behind");
+	});
+	(0, import_qunit.test)("FileAudio exposes the native element to a caller with its own controls", async function(assert) {
+		let file = new FileDef({ url: "http://example.com/a/take.mp3" });
+		let captured = null;
+		let onElement = (element) => {
+			if (element) captured = element;
+		};
+		await render(templateFactory({
+			"id": "z0WXzqpW",
+			"block": "[[[8,[32,0],null,[[\"@file\",\"@onElement\"],[[32,1],[32,2]]],null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/file-resource-primitives-test.gts",
+			"scope": () => [
+				FileAudio,
+				file,
+				onElement
+			],
+			"isStrictMode": true
+		}));
+		assert.strictEqual(captured, document.querySelector("audio"), "the caller receives the exact rendered element");
+	});
+	(0, import_qunit.test)("FileObject emits exactly one object carrying the resource type", async function(assert) {
+		let file = new FileDef({
+			url: "http://example.com/docs/report.pdf",
+			name: "report.pdf",
+			contentType: "application/pdf"
+		});
+		await render(templateFactory({
+			"id": "/WZTy/1A",
+			"block": "[[[10,0],[14,0,\"probe\"],[12],[8,[32,0],null,[[\"@file\"],[[32,1]]],[[\"default\"],[[[[1,\"\\n           \"],[10,1],[14,0,\"fallback\"],[12],[1,\"No viewer\"],[13],[1,\"\\n         \"]],[]]]]],[13]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/file-resource-primitives-test.gts",
+			"scope": () => [FileObject, file],
+			"isStrictMode": true
+		}));
+		assert.strictEqual(document.querySelectorAll(".probe object").length, 1);
+		assert.dom(".probe object").hasAttribute("data", "http://example.com/docs/report.pdf").hasAttribute("type", "application/pdf").hasAttribute("aria-label", "report.pdf");
+		assert.dom(".probe object .fallback").exists("the block is the fallback");
+	});
+	(0, import_qunit.test)("applyFileFont leaves the theme font in place when there is no resource", async function(assert) {
+		let file = new FileDef({});
+		await render(templateFactory({
+			"id": "kruKGJW/",
+			"block": "[[[11,1],[24,0,\"specimen\"],[4,[32,0],[[32,1],[27],[27]],null],[12],[1,\"Aa\"],[13]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/file-resource-primitives-test.gts",
+			"scope": () => [applyFileFont, file],
+			"isStrictMode": true
+		}));
+		assert.strictEqual(document.querySelector(".specimen").style.fontFamily, "", "no font-family was set");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/file-tree-from-index-test-CfldnUgm.js

@@ -0,0 +1,96 @@
+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 fileTreeFromIndex } from "./file-tree-from-index-DiM4Y6VY.js";
+import { T as settled } from "./dist-BOAdzfkP.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-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/integration/resources/file-tree-from-index-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var SKILL_MD = `---
+name: Realm Sync
+boxel:
+  kind: skill
+---
+# Realm Sync
+`;
+var RECIPE_MD = `---
+name: Pasta
+boxel:
+  kind: recipe
+---
+# Pasta
+`;
+var PLAIN_MD = `# Just a note
+`;
+var markdownRef = {
+	module: baseRRI("markdown-file-def"),
+	name: "MarkdownDef"
+};
+function filePaths(entries) {
+	let paths = [];
+	for (let entry of entries) {
+		if (entry.kind === "file") paths.push(entry.path);
+		if (entry.children) paths.push(...filePaths([...entry.children.values()]));
+	}
+	return paths.sort();
+}
+function getTreeForTest(owner, fileTypeFilter, fileFieldFilter) {
+	return fileTreeFromIndex(owner, () => testRealmURL, fileTypeFilter, fileFieldFilter);
+}
+(0, import_qunit.module)("Integration | file-tree-from-index resource", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks);
+	setupRealmCacheTeardown(hooks);
+	hooks.beforeEach(async function() {
+		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"skills/realm-sync/SKILL.md": SKILL_MD,
+				"recipes/pasta/SKILL.md": RECIPE_MD,
+				"notes/plain.md": PLAIN_MD
+			}
+		}));
+	});
+	(0, import_qunit.test)("a fileFieldFilter of kind:skill limits the tree to skill markdown files", async function(assert) {
+		let tree = getTreeForTest(getService("loader-service"), () => markdownRef, () => ({ kind: "skill" }));
+		await tree.loaded;
+		assert.deepEqual(filePaths(tree.entries), ["skills/realm-sync/SKILL.md"], "only the skill markdown file is in the tree");
+	});
+	(0, import_qunit.test)("without a fileFieldFilter the tree includes every markdown file", async function(assert) {
+		let tree = getTreeForTest(getService("loader-service"), () => markdownRef, () => void 0);
+		await tree.loaded;
+		assert.deepEqual(filePaths(tree.entries), [
+			"notes/plain.md",
+			"recipes/pasta/SKILL.md",
+			"skills/realm-sync/SKILL.md"
+		], "all markdown files are in the tree when unscoped");
+	});
+	(0, import_qunit.test)("a burst of realm events coalesces into a single tree re-run", async function(assert) {
+		let store = getService("store");
+		let searchCount = 0;
+		let originalSearchEntries = store.searchEntries.bind(store);
+		store.searchEntries = async () => {
+			searchCount++;
+			return { data: [{ id: `${testRealmURL}notes/plain.md` }] };
+		};
+		try {
+			await getTreeForTest(getService("loader-service"), () => markdownRef, () => void 0).loaded;
+			let baseline = searchCount;
+			let messageService = getService("message-service");
+			for (let i = 1; i <= 5; i++) messageService.relayRealmEvent({
+				eventName: "index",
+				indexType: "incremental",
+				invalidations: [`${testRealmURL}notes/plain.md`],
+				realmURL: testRealmURL
+			});
+			await settled();
+			assert.strictEqual(searchCount, baseline + 1, "five index events inside one window produce one tree re-run");
+		} finally {
+			store.searchEntries = originalSearchEntries;
+		}
+	});
+});
+//#endregion