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

package/bundled-test-harness/assets/patch-instance-test-DssuRGKP.js

@@ -0,0 +1,348 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
+import { B as localId, M as fields } from "./constants-Icc0nFW-.js";
+import { M as waitUntil } from "./dist-BOAdzfkP.js";
+import { t as PatchCardInstanceTool } from "./patch-card-instance-_uyQMYb9.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, I as setupOnSave, L as setupRealmCacheTeardown, P as setupIntegrationTestRealm, Z as withCachedRealmSetup, d as cardInfo, et as withSlowSave, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { A as field, H as linksTo, T as containsMany, U as linksToMany, a as CardDef, w as contains } from "./card-api-Cc8uZunB.js";
+import { t as string_default } from "./string-5IAMEUit.js";
+//#region tests/integration/tools/patch-instance-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Integration | tools | patch-instance", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	const saveWaitTimeoutMs = 5e3;
+	let mockMatrixUtils = setupMockMatrix(hooks, { autostart: true });
+	let toolService;
+	let PersonDef;
+	let indexQuery;
+	setupRealmCacheTeardown(hooks);
+	hooks.beforeEach(async function() {
+		toolService = getService("tool-service");
+		class SpecialStringA extends string_default {}
+		class SpecialStringB extends string_default {}
+		class Person extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "nickNames", [field], function() {
+					return containsMany(string_default);
+				});
+			}
+			#nickNames = (initializeDeferredDecorator(this, "nickNames"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "bestFriend", [field], function() {
+					return linksTo(() => Person);
+				});
+			}
+			#bestFriend = (initializeDeferredDecorator(this, "bestFriend"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "friends", [field], function() {
+					return linksToMany(() => Person);
+				});
+			}
+			#friends = (initializeDeferredDecorator(this, "friends"), void 0);
+		}
+		PersonDef = Person;
+		let { realm } = await withCachedRealmSetup(async () => setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"person.gts": {
+					Person,
+					SpecialStringA,
+					SpecialStringB
+				},
+				"Person/hassan.json": new Person({ name: "Hassan" }),
+				"Person/polymorphic-nicknames.json": new Person({
+					name: "Polymorphic Nicknames",
+					nickNames: ["Alpha", "Beta"],
+					[fields]: {
+						"nickNames.0": SpecialStringA,
+						"nickNames.1": SpecialStringB
+					}
+				}),
+				"Person/jade.json": new Person({ name: "Jade" }),
+				"Person/queenzy.json": new Person({ name: "Queenzy" }),
+				"Person/germaine.json": new Person({ name: "Germaine" })
+			}
+		}));
+		indexQuery = realm.realmIndexQueryEngine;
+	});
+	(0, import_qunit.test)("can patch a contains field", async function(assert) {
+		let patchInstanceCommand = new PatchCardInstanceTool(toolService.toolContext, { cardType: PersonDef });
+		let url = new URL(`${testRealmURL}Person/hassan`);
+		let saves = 0;
+		this.onSave((saveURL) => {
+			if (saveURL.href === url.href) saves++;
+		});
+		await patchInstanceCommand.execute({
+			cardId: `${testRealmURL}Person/hassan`,
+			patch: { attributes: { name: "Paper" } }
+		});
+		await waitUntil(() => saves > 0, {
+			timeout: saveWaitTimeoutMs,
+			timeoutMessage: "timed out waiting for save to complete"
+		});
+		let result = await indexQuery.instance(url);
+		assert.ok(result, "instance query returned a result");
+		assert.strictEqual(result?.type, "instance", "result is an instance");
+		let instance = result && result.type === "instance" ? result.instance : void 0;
+		assert.ok(instance, "instance payload is present");
+		if (!instance) throw new Error("expected instance payload");
+		assert.deepEqual(instance.attributes, {
+			name: "Paper",
+			cardDescription: null,
+			nickNames: [],
+			cardThumbnailURL: null,
+			cardTitle: "Untitled Card",
+			cardInfo
+		}, "the attributes are correct");
+		assert.deepEqual(instance.relationships, void 0, "the relationships are correct");
+	});
+	(0, import_qunit.test)("can patch a containsMany field", async function(assert) {
+		let patchInstanceCommand = new PatchCardInstanceTool(toolService.toolContext, { cardType: PersonDef });
+		let url = new URL(`${testRealmURL}Person/hassan`);
+		let saves = 0;
+		this.onSave((saveURL) => {
+			if (saveURL.href === url.href) saves++;
+		});
+		await patchInstanceCommand.execute({
+			cardId: `${testRealmURL}Person/hassan`,
+			patch: { attributes: { nickNames: ["Paper"] } }
+		});
+		await waitUntil(() => saves > 0, {
+			timeout: saveWaitTimeoutMs,
+			timeoutMessage: "timed out waiting for save to complete"
+		});
+		let result = await indexQuery.instance(url);
+		assert.ok(result, "instance query returned a result");
+		assert.strictEqual(result?.type, "instance", "result is an instance");
+		let instance = result && result.type === "instance" ? result.instance : void 0;
+		assert.ok(instance, "instance payload is present");
+		if (!instance) throw new Error("expected instance payload");
+		assert.deepEqual(instance.attributes, {
+			name: "Hassan",
+			cardDescription: null,
+			nickNames: ["Paper"],
+			cardThumbnailURL: null,
+			cardTitle: "Untitled Card",
+			cardInfo
+		}, "the attributes are correct");
+		assert.deepEqual(instance.relationships, void 0, "the relationships are correct");
+	});
+	(0, import_qunit.test)("patching a containsMany field with a shorter array fully replaces it (no stale trailing items)", async function(assert) {
+		let patchInstanceCommand = new PatchCardInstanceTool(toolService.toolContext, { cardType: PersonDef });
+		let url = new URL(`${testRealmURL}Person/hassan`);
+		let saves = 0;
+		this.onSave((saveURL) => {
+			if (saveURL.href === url.href) saves++;
+		});
+		await patchInstanceCommand.execute({
+			cardId: `${testRealmURL}Person/hassan`,
+			patch: { attributes: { nickNames: [
+				"Paper",
+				"Pinky",
+				"Pix"
+			] } }
+		});
+		await waitUntil(() => saves > 0, {
+			timeout: saveWaitTimeoutMs,
+			timeoutMessage: "timed out waiting for the first save"
+		});
+		let savesAfterGrow = saves;
+		await patchInstanceCommand.execute({
+			cardId: `${testRealmURL}Person/hassan`,
+			patch: { attributes: { nickNames: ["Paper"] } }
+		});
+		await waitUntil(() => saves > savesAfterGrow, {
+			timeout: saveWaitTimeoutMs,
+			timeoutMessage: "timed out waiting for the second save"
+		});
+		let result = await indexQuery.instance(url);
+		let instance = result && result.type === "instance" ? result.instance : void 0;
+		assert.ok(instance, "instance payload is present");
+		if (!instance) throw new Error("expected instance payload");
+		assert.deepEqual(instance.attributes?.nickNames, ["Paper"], "the containsMany array was fully replaced, not index-merged");
+	});
+	(0, import_qunit.test)("patching a polymorphic containsMany field clears stale field metadata", async function(assert) {
+		let patchInstanceCommand = new PatchCardInstanceTool(toolService.toolContext, { cardType: PersonDef });
+		let cardId = `${testRealmURL}Person/polymorphic-nicknames`;
+		let saves = 0;
+		let savedDoc;
+		this.onSave((saveURL, doc) => {
+			if (saveURL.href === cardId && typeof doc !== "string") {
+				saves++;
+				savedDoc = doc;
+			}
+		});
+		await patchInstanceCommand.execute({
+			cardId,
+			patch: { attributes: { nickNames: ["Beta"] } }
+		});
+		await waitUntil(() => saves > 0, {
+			timeout: saveWaitTimeoutMs,
+			timeoutMessage: "timed out waiting for the first save"
+		});
+		assert.deepEqual(savedDoc?.data.attributes?.nickNames, ["Beta"], "the shorter array was persisted");
+		assert.strictEqual(savedDoc?.data.meta.fields?.["nickNames.0"], void 0, "first index metadata was cleared on replacement");
+		assert.strictEqual(savedDoc?.data.meta.fields?.["nickNames.1"], void 0, "second index metadata was cleared on replacement");
+		let savesAfterShrink = saves;
+		await patchInstanceCommand.execute({
+			cardId,
+			patch: { attributes: { nickNames: ["Beta", "Gamma"] } }
+		});
+		await waitUntil(() => saves > savesAfterShrink, {
+			timeout: saveWaitTimeoutMs,
+			timeoutMessage: "timed out waiting for the second save"
+		});
+		assert.deepEqual(savedDoc?.data.attributes?.nickNames, ["Beta", "Gamma"], "the expanded array was persisted without a reload");
+		assert.strictEqual(savedDoc?.data.meta.fields?.["nickNames.1"], void 0, "old second index metadata did not come back after expanding");
+	});
+	(0, import_qunit.test)("can patch a linksTo field", async function(assert) {
+		let patchInstanceCommand = new PatchCardInstanceTool(toolService.toolContext, { cardType: PersonDef });
+		let url = new URL(`${testRealmURL}Person/hassan`);
+		let saves = 0;
+		this.onSave((saveURL) => {
+			if (saveURL.href === url.href) saves++;
+		});
+		await patchInstanceCommand.execute({
+			cardId: `${testRealmURL}Person/hassan`,
+			patch: { relationships: { bestFriend: { links: { self: `${testRealmURL}Person/jade` } } } }
+		});
+		await waitUntil(() => saves > 0, {
+			timeout: saveWaitTimeoutMs,
+			timeoutMessage: "timed out waiting for save to complete"
+		});
+		let result = await indexQuery.instance(url);
+		assert.ok(result, "instance query returned a result");
+		assert.strictEqual(result?.type, "instance", "result is an instance");
+		let instance = result && result.type === "instance" ? result.instance : void 0;
+		assert.ok(instance, "instance payload is present");
+		if (!instance) throw new Error("expected instance payload");
+		assert.deepEqual(instance.attributes, {
+			name: "Hassan",
+			cardDescription: null,
+			nickNames: [],
+			cardThumbnailURL: null,
+			cardTitle: "Untitled Card",
+			cardInfo
+		}, "the attributes are correct");
+		assert.deepEqual(instance.relationships, { bestFriend: { links: { self: `./jade` } } }, "the relationships are correct");
+	});
+	(0, import_qunit.test)("can patch a linksToMany field", async function(assert) {
+		let patchInstanceCommand = new PatchCardInstanceTool(toolService.toolContext, { cardType: PersonDef });
+		let url = new URL(`${testRealmURL}Person/hassan`);
+		let saves = 0;
+		this.onSave((saveURL) => {
+			if (saveURL.href === url.href) saves++;
+		});
+		await patchInstanceCommand.execute({
+			cardId: `${testRealmURL}Person/hassan`,
+			patch: { relationships: {
+				"friends.0": { links: { self: `${testRealmURL}Person/germaine` } },
+				"friends.1": { links: { self: `${testRealmURL}Person/queenzy` } }
+			} }
+		});
+		await waitUntil(() => saves > 0, {
+			timeout: saveWaitTimeoutMs,
+			timeoutMessage: "timed out waiting for save to complete"
+		});
+		let result = await indexQuery.instance(url);
+		assert.ok(result, "instance query returned a result");
+		assert.strictEqual(result?.type, "instance", "result is an instance");
+		let instance = result && result.type === "instance" ? result.instance : void 0;
+		assert.ok(instance, "instance payload is present");
+		if (!instance) throw new Error("expected instance payload");
+		assert.deepEqual(instance.attributes, {
+			name: "Hassan",
+			cardDescription: null,
+			nickNames: [],
+			cardThumbnailURL: null,
+			cardTitle: "Untitled Card",
+			cardInfo
+		}, "the attributes are correct");
+		assert.deepEqual(instance.relationships, {
+			"friends.0": { links: { self: `./germaine` } },
+			"friends.1": { links: { self: `./queenzy` } }
+		}, "the relationships are correct");
+	});
+	(0, import_qunit.test)("patch command returns before persistence completes", async function(assert) {
+		assert.expect(6);
+		let storeService = getService("store");
+		let cardId = `${testRealmURL}Person/hassan`;
+		let patchInstanceCommand = new PatchCardInstanceTool(toolService.toolContext, { cardType: PersonDef });
+		let saves = 0;
+		let savedName;
+		this.onSave((url, doc) => {
+			if (url.href === cardId && typeof doc !== "string") {
+				saves++;
+				savedName = doc.data.attributes?.name;
+			}
+		});
+		let patchOptions;
+		let originalPatch = storeService.patch;
+		storeService.patch = async function(id, patch, opts) {
+			patchOptions = opts;
+			return await originalPatch.call(this, id, patch, opts);
+		};
+		try {
+			await withSlowSave(100, async () => {
+				await patchInstanceCommand.execute({
+					cardId,
+					patch: { attributes: { name: "Hassan Optimistic" } }
+				});
+				let localCard = storeService.peek(cardId);
+				assert.ok(localCard, "local card is present");
+				if (localCard) assert.strictEqual(localCard.name, "Hassan Optimistic", "local card updated immediately");
+				assert.strictEqual(saves, 0, "persistence has not run yet");
+			});
+		} finally {
+			storeService.patch = originalPatch;
+		}
+		assert.true(patchOptions?.doNotWaitForPersist, "store.patch invoked with doNotWaitForPersist");
+		await waitUntil(() => saves > 0, {
+			timeout: saveWaitTimeoutMs,
+			timeoutMessage: "timed out waiting for save to complete"
+		});
+		assert.strictEqual(savedName, "Hassan Optimistic", "background save includes updated data");
+		let persisted = await storeService.get(cardId);
+		assert.strictEqual(persisted.name, "Hassan Optimistic", "remote card reflects update after background save");
+	});
+	(0, import_qunit.test)("can patch an unsaved instance", async function(assert) {
+		let store = getService("store");
+		let andrea = new PersonDef({ name: "Andrea" });
+		await store.addWithoutPersisting(andrea, { realm: testRealmURL });
+		await new PatchCardInstanceTool(toolService.toolContext, { cardType: PersonDef }).execute({
+			cardId: andrea[localId],
+			patch: {
+				attributes: { nickNames: ["Air"] },
+				relationships: { bestFriend: { links: { self: `${testRealmURL}Person/queenzy` } } }
+			}
+		});
+		await waitUntil(() => andrea.id, { timeoutMessage: "waiting for andrea to get assigned a remote id" });
+		let result = await indexQuery.instance(new URL(andrea.id));
+		assert.ok(result, "instance query returned a result");
+		assert.strictEqual(result?.type, "instance", "result is an instance");
+		let instance = result && result.type === "instance" ? result.instance : void 0;
+		assert.ok(instance, "instance payload is present");
+		if (!instance) throw new Error("expected instance payload");
+		assert.deepEqual(instance.attributes, {
+			name: "Andrea",
+			cardDescription: null,
+			nickNames: ["Air"],
+			cardThumbnailURL: null,
+			cardTitle: "Untitled Card",
+			cardInfo
+		}, "the attributes are correct");
+		assert.deepEqual(instance.relationships, { bestFriend: { links: { self: `./queenzy` } } }, "the relationships are correct");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/pdf-file-def-test-Barj9ffD.js

@@ -0,0 +1,111 @@
+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/pdf-def/pdf-file-def-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var encoder = new TextEncoder();
+function makeMinimalPdf() {
+	return encoder.encode("%PDF-1.7\n1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj\n2 0 obj<</Type/Pages/Kids[3 0 R 4 0 R]/Count 2>>endobj\n3 0 obj<</Type/Page/Parent 2 0 R>>endobj\n4 0 obj<</Type/Page/Parent 2 0 R>>endobj\n5 0 obj<</Title(Boxel Test Document)/Author(Test Author)/Producer(Boxel Test Suite)/CreationDate(D:20240320120000Z)>>endobj\ntrailer<</Root 1 0 R/Info 5 0 R>>\n%%EOF\n");
+}
+(0, import_qunit.module)("Acceptance | pdf file 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 pdfDefCodeRef = () => ({
+		module: `${baseRealmRRI}pdf-file-def`,
+		name: "PdfDef"
+	});
+	async function captureFileExtractResult(expectedStatus) {
+		await waitUntil(() => {
+			let status = document.querySelector("[data-prerender-file-extract]")?.getAttribute("data-prerender-file-extract-status");
+			if (!status) return false;
+			if (expectedStatus && status !== expectedStatus) return false;
+			return status === "ready" || status === "error";
+		}, { timeout: 5e3 });
+		let pre = document.querySelector("[data-prerender-file-extract]")?.querySelector("pre");
+		return JSON.parse(pre?.textContent?.trim() ?? "");
+	}
+	hooks.beforeEach(async function() {
+		({realm} = await withCachedRealmSetup(async () => setupAcceptanceTestRealm({
+			mockMatrixUtils,
+			contents: {
+				...SYSTEM_CARD_FIXTURE_CONTENTS,
+				"sample.pdf": makeMinimalPdf(),
+				"not-a-pdf.pdf": "This is plain text, not a PDF document."
+			}
+		})));
+	});
+	hooks.afterEach(function() {
+		delete globalThis.__renderModel;
+		delete globalThis.__boxelFileRenderData;
+	});
+	(0, import_qunit.test)("extracts page count and Info-dictionary metadata from a PDF", async function(assert) {
+		await visit(fileExtractPath(makeFileURL("sample.pdf"), {
+			fileExtract: true,
+			fileDefCodeRef: pdfDefCodeRef()
+		}));
+		let result = await captureFileExtractResult("ready");
+		assert.strictEqual(result.status, "ready");
+		assert.strictEqual(result.searchDoc?.documentInfo?.pageCount, 2, "extracts the page count");
+		assert.strictEqual(result.searchDoc?.documentInfo?.title, "Boxel Test Document", "extracts the title");
+		assert.strictEqual(result.searchDoc?.documentInfo?.author, "Test Author", "extracts the author");
+		assert.strictEqual(result.searchDoc?.documentInfo?.pdfVersion, "1.7", "extracts the PDF version");
+	});
+	(0, import_qunit.test)("falls back when PdfDef is used for non-PDF content", async function(assert) {
+		await visit(fileExtractPath(makeFileURL("not-a-pdf.pdf"), {
+			fileExtract: true,
+			fileDefCodeRef: pdfDefCodeRef()
+		}));
+		let result = await captureFileExtractResult("ready");
+		assert.strictEqual(result.status, "ready");
+		assert.true(result.mismatch, "marks mismatch when content is not a PDF");
+		assert.strictEqual(result.searchDoc?.name, "not-a-pdf.pdf");
+	});
+	(0, import_qunit.test)("isolated template mounts the native page viewer", async function(assert) {
+		let url = makeFileURL("sample.pdf");
+		await visit(fileExtractPath(url, {
+			fileExtract: true,
+			fileDefCodeRef: pdfDefCodeRef()
+		}));
+		let result = await captureFileExtractResult("ready");
+		assert.ok(result.resource, "extraction produced a resource");
+		globalThis.__boxelFileRenderData = {
+			resource: result.resource,
+			fileDefCodeRef: pdfDefCodeRef()
+		};
+		await visit(fileRenderPath(url, {
+			fileRender: true,
+			fileDefCodeRef: pdfDefCodeRef()
+		}));
+		let { status } = await capturePrerenderResult("innerHTML");
+		assert.strictEqual(status, "ready", "render completed");
+		let viewer = document.querySelector("[data-prerender] [data-test-pdf-viewer]");
+		assert.ok(viewer, "the native PDF viewer is mounted");
+		assert.strictEqual(viewer?.getAttribute("type"), "application/pdf", "the viewer requests the PDF content type");
+	});
+	(0, import_qunit.test)("indexing stores document metadata and file meta uses it", async function(assert) {
+		let fileURL = new URL("sample.pdf", testRealmURL);
+		let fileEntry = await realm.realmIndexQueryEngine.file(fileURL);
+		assert.ok(fileEntry, "file entry exists");
+		assert.strictEqual(fileEntry?.searchDoc?.documentInfo?.pageCount, 2, "index stores the page count");
+		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.strictEqual(body?.data?.attributes?.documentInfo?.title, "Boxel Test Document", "file meta includes the document title");
+		assert.deepEqual(body?.data?.meta?.adoptsFrom, pdfDefCodeRef(), "file meta uses the PDF def");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/pdf-metadata-extractor-test-B7KnXcIm.js

@@ -0,0 +1,130 @@
+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/pdf-metadata-extractor-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var encoder = new TextEncoder();
+function pdfBytes(chunks) {
+	let parts = chunks.map((c) => typeof c === "string" ? encoder.encode(c) : c);
+	let total = parts.reduce((sum, p) => sum + p.length, 0);
+	let out = new Uint8Array(total);
+	let offset = 0;
+	for (let part of parts) {
+		out.set(part, offset);
+		offset += part.length;
+	}
+	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 objStm(objectText) {
+	let compressed = await deflate(encoder.encode(objectText));
+	return pdfBytes([
+		`<</Type/ObjStm/N 1/First 0/Filter/FlateDecode/Length ${compressed.length}>>stream\n`,
+		compressed,
+		"\nendstream endobj\n"
+	]);
+}
+(0, import_qunit.module)("Unit | pdf metadata extractor", function(hooks) {
+	setupRenderingTest(hooks);
+	let loader;
+	let extractPdfMetadata;
+	hooks.beforeEach(async function() {
+		loader = getService("loader-service").loader;
+		({extractPdfMetadata} = await loader.import("@cardstack/base/pdf-meta-extractor"));
+	});
+	(0, import_qunit.test)("reads the Info dictionary and page count from an uncompressed PDF", async function(assert) {
+		let bytes = pdfBytes([
+			"%PDF-1.7\n",
+			"1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj\n",
+			"2 0 obj<</Type/Pages/Kids[3 0 R 4 0 R]/Count 2>>endobj\n",
+			"3 0 obj<</Type/Page/Parent 2 0 R>>endobj\n",
+			"4 0 obj<</Type/Page/Parent 2 0 R>>endobj\n",
+			"6 0 obj<</Title(Quarterly Report)/Author(Jane Doe)/Subject(Finance)/Creator(Word)/Producer(libpdf)/CreationDate(D:20230115093000Z)>>endobj\n",
+			"trailer<</Root 1 0 R/Info 6 0 R>>\n"
+		]);
+		let info = await extractPdfMetadata(bytes);
+		assert.strictEqual(info.title, "Quarterly Report");
+		assert.strictEqual(info.author, "Jane Doe");
+		assert.strictEqual(info.subject, "Finance");
+		assert.strictEqual(info.creator, "Word");
+		assert.strictEqual(info.producer, "libpdf");
+		assert.strictEqual(info.pdfVersion, "1.7");
+		assert.strictEqual(info.pageCount, 2);
+		assert.strictEqual(info.created, "2023-01-15T09:30:00Z");
+	});
+	(0, import_qunit.test)("drops a CreationDate that cannot normalize to a real date", async function(assert) {
+		let garbage = await extractPdfMetadata(pdfBytes([
+			"%PDF-1.7\n",
+			"6 0 obj<</Title(No Date)/CreationDate(not a pdf date)>>endobj\n",
+			"trailer<</Info 6 0 R>>\n"
+		]));
+		assert.strictEqual(garbage.title, "No Date");
+		assert.strictEqual(garbage.created, void 0, "unparseable string dropped");
+		let impossible = await extractPdfMetadata(pdfBytes([
+			"%PDF-1.7\n",
+			"6 0 obj<</CreationDate(D:20231345000000Z)>>endobj\n",
+			"trailer<</Info 6 0 R>>\n"
+		]));
+		assert.strictEqual(impossible.created, void 0, "well-formed but impossible date dropped");
+	});
+	(0, import_qunit.test)("falls back to the page-tree /Count when no leaf pages are legible", async function(assert) {
+		let bytes = pdfBytes([
+			"%PDF-1.4\n",
+			"2 0 obj<</Type/Pages/Count 42>>endobj\n",
+			"trailer<</Root 1 0 R>>\n"
+		]);
+		let info = await extractPdfMetadata(bytes);
+		assert.strictEqual(info.pageCount, 42, "reads /Count as the total");
+	});
+	(0, import_qunit.test)("decodes a UTF-16BE hex-string title", async function(assert) {
+		let bytes = pdfBytes([
+			"%PDF-1.6\n",
+			"6 0 obj<</Title<FEFF00430061006600E9>>>endobj\n",
+			"trailer<</Info 6 0 R>>\n"
+		]);
+		let info = await extractPdfMetadata(bytes);
+		assert.strictEqual(info.title, "Café");
+	});
+	(0, import_qunit.test)("reads the Info dictionary out of a compressed object stream", async function(assert) {
+		let bytes = pdfBytes([
+			"%PDF-1.5\n",
+			"3 0 obj<</Type/Page>>endobj\n",
+			await objStm("6 0 <</Title(Compressed Title)/Author(Zed Q)>>"),
+			"trailer<</Info 6 0 R>>\n"
+		]);
+		let info = await extractPdfMetadata(bytes);
+		assert.strictEqual(info.title, "Compressed Title");
+		assert.strictEqual(info.author, "Zed Q");
+		assert.strictEqual(info.pageCount, 1);
+	});
+	(0, import_qunit.test)("leaves the Info strings unread for an encrypted document", async function(assert) {
+		let bytes = pdfBytes([
+			"%PDF-1.7\n",
+			"2 0 obj<</Type/Pages/Count 3>>endobj\n",
+			"6 0 obj<</Title(Ciphertext here)>>endobj\n",
+			"trailer<</Root 1 0 R/Info 6 0 R/Encrypt 9 0 R>>\n"
+		]);
+		let info = await extractPdfMetadata(bytes);
+		assert.true(info.encrypted, "flags the document as encrypted");
+		assert.strictEqual(info.title, void 0, "does not surface ciphertext");
+		assert.strictEqual(info.pageCount, 3);
+	});
+	(0, import_qunit.test)("handles escaped and balanced parentheses in a literal string", async function(assert) {
+		let bytes = pdfBytes([
+			"%PDF-1.7\n",
+			"6 0 obj<</Title(A \\(draft\\) of (part 2))>>endobj\n",
+			"trailer<</Info 6 0 R>>\n"
+		]);
+		let info = await extractPdfMetadata(bytes);
+		assert.strictEqual(info.title, "A (draft) of (part 2)");
+	});
+	(0, import_qunit.test)("throws a content mismatch on non-PDF bytes so the extract falls back", async function(assert) {
+		let notAPdf = encoder.encode("This is a plain text file, not a PDF.");
+		await assert.rejects(extractPdfMetadata(notAPdf), /does not have a PDF header/);
+	});
+});
+//#endregion