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

package/bundled-test-harness/assets/declared-captures-test-C-0yPRU7.js

@@ -0,0 +1,879 @@
+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/declared-captures-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Unit | declared captures", function(hooks) {
+	setupRenderingTest(hooks);
+	let cardApi;
+	hooks.beforeEach(async function() {
+		cardApi = await getService("loader-service").loader.import("@cardstack/base/card-api");
+	});
+	(0, import_qunit.test)("a card with no declarations merges to an empty record", function(assert) {
+		class Plain extends cardApi.CardDef {}
+		assert.deepEqual(cardApi.getCaptures(Plain), {});
+		assert.deepEqual(cardApi.getCaptures(cardApi.CardDef), {});
+		assert.deepEqual(cardApi.getCaptures(cardApi.FileDef), {});
+	});
+	(0, import_qunit.test)("declarations on one class are returned by name", function(assert) {
+		class HeroShot extends cardApi.Component {}
+		class Product extends cardApi.CardDef {
+			static captures = {
+				hero: {
+					render: HeroShot,
+					width: 1200,
+					height: 630,
+					background: "white"
+				},
+				thumb: {
+					format: "fitted",
+					width: 300,
+					height: 200,
+					deviceScaleFactor: 2,
+					useAsThumbnail: true
+				}
+			};
+		}
+		let merged = cardApi.getCaptures(Product);
+		assert.deepEqual(Object.keys(merged).sort(), ["hero", "thumb"]);
+		assert.strictEqual(merged.hero.render, HeroShot);
+		assert.strictEqual(merged.thumb.format, "fitted");
+		assert.true(merged.thumb.useAsThumbnail);
+	});
+	(0, import_qunit.test)("a subclass adds new names and inherits ancestors up the chain", function(assert) {
+		class Video extends cardApi.FileDef {
+			static captures = { poster: {
+				format: "embedded",
+				width: 640,
+				height: 360,
+				keyBy: "file-content",
+				type: "jpeg"
+			} };
+		}
+		class Trailer extends Video {
+			static captures = { banner: {
+				format: "embedded",
+				width: 1024,
+				height: 256
+			} };
+		}
+		class TeaserTrailer extends Trailer {
+			static captures = { teaser: {
+				format: "fitted",
+				width: 150,
+				height: 170
+			} };
+		}
+		assert.deepEqual(Object.keys(TeaserTrailer.captures), ["teaser"]);
+		let merged = cardApi.getCaptures(TeaserTrailer);
+		assert.deepEqual(Object.keys(merged).sort(), [
+			"banner",
+			"poster",
+			"teaser"
+		]);
+		assert.strictEqual(merged.poster.keyBy, "file-content");
+	});
+	(0, import_qunit.test)("a subclass overrides an inherited name wholesale", function(assert) {
+		class Video extends cardApi.FileDef {
+			static captures = { poster: {
+				format: "embedded",
+				width: 640,
+				height: 360,
+				type: "jpeg"
+			} };
+		}
+		class Widescreen extends Video {
+			static captures = { poster: {
+				format: "embedded",
+				width: 1280,
+				height: 720
+			} };
+		}
+		let merged = cardApi.getCaptures(Widescreen);
+		assert.strictEqual(merged.poster.width, 1280);
+		assert.strictEqual(merged.poster.type, void 0);
+	});
+	(0, import_qunit.test)("a name outside the URL-safe charset is refused", function(assert) {
+		for (const name of [
+			"og image",
+			"og/image",
+			"../poster",
+			"-leading",
+			""
+		]) {
+			class Bad extends cardApi.CardDef {
+				static captures = { [name]: {
+					format: "fitted",
+					width: 300,
+					height: 200
+				} };
+			}
+			assert.throws(() => cardApi.getCaptures(Bad), /name must be a URL-safe path segment/, `"${name}" is refused`);
+		}
+		class TooLong extends cardApi.CardDef {
+			static captures = { ["a".repeat(65)]: {
+				format: "fitted",
+				width: 300,
+				height: 200
+			} };
+		}
+		assert.throws(() => cardApi.getCaptures(TooLong), /name must be a URL-safe path segment/);
+	});
+	(0, import_qunit.test)("declaring both or neither of render and format is refused", function(assert) {
+		class Shot extends cardApi.Component {}
+		class Both extends cardApi.CardDef {
+			static captures = { hero: {
+				render: Shot,
+				format: "fitted",
+				width: 300,
+				height: 200
+			} };
+		}
+		class Neither extends cardApi.CardDef {
+			static captures = { hero: {
+				width: 300,
+				height: 200
+			} };
+		}
+		assert.throws(() => cardApi.getCaptures(Both), /declare exactly one of render or format/);
+		assert.throws(() => cardApi.getCaptures(Neither), /declare exactly one of render or format/);
+	});
+	(0, import_qunit.test)("formats outside the declared-capture roster are refused", function(assert) {
+		for (const format of [
+			"edit",
+			"head",
+			"markdown",
+			"bogus"
+		]) {
+			class Bad extends cardApi.CardDef {
+				static captures = { shot: {
+					format,
+					width: 300,
+					height: 200
+				} };
+			}
+			assert.throws(() => cardApi.getCaptures(Bad), /format must be one of/, `"${format}" is refused`);
+		}
+	});
+	(0, import_qunit.test)("unknown spec fields are refused by name", function(assert) {
+		class Bad extends cardApi.CardDef {
+			static captures = { shot: {
+				format: "fitted",
+				width: 300,
+				height: 200,
+				useAsThumbnal: true
+			} };
+		}
+		assert.throws(() => cardApi.getCaptures(Bad), /unknown field "useAsThumbnal"/);
+	});
+	(0, import_qunit.test)("capture-box dimensions must be positive integers within the engine caps", function(assert) {
+		for (let [field, value] of [
+			["width", 0],
+			["width", -100],
+			["width", 12.5],
+			["width", 5e3],
+			["height", 2e4],
+			["height", void 0]
+		]) {
+			class Bad extends cardApi.CardDef {
+				static captures = { shot: {
+					format: "fitted",
+					width: 300,
+					height: 200,
+					[field]: value
+				} };
+			}
+			assert.throws(() => cardApi.getCaptures(Bad), new RegExp(`${field} must be an integer between`), `${field}=${value} is refused`);
+		}
+		class BadDsf extends cardApi.CardDef {
+			static captures = { shot: {
+				format: "fitted",
+				width: 300,
+				height: 200,
+				deviceScaleFactor: 4
+			} };
+		}
+		assert.throws(() => cardApi.getCaptures(BadDsf), /deviceScaleFactor must be a number/);
+	});
+	(0, import_qunit.test)("each edge × deviceScaleFactor must fit the physical-pixel cap", function(assert) {
+		class ImplicitScale extends cardApi.CardDef {
+			static captures = { tall: {
+				format: "fitted",
+				width: 300,
+				height: 16384
+			} };
+		}
+		assert.throws(() => cardApi.getCaptures(ImplicitScale), /height × deviceScaleFactor must be <= 16384 physical pixels/);
+		class ExplicitScale extends cardApi.CardDef {
+			static captures = { tall: {
+				format: "fitted",
+				width: 300,
+				height: 8192,
+				deviceScaleFactor: 3
+			} };
+		}
+		assert.throws(() => cardApi.getCaptures(ExplicitScale), /height × deviceScaleFactor must be <= 16384 physical pixels/);
+		class AtCap extends cardApi.CardDef {
+			static captures = {
+				implicit: {
+					format: "fitted",
+					width: 300,
+					height: 8192
+				},
+				explicit: {
+					format: "fitted",
+					width: 300,
+					height: 16384,
+					deviceScaleFactor: 1
+				}
+			};
+		}
+		assert.deepEqual(Object.keys(cardApi.getCaptures(AtCap)).sort(), ["explicit", "implicit"]);
+	});
+	(0, import_qunit.test)("keyBy 'file-content' is refused off FileDef chains", function(assert) {
+		class Bad extends cardApi.CardDef {
+			static captures = { shot: {
+				format: "fitted",
+				width: 300,
+				height: 200,
+				keyBy: "file-content"
+			} };
+		}
+		assert.throws(() => cardApi.getCaptures(Bad), /keyBy 'file-content' requires a file-backed def/);
+		class Doc extends cardApi.FileDef {
+			static captures = { shot: {
+				format: "fitted",
+				width: 300,
+				height: 200,
+				keyBy: "file-content"
+			} };
+		}
+		assert.strictEqual(cardApi.getCaptures(Doc).shot.keyBy, "file-content", "legal on a FileDef subclass");
+	});
+	(0, import_qunit.test)("keyBy and type are constrained to their rosters", function(assert) {
+		class BadKeyBy extends cardApi.CardDef {
+			static captures = { shot: {
+				format: "fitted",
+				width: 300,
+				height: 200,
+				keyBy: "mtime"
+			} };
+		}
+		class BadType extends cardApi.CardDef {
+			static captures = { shot: {
+				format: "fitted",
+				width: 300,
+				height: 200,
+				type: "gif"
+			} };
+		}
+		assert.throws(() => cardApi.getCaptures(BadKeyBy), /keyBy must be one/);
+		assert.throws(() => cardApi.getCaptures(BadType), /type must be one/);
+	});
+	(0, import_qunit.test)("a pdf capture is a geometry-free declaration from a format or a render slot", function(assert) {
+		class InvoiceDocument extends cardApi.Component {}
+		class Reports extends cardApi.CardDef {
+			static captures = {
+				statement: {
+					format: "isolated",
+					type: "pdf"
+				},
+				summary: {
+					format: "embedded",
+					type: "pdf",
+					keyBy: "generation"
+				},
+				invoice: {
+					render: InvoiceDocument,
+					type: "pdf"
+				}
+			};
+		}
+		let merged = cardApi.getCaptures(Reports);
+		assert.strictEqual(merged.statement.type, "pdf");
+		assert.strictEqual(merged.statement.format, "isolated");
+		assert.strictEqual(merged.statement.width, void 0, "a pdf declares no capture box");
+		assert.strictEqual(merged.summary.format, "embedded");
+		assert.strictEqual(merged.invoice.render, InvoiceDocument, "a pdf can source from a capture-only render component");
+	});
+	(0, import_qunit.test)("a pdf capture refuses raster fields, box formats, and thumbnails", function(assert) {
+		for (let [spec, pattern] of [
+			[{
+				format: "isolated",
+				type: "pdf",
+				width: 300
+			}, /'width' is a raster/],
+			[{
+				format: "isolated",
+				type: "pdf",
+				height: 300
+			}, /'height' is a raster/],
+			[{
+				format: "isolated",
+				type: "pdf",
+				deviceScaleFactor: 2
+			}, /'deviceScaleFactor' is a raster/],
+			[{
+				format: "isolated",
+				type: "pdf",
+				background: "white"
+			}, /'background' is a raster/],
+			[{
+				format: "fitted",
+				type: "pdf"
+			}, /format must be 'isolated' or 'embedded'/],
+			[{
+				format: "atom",
+				type: "pdf"
+			}, /format must be 'isolated' or 'embedded'/],
+			[{
+				render: class {},
+				type: "pdf",
+				width: 300
+			}, /'width' is a raster/],
+			[{
+				format: "isolated",
+				type: "pdf",
+				useAsThumbnail: true
+			}, /useAsThumbnail cannot appear on a pdf/]
+		]) {
+			class Bad extends cardApi.CardDef {
+				static captures = { shot: spec };
+			}
+			assert.throws(() => cardApi.getCaptures(Bad), pattern);
+		}
+	});
+	(0, import_qunit.test)("filename is a pdf-only field that must be a non-empty string or a function", function(assert) {
+		for (let [spec, pattern] of [
+			[{
+				format: "isolated",
+				width: 300,
+				height: 200,
+				filename: "shot"
+			}, /filename names a saved document and is only valid on a pdf capture/],
+			[{
+				format: "isolated",
+				type: "pdf",
+				filename: "  "
+			}, /filename must be a non-empty string or a function/],
+			[{
+				format: "isolated",
+				type: "pdf",
+				filename: 42
+			}, /filename must be a non-empty string or a function/]
+		]) {
+			class Bad extends cardApi.CardDef {
+				static captures = { shot: spec };
+			}
+			assert.throws(() => cardApi.getCaptures(Bad), pattern);
+		}
+		class Good extends cardApi.CardDef {
+			static captures = {
+				fixed: {
+					format: "isolated",
+					type: "pdf",
+					filename: "Statement"
+				},
+				computed: {
+					format: "embedded",
+					type: "pdf",
+					filename: (card) => card.cardTitle
+				}
+			};
+		}
+		assert.deepEqual(Object.keys(cardApi.getCaptures(Good)).sort(), ["computed", "fixed"]);
+	});
+	(0, import_qunit.test)("title is a pdf-only field that must be a non-empty string or a function", function(assert) {
+		for (let [spec, pattern] of [
+			[{
+				format: "isolated",
+				width: 300,
+				height: 200,
+				title: "Shot"
+			}, /title names a document and is only valid on a pdf capture/],
+			[{
+				format: "isolated",
+				type: "pdf",
+				title: "  "
+			}, /title must be a non-empty string or a function/],
+			[{
+				format: "isolated",
+				type: "pdf",
+				title: 42
+			}, /title must be a non-empty string or a function/]
+		]) {
+			class Bad extends cardApi.CardDef {
+				static captures = { shot: spec };
+			}
+			assert.throws(() => cardApi.getCaptures(Bad), pattern);
+		}
+		class Good extends cardApi.CardDef {
+			static captures = {
+				fixed: {
+					format: "isolated",
+					type: "pdf",
+					title: "Statement"
+				},
+				computed: {
+					format: "embedded",
+					type: "pdf",
+					title: (card) => card.cardTitle
+				}
+			};
+		}
+		assert.deepEqual(Object.keys(cardApi.getCaptures(Good)).sort(), ["computed", "fixed"]);
+	});
+	(0, import_qunit.test)("a transparent background on a jpeg capture is refused", function(assert) {
+		class TransparentJpeg extends cardApi.CardDef {
+			static captures = { shot: {
+				format: "fitted",
+				width: 300,
+				height: 200,
+				background: "transparent",
+				type: "jpeg"
+			} };
+		}
+		class TransparentWebp extends cardApi.CardDef {
+			static captures = { shot: {
+				format: "fitted",
+				width: 300,
+				height: 200,
+				background: "transparent",
+				type: "webp"
+			} };
+		}
+		assert.throws(() => cardApi.getCaptures(TransparentJpeg), /cannot be captured as jpeg/);
+		assert.strictEqual(cardApi.getCaptures(TransparentWebp).shot.background, "transparent", "an alpha-capable type accepts a transparent background");
+	});
+	(0, import_qunit.test)("more than one useAsThumbnail across the merged chain is refused", function(assert) {
+		class Video extends cardApi.FileDef {
+			static captures = { poster: {
+				format: "embedded",
+				width: 640,
+				height: 360,
+				useAsThumbnail: true
+			} };
+		}
+		class Trailer extends Video {
+			static captures = { banner: {
+				format: "embedded",
+				width: 1024,
+				height: 256,
+				useAsThumbnail: true
+			} };
+		}
+		assert.strictEqual(Object.keys(cardApi.getCaptures(Video)).length, 1, "base class alone is valid");
+		assert.throws(() => cardApi.getCaptures(Trailer), /more than one useAsThumbnail capture \("poster", "banner"\)/);
+	});
+	(0, import_qunit.test)("two useAsThumbnail entries on one class are refused", function(assert) {
+		class Bad extends cardApi.CardDef {
+			static captures = {
+				a: {
+					format: "fitted",
+					width: 300,
+					height: 200,
+					useAsThumbnail: true
+				},
+				b: {
+					format: "embedded",
+					width: 300,
+					height: 200,
+					useAsThumbnail: true
+				}
+			};
+		}
+		assert.throws(() => cardApi.getCaptures(Bad), /more than one useAsThumbnail/);
+	});
+	(0, import_qunit.test)("overriding an inherited entry by name can move the thumbnail", function(assert) {
+		class Video extends cardApi.FileDef {
+			static captures = { poster: {
+				format: "embedded",
+				width: 640,
+				height: 360,
+				useAsThumbnail: true
+			} };
+		}
+		class Trailer extends Video {
+			static captures = {
+				poster: {
+					format: "embedded",
+					width: 640,
+					height: 360
+				},
+				banner: {
+					format: "embedded",
+					width: 1024,
+					height: 256,
+					useAsThumbnail: true
+				}
+			};
+		}
+		let merged = cardApi.getCaptures(Trailer);
+		assert.strictEqual(merged.poster.useAsThumbnail, void 0);
+		assert.true(merged.banner.useAsThumbnail);
+	});
+	(0, import_qunit.test)("serializeDeclaredCaptures crosses the page boundary without the component", function(assert) {
+		class HeroShot extends cardApi.Component {}
+		class Product extends cardApi.CardDef {
+			static captures = {
+				card: {
+					format: "fitted",
+					width: 400,
+					height: 300,
+					useAsThumbnail: true
+				},
+				hero: {
+					render: HeroShot,
+					width: 320,
+					height: 180,
+					deviceScaleFactor: 1,
+					background: "transparent",
+					type: "webp"
+				}
+			};
+		}
+		let roster = cardApi.serializeDeclaredCaptures(Product);
+		assert.deepEqual(roster.card, {
+			width: 400,
+			height: 300,
+			useAsThumbnail: true,
+			format: "fitted"
+		});
+		assert.deepEqual(roster.hero, {
+			width: 320,
+			height: 180,
+			deviceScaleFactor: 1,
+			background: "transparent",
+			type: "webp",
+			render: true
+		});
+		assert.deepEqual(cardApi.serializeDeclaredCaptures(cardApi.CardDef), {}, "no declarations serialize to an empty roster");
+	});
+	(0, import_qunit.test)("serializeDeclaredCaptures resolves a pdf filename against the instance it is given", function(assert) {
+		class Statement extends cardApi.CardDef {
+			static displayName = "Statement";
+			static captures = {
+				fixed: {
+					format: "isolated",
+					type: "pdf",
+					filename: "Annual Report"
+				},
+				computed: {
+					format: "isolated",
+					type: "pdf",
+					filename: (card) => `${card.cardTitle} (copy)`
+				},
+				throwing: {
+					format: "isolated",
+					type: "pdf",
+					filename: () => {
+						throw new Error("boom");
+					}
+				},
+				empty: {
+					format: "isolated",
+					type: "pdf",
+					filename: () => "  "
+				},
+				sliced: {
+					format: "isolated",
+					type: "pdf",
+					filename: () => "Trip 🏖 notes".slice(0, 6)
+				},
+				titled: {
+					format: "isolated",
+					type: "pdf"
+				},
+				tile: {
+					format: "fitted",
+					width: 170,
+					height: 250
+				}
+			};
+		}
+		let named = new Statement({ cardInfo: new cardApi.CardInfoField({ name: "Acme Q3" }) });
+		let roster = cardApi.serializeDeclaredCaptures(Statement, named);
+		assert.strictEqual(roster.fixed.filename, "Annual Report");
+		assert.strictEqual(roster.computed.filename, "Acme Q3 (copy)");
+		assert.strictEqual(roster.throwing.filename, "Acme Q3", "a throwing function falls back to the title");
+		assert.strictEqual(roster.empty.filename, "Acme Q3", "an empty result falls back to the title");
+		assert.strictEqual(roster.titled.filename, "Acme Q3");
+		assert.strictEqual(roster.sliced.filename, "Trip �", "a lone surrogate from a sliced emoji becomes U+FFFD");
+		assert.false("filename" in roster.tile, "a raster slot carries none");
+		let untitled = cardApi.serializeDeclaredCaptures(Statement, new Statement());
+		assert.false("filename" in untitled.titled, "the untitled placeholder is not a filename");
+		assert.strictEqual(untitled.computed.filename, "Untitled Statement (copy)");
+		let classOnly = cardApi.serializeDeclaredCaptures(Statement);
+		assert.false("filename" in classOnly.fixed, "a class-only roster resolves no filename");
+	});
+	(0, import_qunit.test)("serializeDeclaredCaptures resolves a pdf title against the instance it is given", function(assert) {
+		class Statement extends cardApi.CardDef {
+			static displayName = "Statement";
+			static captures = {
+				fixed: {
+					format: "isolated",
+					type: "pdf",
+					title: "Annual Report"
+				},
+				computed: {
+					format: "isolated",
+					type: "pdf",
+					title: (card) => `${card.cardTitle} — Q3`
+				},
+				throwing: {
+					format: "isolated",
+					type: "pdf",
+					title: () => {
+						throw new Error("boom");
+					}
+				},
+				empty: {
+					format: "isolated",
+					type: "pdf",
+					title: () => "  "
+				},
+				named: {
+					format: "isolated",
+					type: "pdf",
+					filename: "statement-q3"
+				},
+				tile: {
+					format: "fitted",
+					width: 170,
+					height: 250
+				}
+			};
+		}
+		let titled = new Statement({ cardInfo: new cardApi.CardInfoField({ name: "Acme" }) });
+		let roster = cardApi.serializeDeclaredCaptures(Statement, titled);
+		assert.strictEqual(roster.fixed.title, "Annual Report");
+		assert.strictEqual(roster.computed.title, "Acme — Q3");
+		assert.strictEqual(roster.throwing.title, "Acme", "a throwing function falls back to the card title");
+		assert.strictEqual(roster.empty.title, "Acme", "an empty result falls back to the card title");
+		assert.strictEqual(roster.named.title, "Acme", "a declared filename does not stand in for the title");
+		assert.false("title" in roster.tile, "a raster slot carries none");
+		let untitled = cardApi.serializeDeclaredCaptures(Statement, new Statement());
+		assert.strictEqual(untitled.named.title, "Untitled Statement", "the untitled placeholder still titles the document");
+		let classOnly = cardApi.serializeDeclaredCaptures(Statement);
+		assert.false("title" in classOnly.fixed, "a class-only roster resolves no title");
+	});
+	(0, import_qunit.test)("a FileDef's pdf filename defaults to its name without the extension", function(assert) {
+		class Doc extends cardApi.FileDef {
+			static captures = { print: {
+				render: class {},
+				type: "pdf"
+			} };
+		}
+		let roster = cardApi.serializeDeclaredCaptures(Doc, new Doc({ name: "quarterly.report.docx" }));
+		assert.strictEqual(roster.print.filename, "quarterly.report");
+		assert.strictEqual(roster.print.title, "quarterly.report");
+	});
+	(0, import_qunit.test)("a non-object declarations value is refused", function(assert) {
+		class Bad extends cardApi.CardDef {
+			static captures = ["nope"];
+		}
+		assert.throws(() => cardApi.getCaptures(Bad), /must be an object mapping names to specs/);
+	});
+	(0, import_qunit.test)("a 'static screenshots' declaration is refused by name", function(assert) {
+		class Legacy extends cardApi.CardDef {
+			static screenshots = { hero: {
+				format: "isolated",
+				width: 800,
+				height: 600
+			} };
+		}
+		assert.throws(() => cardApi.getCaptures(Legacy), /'static screenshots', which is no longer read — rename it to 'static captures'/);
+	});
+	(0, import_qunit.test)("an inherited screenshots declaration is refused too", function(assert) {
+		class Base extends cardApi.CardDef {
+			static screenshots = { hero: { format: "isolated" } };
+		}
+		class Child extends Base {
+			static captures = { thumb: {
+				format: "fitted",
+				width: 300,
+				height: 200
+			} };
+		}
+		assert.throws(() => cardApi.getCaptures(Child), /no longer read/, "a valid own declaration does not mask an ancestor that still uses the old name");
+	});
+	(0, import_qunit.test)("captureURLs maps declared names to captured URLs from meta", function(assert) {
+		class Product extends cardApi.CardDef {
+			static captures = {
+				hero: {
+					format: "isolated",
+					width: 800,
+					height: 600
+				},
+				thumb: {
+					format: "fitted",
+					width: 300,
+					height: 200
+				}
+			};
+		}
+		let instance = new Product();
+		assert.deepEqual(instance.captureURLs, {
+			hero: void 0,
+			thumb: void 0
+		}, "every declared name is a key; undefined until a capture exists");
+		instance[cardApi.meta] = { captures: { hero: {
+			url: "http://example.com/r/_capture/card-1?name=hero",
+			hash: "abc123",
+			contentType: "image/png",
+			width: 800,
+			height: 600,
+			deviceScaleFactor: 2
+		} } };
+		assert.deepEqual(instance.captureURLs, {
+			hero: "http://example.com/r/_capture/card-1?name=hero",
+			thumb: void 0
+		}, "a captured name reads its durable served URL; the uncaptured one stays undefined");
+	});
+	(0, import_qunit.test)("captureURLs also surfaces captured names the class no longer declares", function(assert) {
+		class Plain extends cardApi.CardDef {}
+		let instance = new Plain();
+		instance[cardApi.meta] = { captures: { legacy: {
+			url: "http://example.com/r/_capture/card-1?name=legacy",
+			hash: "abc123",
+			contentType: "image/png",
+			width: 800,
+			height: 600,
+			deviceScaleFactor: 2
+		} } };
+		assert.deepEqual(instance.captureURLs, { legacy: "http://example.com/r/_capture/card-1?name=legacy" }, "a manifest entry outliving its declaration still serves, so it still reads");
+	});
+	(0, import_qunit.test)("a FileDef reads captureURLs the same way", function(assert) {
+		class Video extends cardApi.FileDef {
+			static captures = { poster: {
+				format: "embedded",
+				width: 640,
+				height: 360,
+				keyBy: "file-content"
+			} };
+		}
+		let instance = new Video();
+		assert.deepEqual(instance.captureURLs, { poster: void 0 }, "the prerender pass captures only instance rows, so a file declared name reads undefined");
+	});
+	(0, import_qunit.test)("an invalid declaration reads as nothing declared rather than throwing", function(assert) {
+		class Bad extends cardApi.CardDef {
+			static captures = { hero: { width: 800 } };
+		}
+		let instance = new Bad();
+		assert.deepEqual(instance.captureURLs, {}, "consumption stays render-safe; the declaration error surfaces at authoring/capture surfaces");
+	});
+	(0, import_qunit.test)("cardThumbnailURL falls back to the useAsThumbnail capture", function(assert) {
+		class Product extends cardApi.CardDef {
+			static captures = {
+				tile: {
+					format: "fitted",
+					width: 170,
+					height: 250,
+					useAsThumbnail: true
+				},
+				hero: {
+					format: "isolated",
+					width: 800,
+					height: 600
+				}
+			};
+		}
+		let instance = new Product();
+		assert.notOk(instance.cardThumbnailURL, "nullish until a capture exists — the absence signal the icon default engages on");
+		instance[cardApi.meta] = { captures: {
+			hero: {
+				url: "http://example.com/r/_capture/card-1?name=hero",
+				hash: "aaa",
+				contentType: "image/png",
+				width: 800,
+				height: 600,
+				deviceScaleFactor: 2
+			},
+			tile: {
+				url: "http://example.com/r/_capture/card-1?name=tile",
+				hash: "bbb",
+				contentType: "image/png",
+				width: 170,
+				height: 250,
+				deviceScaleFactor: 2,
+				useAsThumbnail: true
+			}
+		} };
+		assert.strictEqual(instance.cardThumbnailURL, "http://example.com/r/_capture/card-1?name=tile", "the declared useAsThumbnail slot feeds the thumbnail, not other captures");
+	});
+	(0, import_qunit.test)("author-set thumbnails win over the capture", function(assert) {
+		class Product extends cardApi.CardDef {
+			static captures = { tile: {
+				format: "fitted",
+				width: 170,
+				height: 250,
+				useAsThumbnail: true
+			} };
+		}
+		let instance = new Product();
+		instance[cardApi.meta] = { captures: { tile: {
+			url: "http://example.com/r/_capture/card-1?name=tile",
+			hash: "bbb",
+			contentType: "image/png",
+			width: 170,
+			height: 250,
+			deviceScaleFactor: 2,
+			useAsThumbnail: true
+		} } };
+		let img = new cardApi.ImageDef({
+			id: "http://example.com/authored.png",
+			url: "http://example.com/authored.png"
+		});
+		instance.cardInfo.cardThumbnail = img;
+		assert.strictEqual(instance.cardThumbnailURL, "http://example.com/authored.png", "an authored ImageDef link outranks the capture");
+		instance.cardInfo.cardThumbnailURL = "http://example.com/explicit.png";
+		assert.strictEqual(instance.cardThumbnailURL, "http://example.com/explicit.png", "an explicit URL outranks everything");
+	});
+	(0, import_qunit.test)("an empty-string authored URL falls through to the capture", function(assert) {
+		class Product extends cardApi.CardDef {
+			static captures = { tile: {
+				format: "fitted",
+				width: 170,
+				height: 250,
+				useAsThumbnail: true
+			} };
+		}
+		let instance = new Product();
+		instance[cardApi.meta] = { captures: { tile: {
+			url: "http://example.com/r/_capture/card-1?name=tile",
+			hash: "bbb",
+			contentType: "image/png",
+			width: 170,
+			height: 250,
+			deviceScaleFactor: 2,
+			useAsThumbnail: true
+		} } };
+		instance.cardInfo.cardThumbnailURL = "";
+		assert.strictEqual(instance.cardThumbnailURL, "http://example.com/r/_capture/card-1?name=tile", "an emptied authored URL does not mask the capture");
+	});
+	(0, import_qunit.test)("a card without a useAsThumbnail declaration ignores captured slots", function(assert) {
+		class Product extends cardApi.CardDef {
+			static captures = { hero: {
+				format: "isolated",
+				width: 800,
+				height: 600
+			} };
+		}
+		let instance = new Product();
+		instance[cardApi.meta] = { captures: { hero: {
+			url: "http://example.com/r/_capture/card-1?name=hero",
+			hash: "aaa",
+			contentType: "image/png",
+			width: 800,
+			height: 600,
+			deviceScaleFactor: 2
+		} } };
+		assert.notOk(instance.cardThumbnailURL, "no declared thumbnail slot means no capture rung");
+	});
+	(0, import_qunit.test)("the @field decorator refuses the reserved captureURLs name", function(assert) {
+		class Bad extends cardApi.CardDef {}
+		assert.throws(() => cardApi.field(Bad.prototype, "captureURLs", { initializer: () => ({}) }), /"captureURLs" is a reserved name/);
+	});
+});
+//#endregion