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

package/bundled-test-harness/assets/film-C54lhaiU.js

@@ -0,0 +1,2 @@
+import { r as TICK, t as Film } from "./film-Bf73ypzi.js";
+export { Film, TICK };

package/bundled-test-harness/assets/film-DPcMEHYu.js

@@ -0,0 +1,13 @@
+import { t as Clip } from "./clip-DY6N6K67.js";
+import { C as clipWindow, S as clipLanes, T as resolveClips, _ as lerp, a as chapterHeads, b as rgba, c as joinInto, d as tailFor, f as totalSecs, g as hex, h as clamp01, i as beatStart, l as schedule, m as RAD, n as Seam, o as contents, p as waypoints, r as TICK, s as cues, t as Film, u as secsBefore, v as luminance, w as resolveClip, x as smooth, y as mmss } from "./film-Bf73ypzi.js";
+import { C as collectGraph, S as Voice, _ as Stamp, a as Freeze, b as Type, d as Mark, f as PatchComponent, g as Spine, h as Sky, i as Eye, l as JoinInto, m as Shot, n as Chapter, o as GraphNodeComponent, p as Sequence, s as Insert, t as Attach, u as Lineup, v as To, x as Video, y as Trace } from "./nodes-BH4FGkKK.js";
+import { a as IFRAME_PICTURE, c as Mix, d as Sun, f as Weather, i as Filter, l as SOUND, n as Build, o as Light, p as Winter, s as Look, t as Adjustment, u as Set } from "./adjust--n_OTVbP.js";
+import { n as VOCABULARY, r as compileGraph, t as FilmGraph } from "./host-KVk6VIHI.js";
+import { a as Iris, c as Luma, d as STILL_JOINS, f as Wipe, h as seamShape, i as Flash, l as Melt, m as retire, n as Blur, o as JOIN_SECS, p as inGlass, r as Dip, s as Joins, t as Blend, u as PRESENTATIONS } from "./joins-D_xzMJAJ.js";
+import { i as Track, n as Insert$1, r as Stamp$1, t as Captions } from "./overlays-DSf2je0c.js";
+import { t as Plate } from "./plate-CJq1veVA.js";
+import { n as Menu, r as Player, t as Burst } from "./player-vsjosoN_.js";
+import { t as Rail } from "./rail-CQ53Dakr.js";
+import { n as Gate, t as EndCard } from "./titles-DCvAhECF.js";
+import { t as IframePicture } from "./picture-DbNWRbtX.js";
+export { Adjustment, Blend, Blur, Build, Burst, Captions, Clip, Dip, EndCard, Eye, Film, FilmGraph, Filter, Flash, Freeze, Gate, Attach as GraphAttach, Chapter as GraphChapter, Insert as GraphInsert, GraphNodeComponent, Stamp as GraphStamp, IFRAME_PICTURE, IframePicture, Insert$1 as Insert, Iris, JOIN_SECS, JoinInto, Joins, Light, Lineup, Look, Luma, Mark, Melt, Menu, Mix, PRESENTATIONS, PatchComponent, Plate, Player, RAD, Rail, SOUND, STILL_JOINS, Seam, Sequence, Set, Shot, Sky, Spine, Stamp$1 as Stamp, Sun, TICK, To, Trace, Track, Type, VOCABULARY, Video, Voice, Weather, Winter, Wipe, beatStart, chapterHeads, clamp01, clipLanes, clipWindow, collectGraph, compileGraph, contents, cues, hex, inGlass, joinInto, lerp, luminance, mmss, resolveClip, resolveClips, retire, rgba, schedule, seamShape, secsBefore, smooth, tailFor, totalSecs, waypoints };

package/bundled-test-harness/assets/flac-audio-def-test-ByoXMoQ1.js

@@ -0,0 +1,143 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL, Co as SupportedMimeType } from "./runtime-common-BTaLJEw-.js";
+import { it as baseRealmRRI } from "./constants-Icc0nFW-.js";
+import { M as waitUntil, k as visit } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, I as setupOnSave, L as setupRealmCacheTeardown, Z as withCachedRealmSetup, a as SYSTEM_CARD_FIXTURE_CONTENTS, ct as setupApplicationTest, j as setupAcceptanceTestRealm, l as capturePrerenderResult, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { t as setupTestRealmServiceWorker } from "./test-realm-service-worker-OVn3b7N-.js";
+//#region tests/acceptance/audio-def/flac-audio-def-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+function makeMinimalFlac() {
+	let payload = new Uint8Array(34);
+	let view = new DataView(payload.buffer);
+	view.setUint16(0, 4096);
+	view.setUint16(2, 4096);
+	payload[10] = 10;
+	payload[11] = 196;
+	payload[12] = 64;
+	payload[13] = 240;
+	view.setUint32(14, 44100);
+	let blockHeader = new Uint8Array(4);
+	blockHeader[0] = 128;
+	blockHeader[1] = 0;
+	blockHeader[2] = 0;
+	blockHeader[3] = 34;
+	let marker = new Uint8Array([
+		102,
+		76,
+		97,
+		67
+	]);
+	let out = new Uint8Array(marker.length + blockHeader.length + payload.length);
+	out.set(marker, 0);
+	out.set(blockHeader, marker.length);
+	out.set(payload, marker.length + blockHeader.length);
+	return out;
+}
+(0, import_qunit.module)("Acceptance | flac audio def", function(hooks) {
+	setupApplicationTest(hooks);
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	setupRealmCacheTeardown(hooks);
+	setupTestRealmServiceWorker(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, { loggedInAs: "@testuser:localhost" });
+	let realm;
+	const fileExtractPath = (url, renderOptions, nonce = 0) => `/render/${encodeURIComponent(url)}/${nonce}/${encodeURIComponent(JSON.stringify(renderOptions))}/file-extract`;
+	const fileRenderPath = (url, renderOptions, format = "isolated", ancestorLevel = 0, nonce = 0) => `/render/${encodeURIComponent(url)}/${nonce}/${encodeURIComponent(JSON.stringify(renderOptions))}/html/${format}/${ancestorLevel}`;
+	const makeFileURL = (path) => new URL(path, testRealmURL).href;
+	const flacDefCodeRef = () => ({
+		module: `${baseRealmRRI}flac-audio-def`,
+		name: "FlacDef"
+	});
+	async function captureFileExtractResult(expectedStatus) {
+		await waitUntil(() => {
+			let container = document.querySelector("[data-prerender-file-extract]");
+			if (!container) return false;
+			let status = container.getAttribute("data-prerender-file-extract-status");
+			if (!status) return false;
+			if (expectedStatus && status !== expectedStatus) return false;
+			return status === "ready" || status === "error";
+		}, { timeout: 5e3 });
+		let container = document.querySelector("[data-prerender-file-extract]");
+		if (!container) throw new Error("captureFileExtractResult: missing [data-prerender-file-extract] container after wait");
+		let text = container.querySelector("pre")?.textContent?.trim() ?? "";
+		return JSON.parse(text);
+	}
+	hooks.beforeEach(async function() {
+		let flacBytes = makeMinimalFlac();
+		({realm} = await withCachedRealmSetup(async () => setupAcceptanceTestRealm({
+			mockMatrixUtils,
+			contents: {
+				...SYSTEM_CARD_FIXTURE_CONTENTS,
+				"sample.flac": flacBytes,
+				"not-a-flac.flac": "This is plain text, not a FLAC file."
+			}
+		})));
+	});
+	hooks.afterEach(function() {
+		delete globalThis.__renderModel;
+		delete globalThis.__boxelFileRenderData;
+	});
+	(0, import_qunit.test)("extracts duration from FLAC", async function(assert) {
+		await visit(fileExtractPath(makeFileURL("sample.flac"), {
+			fileExtract: true,
+			fileDefCodeRef: flacDefCodeRef()
+		}));
+		let result = await captureFileExtractResult("ready");
+		assert.strictEqual(result.status, "ready");
+		assert.strictEqual(result.searchDoc?.duration, 1, "extracts FLAC duration");
+		assert.strictEqual(result.searchDoc?.name, "sample.flac");
+		assert.ok(String(result.searchDoc?.contentType).includes("flac"), "sets flac content type");
+	});
+	(0, import_qunit.test)("falls back when FlacDef is used for non-FLAC content", async function(assert) {
+		await visit(fileExtractPath(makeFileURL("not-a-flac.flac"), {
+			fileExtract: true,
+			fileDefCodeRef: flacDefCodeRef()
+		}));
+		let result = await captureFileExtractResult("ready");
+		assert.strictEqual(result.status, "ready");
+		assert.true(result.mismatch, "marks mismatch when content is not valid FLAC");
+		assert.strictEqual(result.searchDoc?.name, "not-a-flac.flac");
+	});
+	(0, import_qunit.test)("isolated preview renders the player and formatted duration", async function(assert) {
+		let url = makeFileURL("sample.flac");
+		await visit(fileExtractPath(url, {
+			fileExtract: true,
+			fileDefCodeRef: flacDefCodeRef()
+		}));
+		let result = await captureFileExtractResult("ready");
+		assert.ok(result.resource, "extraction produced a resource");
+		globalThis.__boxelFileRenderData = {
+			resource: result.resource,
+			fileDefCodeRef: flacDefCodeRef()
+		};
+		await visit(fileRenderPath(url, {
+			fileRender: true,
+			fileDefCodeRef: flacDefCodeRef()
+		}));
+		let { status } = await capturePrerenderResult("innerHTML");
+		assert.strictEqual(status, "ready", "render completed");
+		let preview = document.querySelector("[data-prerender] [data-test-audio-preview]");
+		assert.ok(preview, "audio preview renders in the shared shell");
+		let player = document.querySelector("[data-prerender] [data-test-audio-player]");
+		assert.ok(player, "native audio player is mounted");
+		let duration = document.querySelector("[data-prerender] [data-test-audio-duration]");
+		assert.ok(duration, "duration element is rendered");
+		assert.strictEqual(duration?.textContent?.trim(), "0:01", "duration is formatted as m:ss");
+	});
+	(0, import_qunit.test)("indexing stores FLAC metadata and file meta uses it", async function(assert) {
+		let fileURL = new URL("sample.flac", testRealmURL);
+		let fileEntry = await realm.realmIndexQueryEngine.file(fileURL);
+		assert.ok(fileEntry, "file entry exists");
+		assert.strictEqual(fileEntry?.searchDoc?.duration, 1, "index stores FLAC duration");
+		let response = await getService("network").virtualNetwork.fetch(fileURL, { headers: { Accept: SupportedMimeType.FileMeta } });
+		assert.true(response.ok, "file meta request succeeds");
+		let body = await response.json();
+		assert.strictEqual(body?.data?.type, "file-meta");
+		assert.ok(String(body?.data?.attributes?.contentType).includes("flac"), "file meta uses flac content type");
+		assert.strictEqual(body?.data?.attributes?.duration, 1, "file meta includes FLAC duration");
+		assert.deepEqual(body?.data?.meta?.adoptsFrom, flacDefCodeRef(), "file meta uses FLAC def");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/font-metadata-extractor-test-hawLTDTG.js

@@ -0,0 +1,415 @@
+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";
+//#region tests/unit/font-metadata-extractor-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+function utf16be(text) {
+	let bytes = new Uint8Array(text.length * 2);
+	let view = new DataView(bytes.buffer);
+	for (let i = 0; i < text.length; i++) view.setUint16(i * 2, text.charCodeAt(i));
+	return bytes;
+}
+function nameTable(records) {
+	let strings = records.map((r) => utf16be(r.value));
+	let recordArea = 6 + records.length * 12;
+	let storage = strings.reduce((sum, s) => sum + s.length, 0);
+	let table = new Uint8Array(recordArea + storage);
+	let view = new DataView(table.buffer);
+	view.setUint16(0, 0);
+	view.setUint16(2, records.length);
+	view.setUint16(4, recordArea);
+	let stringCursor = 0;
+	records.forEach((r, i) => {
+		let rec = 6 + i * 12;
+		view.setUint16(rec, 3);
+		view.setUint16(rec + 2, 1);
+		view.setUint16(rec + 4, 1033);
+		view.setUint16(rec + 6, r.nameID);
+		view.setUint16(rec + 8, strings[i].length);
+		view.setUint16(rec + 10, stringCursor);
+		table.set(strings[i], recordArea + stringCursor);
+		stringCursor += strings[i].length;
+	});
+	return table;
+}
+function os2Table(spec) {
+	let table = new Uint8Array(78);
+	let view = new DataView(table.buffer);
+	view.setUint16(0, 0);
+	view.setUint16(4, spec.weightClass);
+	view.setUint16(6, spec.widthClass);
+	for (let i = 0; i < 4; i++) view.setUint8(58 + i, spec.vendorId.charCodeAt(i));
+	view.setUint16(62, spec.fsSelection);
+	return table;
+}
+function headTable(unitsPerEm, macStyle) {
+	let table = new Uint8Array(54);
+	let view = new DataView(table.buffer);
+	view.setUint16(18, unitsPerEm);
+	view.setUint16(44, macStyle);
+	return table;
+}
+function maxpTable(numGlyphs) {
+	let table = new Uint8Array(6);
+	let view = new DataView(table.buffer);
+	view.setUint32(0, 65536);
+	view.setUint16(4, numGlyphs);
+	return table;
+}
+function fvarTable(axes) {
+	let axesOffset = 16;
+	let table = new Uint8Array(axesOffset + axes.length * 20);
+	let view = new DataView(table.buffer);
+	view.setUint16(0, 1);
+	view.setUint16(4, axesOffset);
+	view.setUint16(8, axes.length);
+	view.setUint16(10, 20);
+	axes.forEach((axis, i) => {
+		let rec = axesOffset + i * 20;
+		for (let j = 0; j < 4; j++) view.setUint8(rec + j, axis.tag.charCodeAt(j));
+		view.setInt32(rec + 4, axis.min * 65536);
+		view.setInt32(rec + 8, axis.def * 65536);
+		view.setInt32(rec + 12, axis.max * 65536);
+		view.setUint16(rec + 16, 0);
+		view.setUint16(rec + 18, 256 + i);
+	});
+	return table;
+}
+function sfnt(flavor, tables) {
+	let cursor = 12 + tables.length * 16;
+	let placed = tables.map((t) => {
+		let offset = cursor;
+		cursor += Math.ceil(t.data.length / 4) * 4;
+		return {
+			...t,
+			offset
+		};
+	});
+	let out = new Uint8Array(cursor);
+	let view = new DataView(out.buffer);
+	view.setUint32(0, flavor);
+	view.setUint16(4, tables.length);
+	placed.forEach((t, i) => {
+		let rec = 12 + i * 16;
+		for (let j = 0; j < 4; j++) view.setUint8(rec + j, t.tag.charCodeAt(j));
+		view.setUint32(rec + 8, t.offset);
+		view.setUint32(rec + 12, t.data.length);
+		out.set(t.data, t.offset);
+	});
+	return out;
+}
+async function deflate(bytes) {
+	let stream = new Blob([bytes]).stream().pipeThrough(new CompressionStream("deflate"));
+	return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+async function woff(flavor, tables, compressedTags = /* @__PURE__ */ new Set()) {
+	let headerSize = 44 + tables.length * 20;
+	let blobs = await Promise.all(tables.map(async (t) => {
+		if (compressedTags.has(t.tag)) {
+			let comp = await deflate(t.data);
+			return {
+				tag: t.tag,
+				comp,
+				origLength: t.data.length
+			};
+		}
+		return {
+			tag: t.tag,
+			comp: t.data,
+			origLength: t.data.length
+		};
+	}));
+	let cursor = headerSize;
+	let placed = blobs.map((b) => {
+		let offset = cursor;
+		cursor += Math.ceil(b.comp.length / 4) * 4;
+		return {
+			...b,
+			offset
+		};
+	});
+	let out = new Uint8Array(cursor);
+	let view = new DataView(out.buffer);
+	view.setUint32(0, 2001684038);
+	view.setUint32(4, flavor);
+	view.setUint32(8, out.length);
+	view.setUint16(12, tables.length);
+	placed.forEach((b, i) => {
+		let rec = 44 + i * 20;
+		for (let j = 0; j < 4; j++) view.setUint8(rec + j, b.tag.charCodeAt(j));
+		view.setUint32(rec + 4, b.offset);
+		view.setUint32(rec + 8, b.comp.length);
+		view.setUint32(rec + 12, b.origLength);
+		out.set(b.comp, b.offset);
+	});
+	return out;
+}
+function woff2Header(flavor) {
+	let out = new Uint8Array(48);
+	let view = new DataView(out.buffer);
+	view.setUint32(0, 2001684018);
+	view.setUint32(4, flavor);
+	view.setUint16(12, 4);
+	return out;
+}
+var SFNT_TRUETYPE = 65536;
+var SFNT_OTTO = 1330926671;
+var FS_BOLD = 32;
+function completeTruetype() {
+	return sfnt(SFNT_TRUETYPE, [
+		{
+			tag: "OS/2",
+			data: os2Table({
+				weightClass: 700,
+				widthClass: 3,
+				vendorId: "ACME",
+				fsSelection: FS_BOLD
+			})
+		},
+		{
+			tag: "head",
+			data: headTable(2048, 0)
+		},
+		{
+			tag: "maxp",
+			data: maxpTable(1234)
+		},
+		{
+			tag: "name",
+			data: nameTable([
+				{
+					nameID: 1,
+					value: "Legacy Family"
+				},
+				{
+					nameID: 2,
+					value: "Legacy Style"
+				},
+				{
+					nameID: 4,
+					value: "Acme Sans Bold"
+				},
+				{
+					nameID: 6,
+					value: "AcmeSans-Bold"
+				},
+				{
+					nameID: 8,
+					value: "Acme Type Foundry"
+				},
+				{
+					nameID: 16,
+					value: "Acme Sans"
+				},
+				{
+					nameID: 17,
+					value: "Bold"
+				}
+			])
+		},
+		{
+			tag: "glyf",
+			data: new Uint8Array(4)
+		}
+	]);
+}
+(0, import_qunit.module)("Unit | font metadata extractor", function(hooks) {
+	setupRenderingTest(hooks);
+	let loader;
+	let extractFontMetadata;
+	hooks.beforeEach(async function() {
+		loader = getService("loader-service").loader;
+		({extractFontMetadata} = await loader.import("@cardstack/base/font-meta-extractor"));
+	});
+	(0, import_qunit.test)("reads name, OS/2, head, and maxp facts from a TrueType face", async function(assert) {
+		let metadata = await extractFontMetadata(completeTruetype());
+		assert.strictEqual(metadata.familyName, "Acme Sans");
+		assert.strictEqual(metadata.subfamilyName, "Bold");
+		assert.strictEqual(metadata.fullName, "Acme Sans Bold");
+		assert.strictEqual(metadata.postscriptName, "AcmeSans-Bold");
+		assert.strictEqual(metadata.foundry, "Acme Type Foundry");
+		assert.strictEqual(metadata.vendorId, "ACME");
+		assert.strictEqual(metadata.weightClass, 700);
+		assert.strictEqual(metadata.widthName, "Condensed");
+		assert.strictEqual(metadata.glyphCount, 1234);
+		assert.strictEqual(metadata.unitsPerEm, 2048);
+		assert.strictEqual(metadata.outlineType, "TrueType");
+		assert.true(metadata.isBold);
+		assert.false(metadata.isItalic);
+	});
+	(0, import_qunit.test)("names CFF outlines as PostScript", async function(assert) {
+		let metadata = await extractFontMetadata(sfnt(SFNT_OTTO, [
+			{
+				tag: "CFF ",
+				data: new Uint8Array(4)
+			},
+			{
+				tag: "maxp",
+				data: maxpTable(50)
+			},
+			{
+				tag: "name",
+				data: nameTable([{
+					nameID: 1,
+					value: "Acme Serif"
+				}])
+			}
+		]));
+		assert.strictEqual(metadata.outlineType, "PostScript/CFF");
+		assert.strictEqual(metadata.familyName, "Acme Serif");
+	});
+	(0, import_qunit.test)("reports variation axes for a variable font", async function(assert) {
+		let metadata = await extractFontMetadata(sfnt(SFNT_TRUETYPE, [
+			{
+				tag: "maxp",
+				data: maxpTable(80)
+			},
+			{
+				tag: "glyf",
+				data: new Uint8Array(4)
+			},
+			{
+				tag: "fvar",
+				data: fvarTable([{
+					tag: "wght",
+					min: 100,
+					def: 400,
+					max: 900
+				}, {
+					tag: "wdth",
+					min: 75,
+					def: 100,
+					max: 125
+				}])
+			}
+		]));
+		assert.true(metadata.isVariable);
+		assert.deepEqual(metadata.axes, ["Weight (wght) 100–900", "Width (wdth) 75–125"]);
+	});
+	(0, import_qunit.test)("falls back to the legacy family/style names when no typographic pair exists", async function(assert) {
+		let metadata = await extractFontMetadata(sfnt(SFNT_TRUETYPE, [{
+			tag: "glyf",
+			data: new Uint8Array(4)
+		}, {
+			tag: "name",
+			data: nameTable([{
+				nameID: 1,
+				value: "Plain Family"
+			}, {
+				nameID: 2,
+				value: "Regular"
+			}])
+		}]));
+		assert.strictEqual(metadata.familyName, "Plain Family");
+		assert.strictEqual(metadata.subfamilyName, "Regular");
+	});
+	(0, import_qunit.test)("derives style from head macStyle when OS/2 is absent", async function(assert) {
+		let metadata = await extractFontMetadata(sfnt(SFNT_TRUETYPE, [{
+			tag: "glyf",
+			data: new Uint8Array(4)
+		}, {
+			tag: "head",
+			data: headTable(1e3, 2)
+		}]));
+		assert.true(metadata.isItalic);
+		assert.false(metadata.isBold);
+		assert.strictEqual(metadata.weightClass, void 0, "no OS/2, no weight");
+	});
+	(0, import_qunit.test)("reads the same facts through an uncompressed WOFF wrapper", async function(assert) {
+		let bytes = await woff(SFNT_TRUETYPE, [
+			{
+				tag: "maxp",
+				data: maxpTable(321)
+			},
+			{
+				tag: "glyf",
+				data: new Uint8Array(4)
+			},
+			{
+				tag: "name",
+				data: nameTable([{
+					nameID: 1,
+					value: "Woff Family"
+				}])
+			}
+		]);
+		let metadata = await extractFontMetadata(bytes);
+		assert.strictEqual(metadata.familyName, "Woff Family");
+		assert.strictEqual(metadata.glyphCount, 321);
+		assert.strictEqual(metadata.outlineType, "TrueType");
+	});
+	(0, import_qunit.test)("inflates a zlib-compressed WOFF table", async function(assert) {
+		let bytes = await woff(SFNT_TRUETYPE, [{
+			tag: "glyf",
+			data: new Uint8Array(4)
+		}, {
+			tag: "name",
+			data: nameTable([{
+				nameID: 1,
+				value: "Compressed Family"
+			}, {
+				nameID: 256,
+				value: "padding ".repeat(64)
+			}])
+		}], new Set(["name"]));
+		let metadata = await extractFontMetadata(bytes);
+		assert.strictEqual(metadata.familyName, "Compressed Family");
+	});
+	(0, import_qunit.test)("reads only the outline flavor from a WOFF2, whose tables are Brotli-compressed", async function(assert) {
+		let metadata = await extractFontMetadata(woff2Header(SFNT_TRUETYPE));
+		assert.strictEqual(metadata.outlineType, "TrueType");
+		assert.strictEqual(metadata.familyName, void 0, "no legible name table");
+		assert.strictEqual(metadata.glyphCount, void 0, "no legible maxp table");
+	});
+	(0, import_qunit.test)("throws a content mismatch on non-font bytes so the extract falls back", async function(assert) {
+		let notAFont = new Uint8Array([
+			37,
+			80,
+			68,
+			70,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0
+		]);
+		await assert.rejects(extractFontMetadata(notAFont), /recognized font signature/);
+	});
+	(0, import_qunit.test)("degrades to a partial result when a declared table is out of bounds", async function(assert) {
+		let bytes = completeTruetype();
+		new DataView(bytes.buffer).setUint32(20, bytes.length + 1e3);
+		let metadata = await extractFontMetadata(bytes);
+		assert.strictEqual(metadata.outlineType, "TrueType");
+	});
+	(0, import_qunit.test)("rejects a truncated WOFF header instead of throwing a RangeError", async function(assert) {
+		let truncated = new Uint8Array(20);
+		new DataView(truncated.buffer).setUint32(0, 2001684038);
+		await assert.rejects(extractFontMetadata(truncated), /WOFF header is truncated/);
+	});
+	function ttcFixture(faceVersion) {
+		let ttc = new Uint8Array(28);
+		let view = new DataView(ttc.buffer);
+		view.setUint32(0, 1953784678);
+		view.setUint16(4, 1);
+		view.setUint16(6, 0);
+		view.setUint32(8, 1);
+		view.setUint32(12, 16);
+		view.setUint32(16, faceVersion);
+		return ttc;
+	}
+	(0, import_qunit.test)("reports a TrueType Collection as a font without walking into a face", async function(assert) {
+		let metadata = await extractFontMetadata(ttcFixture(SFNT_TRUETYPE));
+		assert.strictEqual(metadata.outlineType, "TrueType", "flavor read from the first face");
+		assert.strictEqual(metadata.familyName, void 0, "no table is walked, so no name is invented");
+		assert.strictEqual(metadata.glyphCount, void 0, "no maxp is read");
+	});
+	(0, import_qunit.test)("names an OpenType Collection by its first face rather than defaulting to TrueType", async function(assert) {
+		let metadata = await extractFontMetadata(ttcFixture(SFNT_OTTO));
+		assert.strictEqual(metadata.outlineType, "PostScript/CFF");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/formatted-aibot-message-test-BahBj3x8.js

@@ -0,0 +1,109 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import { n as tracked } from "./tracking-800VJb8b.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as templateOnly } from "./template-only-6nVzLWF-.js";
+import { t as parseHtmlContent } from "./utils-C8wyqVaW.js";
+import { M as waitUntil, T as settled, h as render } from "./dist-BOAdzfkP.js";
+import { t as FormattedAiBotMessage } from "./aibot-message-BShcljQ9.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 { n as renderComponent } from "./render-component-B15Z0e2v.js";
+//#region tests/integration/components/3732e3a350.css
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+//#endregion
+//#region tests/integration/components/formatted-aibot-message-test.gts
+(0, import_qunit.module)("Integration | Component | FormattedAiBotMessage", function(hooks) {
+	setupRenderingTest(hooks);
+	let monacoService;
+	let roomId = "!abcd";
+	let eventId = "1234";
+	hooks.beforeEach(async function() {
+		monacoService = getService("monaco-service");
+	});
+	async function renderFormattedAiBotMessage(testScenario) {
+		let monacoSDK = await monacoService.getMonacoContext();
+		await render(setComponentTemplate(templateFactory({
+			"id": "QETn2IuS",
+			"block": "[[[8,[32,0],[[24,0,\"test-component\"],[24,\"data-scopedcss-f40ad70d2a-e85261734e\",\"\"]],[[\"@monacoSDK\",\"@roomId\",\"@eventId\",\"@htmlParts\",\"@isStreaming\"],[[32,1],[32,2,[\"roomId\"]],[32,2,[\"eventId\"]],[32,2,[\"htmlParts\"]],[32,2,[\"isStreaming\"]]]],null],[1,\"\\n\"]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/formatted-aibot-message-test.gts",
+			"scope": () => [
+				FormattedAiBotMessage,
+				monacoSDK,
+				testScenario
+			],
+			"isStrictMode": true
+		}), templateOnly()));
+	}
+	(0, import_qunit.test)("it renders content with monaco editor in place of pre tags", async function(assert) {
+		await renderFormattedAiBotMessage({
+			htmlParts: parseHtmlContent(`
+<p>Hey there, for Valentine's day I made you a code block!</p>
+<pre data-code-language="c">
+print("🖤")
+</pre>
+<p>I hope you like it! But here is another one!</p>
+<pre data-code-language="ruby">
+puts "💎"
+</pre>
+<p>I hope you like this one too!</p>
+`, roomId, eventId),
+			isStreaming: false
+		});
+		let directChildren = this.element.querySelector(".message").children;
+		assert.strictEqual(directChildren[0]?.tagName, "P");
+		assert.strictEqual(directChildren[1]?.tagName, "SECTION");
+		assert.true(directChildren[1]?.classList.contains("code-block"));
+		assert.strictEqual(directChildren[2]?.tagName, "P");
+		assert.strictEqual(directChildren[3]?.tagName, "SECTION");
+		assert.true(directChildren[3]?.classList.contains("code-block"));
+		assert.strictEqual(directChildren[4]?.tagName, "P");
+		assert.dom(".monaco-editor").exists({ count: 2 });
+		assert.dom("pre").doesNotExist();
+	});
+	(0, import_qunit.test)("unincremental updates are handled gracefully", async function(assert) {
+		let monacoSDK = await monacoService.getMonacoContext();
+		let component = null;
+		class TestComponent extends Component {
+			static {
+				decorateFieldV2(this.prototype, "htmlParts", [tracked], function() {
+					return parseHtmlContent("<p>Howdy!</p> <p>How are you today?</p>", roomId, eventId);
+				});
+			}
+			#htmlParts = (initializeDeferredDecorator(this, "htmlParts"), void 0);
+			constructor(owner, args) {
+				super(owner, args);
+				component = this;
+			}
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "wSjSEWQO",
+					"block": "[[[8,[32,0],null,[[\"@monacoSDK\",\"@htmlParts\",\"@roomId\",\"@eventId\",\"@isStreaming\"],[[32,1],[30,0,[\"htmlParts\"]],\"!abcd\",\"1234\",true]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/formatted-aibot-message-test.gts",
+					"scope": () => [FormattedAiBotMessage, monacoSDK],
+					"isStrictMode": true
+				}), this);
+			}
+		}
+		await renderComponent(TestComponent);
+		assert.dom(".message").containsText("Howdy! How are you today?");
+		component.htmlParts = parseHtmlContent("<p>There was an error processing your request, please try again later.</p>", roomId, eventId);
+		await settled();
+		assert.dom(".message").containsText("There was an error processing your request, please try again later.");
+	});
+	(0, import_qunit.test)("it will text code clocks as they are sent, without hiding the first line url as it streams", async function(assert) {
+		await renderFormattedAiBotMessage({
+			htmlParts: parseHtmlContent(`<pre data-code-language="text">https://example.com/some-url</pre>`, roomId, eventId),
+			isStreaming: false
+		});
+		assert.dom(".code-block").exists();
+		await waitUntil(() => document.querySelectorAll(".view-line").length == 1);
+		assert.strictEqual(document.getElementsByClassName("view-lines")[0].innerText, "https://example.com/some-url");
+	});
+});
+//#endregion