@cardstack/boxel-cli 0.9.0 → 0.10.0-unstable.0

package/bundled-test-harness/assets/check-correctness-test-BfMV-MC0.js

@@ -1,554 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { Ar as testRealmURL } from "./runtime-common-ClpqhbwG.js";
-import { M as waitUntil } from "./dist-BOAdzfkP.js";
-import { t as CheckCorrectnessTool } from "./check-correctness-Cm_rih_O.js";
-import { t as PatchCardInstanceTool } from "./patch-card-instance-UcLXIvSK.js";
-import { t as RunRealmCodeTool } from "./run-realm-code-DyVyEDBl.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-DPQ0j2MD.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-//#region tests/integration/tools/check-correctness-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-function petDocument(name, hasError) {
-	return JSON.stringify({ data: {
-		type: "card",
-		attributes: {
-			name,
-			hasError
-		},
-		meta: { adoptsFrom: {
-			module: "../pet",
-			name: "Pet"
-		} }
-	} }, null, 2);
-}
-function ticketDocument(overrides = {}) {
-	return JSON.stringify({ data: {
-		type: "card",
-		attributes: overrides.attributes ?? {
-			status: "New",
-			timers: [{
-				label: "First response",
-				hours: 4
-			}]
-		},
-		relationships: overrides.relationships ?? { customer: { links: { self: "../Pet/billy" } } },
-		meta: {
-			adoptsFrom: {
-				module: "../ticket",
-				name: "Ticket"
-			},
-			...overrides.metaFields ? { fields: overrides.metaFields } : {}
-		}
-	} }, null, 2);
-}
-function overwriteScript(path, content) {
-	let p = JSON.stringify(path);
-	return `await realm.fs.replace(${p}, await realm.fs.readText(${p}), ${JSON.stringify(content)});`;
-}
-function writeTextScript(path, content) {
-	return `await realm.fs.writeText(${JSON.stringify(path)}, ${JSON.stringify(content)});`;
-}
-(0, import_qunit.module)("Integration | tools | check-correctness", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		autostart: true,
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL]
-	});
-	setupRealmCacheTeardown(hooks);
-	let testRealm;
-	hooks.beforeEach(async function() {
-		await withCachedRealmSetup(async () => {
-			({realm: testRealm} = await setupIntegrationTestRealm({
-				mockMatrixUtils,
-				contents: {
-					"pet.gts": `
-          import { contains, field, CardDef } from "@cardstack/base/card-api";
-          import StringField from "@cardstack/base/string";
-          import BooleanField from "@cardstack/base/boolean";
-          export class Pet extends CardDef {
-            static displayName = 'Pet';
-            @field name = contains(StringField);
-            @field hasError = contains(BooleanField);
-            @field boom = contains(StringField, {
-              computeVia: function (this: Pet) {
-                if (this.hasError) {
-                  throw new Error('Name cannot be "Bill"');
-                }
-                return 'ok';
-              },
-            });
-          }
-        `,
-					"ticket.gts": `
-          import { contains, containsMany, field, linksTo, linksToMany, CardDef, FieldDef } from "@cardstack/base/card-api";
-          import { FileDef } from "@cardstack/base/file-api";
-          import StringField from "@cardstack/base/string";
-          import NumberField from "@cardstack/base/number";
-          import enumField from "@cardstack/base/enum";
-          import { Pet } from "./pet";
-          const StatusField = enumField(StringField, {
-            options: ['New', 'Open', 'Pending', 'Resolved'],
-          });
-          export class SlaTimerField extends FieldDef {
-            static displayName = 'SlaTimer';
-            @field label = contains(StringField);
-            @field hours = contains(NumberField);
-          }
-          export class TicketItemField extends FieldDef {
-            static displayName = 'TicketItem';
-            @field label = contains(StringField);
-          }
-          export class AssignedItemField extends TicketItemField {
-            static displayName = 'AssignedItem';
-            @field assignee = linksTo(Pet);
-          }
-          export class Ticket extends CardDef {
-            static displayName = 'Ticket';
-            @field status = contains(StatusField);
-            @field customer = linksTo(Pet);
-            @field reference = linksTo(CardDef);
-            @field attachment = linksTo(FileDef);
-            @field watchers = linksToMany(Pet);
-            @field timers = containsMany(SlaTimerField);
-            @field items = containsMany(TicketItemField);
-          }
-        `,
-					"Ticket/t1.json": { data: {
-						type: "card",
-						attributes: {
-							status: "New",
-							timers: [{
-								label: "First response",
-								hours: 4
-							}]
-						},
-						relationships: { customer: { links: { self: "../Pet/billy" } } },
-						meta: { adoptsFrom: {
-							module: "../ticket",
-							name: "Ticket"
-						} }
-					} },
-					"ticket-notes.txt": "Ticket notes",
-					"Pet/gone.json": { data: {
-						type: "card",
-						attributes: {
-							name: "Gone",
-							hasError: false
-						},
-						meta: { adoptsFrom: {
-							module: "../pet",
-							name: "Pet"
-						} }
-					} },
-					"settings.json": {
-						type: "module",
-						meta: { version: 1 },
-						attributes: { enabled: true }
-					},
-					"Pet/billy.json": { data: {
-						type: "card",
-						attributes: {
-							name: "Billy",
-							hasError: false
-						},
-						meta: { adoptsFrom: {
-							module: "../pet",
-							name: "Pet"
-						} }
-					} }
-				}
-			}));
-		});
-		let realmService = getService("realm");
-		getService("message-service").register();
-		await realmService.login(testRealmURL);
-	});
-	(0, import_qunit.test)("reports card instance correctness when PatchCardInstanceTool is used", async function(assert) {
-		let toolService = getService("tool-service");
-		let store = getService("store");
-		let { Pet } = await getService("loader-service").loader.import(`${testRealmURL}pet`);
-		let cardId = `${testRealmURL}Pet/billy`;
-		store.addReference(cardId);
-		await store.waitForCardLoad(cardId);
-		let command = new CheckCorrectnessTool(toolService.toolContext);
-		let runRealmCodeCommand = new RunRealmCodeTool(toolService.toolContext);
-		let roomId = "!room:example.com";
-		let firstResult = await command.execute({
-			targetType: "card",
-			targetRef: cardId,
-			roomId
-		});
-		assert.true(firstResult.correct, "initial run reports no errors");
-		assert.deepEqual(firstResult.warnings, [], "initial run reports no warnings");
-		await new PatchCardInstanceTool(toolService.toolContext, { cardType: Pet }).execute({
-			cardId,
-			patch: { attributes: {
-				name: "Bill",
-				hasError: true
-			} },
-			roomId
-		});
-		let secondResult = await command.execute({
-			targetType: "card",
-			targetRef: cardId,
-			roomId
-		});
-		assert.false(secondResult.correct, "second run reports errors after invalid change");
-		assert.ok(secondResult.errors.some((e) => e.includes("Name cannot be \"Bill\"")), "reports the validation error from the card constructor");
-		let revertResult = await runRealmCodeCommand.execute({
-			realm: testRealmURL,
-			roomId,
-			code: overwriteScript("Pet/billy.json", petDocument("Billy", false))
-		});
-		assert.strictEqual(revertResult.files[0]?.status, "saved", "revert write is saved");
-		let thirdResult = await command.execute({
-			targetType: "card",
-			targetRef: cardId,
-			roomId
-		});
-		assert.true(thirdResult.correct, "third run reports no errors");
-		assert.deepEqual(thirdResult.warnings, [], "third run reports no warnings");
-	});
-	(0, import_qunit.test)("reports card instance correctness when RunRealmCodeTool is used", async function(assert) {
-		let toolService = getService("tool-service");
-		let store = getService("store");
-		let command = new CheckCorrectnessTool(toolService.toolContext);
-		let runRealmCodeCommand = new RunRealmCodeTool(toolService.toolContext);
-		let cardId = `${testRealmURL}Pet/billy`;
-		let roomId = "!room:example.com";
-		store.addReference(cardId);
-		await store.waitForCardLoad(cardId);
-		let firstResult = await command.execute({
-			targetType: "card",
-			targetRef: cardId,
-			roomId
-		});
-		assert.true(firstResult.correct, "initial run reports no errors");
-		await runRealmCodeCommand.execute({
-			realm: testRealmURL,
-			roomId,
-			code: overwriteScript("Pet/billy.json", petDocument("Bill", true))
-		});
-		let secondResult = await command.execute({
-			targetType: "card",
-			targetRef: cardId,
-			roomId
-		});
-		assert.false(secondResult.correct, "second run reports errors");
-		assert.ok(secondResult.errors.some((e) => e.includes("Name cannot be \"Bill\"")), "reports the validation error from the card constructor");
-		let revertResult = await runRealmCodeCommand.execute({
-			realm: testRealmURL,
-			roomId,
-			code: overwriteScript("Pet/billy.json", petDocument("Billy", false))
-		});
-		assert.strictEqual(revertResult.files[0]?.status, "saved", "revert write is saved");
-		let thirdResult = await command.execute({
-			targetType: "card",
-			targetRef: cardId,
-			roomId
-		});
-		assert.true(thirdResult.correct, "third run reports no errors");
-	});
-	(0, import_qunit.test)("skips correctness checks for empty files", async function(assert) {
-		let toolService = getService("tool-service");
-		let runRealmCodeCommand = new RunRealmCodeTool(toolService.toolContext);
-		let command = new CheckCorrectnessTool(toolService.toolContext);
-		let roomId = "!room:example.com";
-		let emptyFileUrl = `${testRealmURL}empty.gts`;
-		let cardService = getService("card-service");
-		await runRealmCodeCommand.execute({
-			realm: testRealmURL,
-			roomId,
-			code: writeTextScript("empty.gts", "")
-		});
-		await waitUntil(async () => {
-			let { status, content } = await cardService.getSource(new URL(emptyFileUrl));
-			return status === 200 && content.trim() === "";
-		});
-		let result = await command.execute({
-			targetType: "file",
-			targetRef: emptyFileUrl,
-			roomId
-		});
-		assert.true(result.correct, "empty file reports as correct");
-		assert.deepEqual(result.errors, [], "no errors are reported");
-	});
-	(0, import_qunit.test)("checks a module file named by a prefix-form identifier", async function(assert) {
-		let toolService = getService("tool-service");
-		let { virtualNetwork } = getService("network");
-		let testRealmPrefix = "@test/correctness-realm/";
-		virtualNetwork.addRealmMapping(testRealmPrefix, testRealmURL);
-		try {
-			await getService("card-service").saveSource(new URL(`${testRealmURL}prefixed-empty.gts`), "", "create-file");
-			let result = await new CheckCorrectnessTool(toolService.toolContext).execute({
-				targetType: "file",
-				targetRef: `${testRealmPrefix}prefixed-empty.gts`,
-				roomId: "!room:example.com"
-			});
-			assert.deepEqual(result.errors, [], "the module and its realm are found from the prefix-form identifier");
-			assert.true(result.correct, "the empty module reports as correct");
-		} finally {
-			virtualNetwork.removeRealmMapping(testRealmPrefix);
-		}
-	});
-	(0, import_qunit.test)("does not treat ordinary JSON configuration as a malformed card", async function(assert) {
-		let result = await new CheckCorrectnessTool(getService("tool-service").toolContext).execute({
-			targetType: "file",
-			targetRef: `${testRealmURL}settings.json`,
-			roomId: "!room:example.com"
-		});
-		assert.true(result.correct, "ordinary JSON is not treated as a card");
-		assert.deepEqual(result.errors, [], "no card-document errors are reported");
-	});
-	(0, import_qunit.test)("reports size limit errors for file writes", async function(assert) {
-		let toolService = getService("tool-service");
-		let environmentService = getService("environment-service");
-		let runRealmCodeCommand = new RunRealmCodeTool(toolService.toolContext);
-		let command = new CheckCorrectnessTool(toolService.toolContext);
-		let roomId = "!room:example.com";
-		let fileUrl = `${testRealmURL}notes.txt`;
-		let originalMaxSize = environmentService.fileSizeLimitBytes;
-		environmentService.fileSizeLimitBytes = 20;
-		try {
-			await assert.rejects(runRealmCodeCommand.execute({
-				realm: testRealmURL,
-				roomId,
-				code: writeTextScript("notes.txt", "x".repeat(21))
-			}), "the oversized write is refused");
-			let result = await command.execute({
-				targetType: "file",
-				targetRef: fileUrl,
-				roomId
-			});
-			assert.false(result.correct, "size limit error reports incorrect");
-			assert.ok(result.errors[0]?.includes("exceeds maximum allowed size (20 bytes)"), "error mentions size limit");
-		} finally {
-			environmentService.fileSizeLimitBytes = originalMaxSize;
-		}
-	});
-	(0, import_qunit.test)("reports size limit errors for card writes via PatchCardInstanceTool", async function(assert) {
-		let toolService = getService("tool-service");
-		let environmentService = getService("environment-service");
-		let loader = getService("loader-service").loader;
-		let store = getService("store");
-		let command = new CheckCorrectnessTool(toolService.toolContext);
-		let roomId = "!room:example.com";
-		let { Pet } = await loader.import(`${testRealmURL}pet`);
-		let cardId = `${testRealmURL}Pet/billy`;
-		store.addReference(cardId);
-		await store.waitForCardLoad(cardId);
-		let originalMaxSize = environmentService.cardSizeLimitBytes;
-		environmentService.cardSizeLimitBytes = 1e3;
-		try {
-			await new PatchCardInstanceTool(toolService.toolContext, { cardType: Pet }).execute({
-				cardId,
-				patch: { attributes: { name: "x".repeat(2e3) } },
-				roomId
-			});
-			let result = await command.execute({
-				targetType: "card",
-				targetRef: cardId,
-				roomId
-			});
-			assert.false(result.correct, "size limit error reports incorrect");
-			assert.ok(result.errors[0]?.includes("exceeds maximum allowed size (1000 bytes)"), "error mentions size limit");
-		} finally {
-			environmentService.cardSizeLimitBytes = originalMaxSize;
-		}
-	});
-	async function checkTicket(overrides) {
-		let toolService = getService("tool-service");
-		let command = new CheckCorrectnessTool(toolService.toolContext);
-		let roomId = "!room:example.com";
-		if (overrides) await new RunRealmCodeTool(toolService.toolContext).execute({
-			realm: testRealmURL,
-			roomId,
-			code: overwriteScript("Ticket/t1.json", ticketDocument(overrides))
-		});
-		return command.execute({
-			targetType: "file",
-			targetRef: `${testRealmURL}Ticket/t1.json`,
-			roomId
-		});
-	}
-	(0, import_qunit.test)("a valid instance passes with no warnings", async function(assert) {
-		let result = await checkTicket();
-		assert.true(result.correct, "valid instance is correct");
-		assert.deepEqual(result.errors, [], "no errors are reported");
-		assert.deepEqual(result.warnings, [], "no warnings are reported");
-	});
-	(0, import_qunit.test)("warns about attributes and relationships the card type does not declare", async function(assert) {
-		let result = await checkTicket({
-			attributes: {
-				status: "New",
-				responseTimer: { hours: 4 },
-				resolutionTimer: { hours: 24 }
-			},
-			relationships: { requester: { links: { self: "../Pet/billy" } } }
-		});
-		assert.true(result.correct, "undeclared fields do not fail the check");
-		assert.deepEqual(result.errors, [], "no errors are reported");
-		assert.strictEqual(result.warnings.length, 3, "three warnings");
-		assert.ok(result.warnings.some((w) => w.includes("\"responseTimer\" is not a field of Ticket")), "warns about the undeclared responseTimer attribute");
-		assert.ok(result.warnings.some((w) => w.includes("\"resolutionTimer\" is not a field of Ticket")), "warns about the undeclared resolutionTimer attribute");
-		assert.ok(result.warnings.some((w) => w.includes("relationships.requester") && w.includes("\"requester\" is not a field of Ticket")), "warns about the undeclared requester relationship");
-	});
-	(0, import_qunit.test)("warns about an enum value outside the allowed options (card target)", async function(assert) {
-		let toolService = getService("tool-service");
-		let runRealmCodeCommand = new RunRealmCodeTool(toolService.toolContext);
-		let command = new CheckCorrectnessTool(toolService.toolContext);
-		let roomId = "!room:example.com";
-		let cardId = `${testRealmURL}Ticket/t1`;
-		await runRealmCodeCommand.execute({
-			realm: testRealmURL,
-			roomId,
-			code: overwriteScript("Ticket/t1.json", ticketDocument({ attributes: { status: "open" } }))
-		});
-		let result = await command.execute({
-			targetType: "card",
-			targetRef: cardId,
-			roomId
-		});
-		assert.true(result.correct, "an out-of-range enum value does not fail the check");
-		assert.deepEqual(result.errors, [], "no errors are reported");
-		assert.strictEqual(result.warnings.length, 1, "one warning");
-		assert.ok(result.warnings[0].includes("\"status\" value \"open\" is not one of the allowed options"), "warning names the field and the rejected value");
-		assert.ok(result.warnings[0].includes("\"New\", \"Open\", \"Pending\", \"Resolved\""), "warning lists the allowed options");
-	});
-	(0, import_qunit.test)("warns about values written in the wrong bucket", async function(assert) {
-		let result = await checkTicket({
-			attributes: {
-				customer: { links: { self: "../Pet/billy" } },
-				watchers: [{ links: { self: "../Pet/billy" } }]
-			},
-			relationships: { status: { links: { self: null } } }
-		});
-		assert.true(result.correct, "bucket mismatches do not fail the check");
-		assert.deepEqual(result.errors, [], "no errors are reported");
-		assert.ok(result.warnings.some((w) => w.includes("\"customer\" is a linksTo relationship of Ticket but was written under \"attributes\"")), "warns about the relationship written under attributes");
-		assert.ok(result.warnings.some((w) => w.includes("\"status\" is a contains attribute of Ticket but was written under \"relationships\"")), "warns about the attribute written under relationships");
-		assert.ok(result.warnings.some((w) => w.includes("\"watchers\" is a linksToMany relationship of Ticket but was written under \"attributes\"") && w.includes("\"watchers.0\": { \"links\"")), "tells the AI to move a linksToMany as indexed keys");
-	});
-	(0, import_qunit.test)("warns about a relationship link whose target does not exist", async function(assert) {
-		let result = await checkTicket({ relationships: { customer: { links: { self: "../Pet/missing" } } } });
-		assert.true(result.correct, "a dangling link does not fail the check");
-		assert.deepEqual(result.errors, [], "no errors are reported");
-		assert.strictEqual(result.warnings.length, 1, "one warning");
-		assert.ok(result.warnings[0].includes(`"customer" links to ${testRealmURL}Pet/missing, which does not exist`), "warning names the field and the resolved target");
-	});
-	(0, import_qunit.test)("does not flag a prefix-form link to a card that exists", async function(assert) {
-		let result = await checkTicket({ relationships: {
-			customer: { links: { self: "../Pet/billy" } },
-			reference: { links: { self: "@cardstack/base/cards/welcome-to-boxel" } }
-		} });
-		assert.true(result.correct, "the instance is correct");
-		assert.deepEqual(result.errors, [], "no errors are reported");
-		assert.deepEqual(result.warnings, [], "the prefix-form link resolves to an existing card");
-	});
-	(0, import_qunit.test)("checks a link to a file as a file", async function(assert) {
-		let result = await checkTicket({ relationships: {
-			customer: { links: { self: "../Pet/billy" } },
-			attachment: { links: { self: "../ticket-notes.txt" } }
-		} });
-		assert.true(result.correct, "the instance is correct");
-		assert.deepEqual(result.warnings, [], "an existing file target is not reported as missing");
-		result = await checkTicket({ relationships: {
-			customer: { links: { self: "../Pet/billy" } },
-			attachment: { links: { self: "../missing.txt" } }
-		} });
-		assert.deepEqual(result.warnings.map((w) => w.replace(/^.*?: /, "")), [`"attachment" links to ${testRealmURL}missing.txt, which does not exist; create it or correct the link`], "a missing file target is reported");
-	});
-	(0, import_qunit.test)("warns about a link to a card deleted after it was loaded", async function(assert) {
-		let goneId = `${testRealmURL}Pet/gone`;
-		await getService("store").get(goneId);
-		await testRealm.delete("Pet/gone.json");
-		let result = await checkTicket({ relationships: { customer: { links: { self: "../Pet/gone" } } } });
-		assert.true(result.correct, "a dangling link does not fail the check");
-		assert.strictEqual(result.warnings.length, 1, "one warning");
-		assert.ok(result.warnings[0].includes(`"customer" links to ${goneId}, which does not exist`), "the deleted target is reported even though the store loaded it");
-	});
-	(0, import_qunit.test)("follows links given as relationship data", async function(assert) {
-		let result = await checkTicket({ relationships: {
-			customer: { data: {
-				type: "card",
-				id: "../Pet/missing"
-			} },
-			watchers: { data: [{
-				type: "card",
-				id: "../Pet/billy"
-			}, {
-				type: "card",
-				id: "../Pet/nobody"
-			}] }
-		} });
-		assert.true(result.correct, "dangling links do not fail the check");
-		assert.deepEqual(result.warnings.map((w) => w.replace(/^.*?: /, "")), [`"customer" links to ${testRealmURL}Pet/missing, which does not exist; create it or correct the link`, `"watchers.1" links to ${testRealmURL}Pet/nobody, which does not exist; create it or correct the link`], "targets named by data.id and by a data array are checked");
-	});
-	(0, import_qunit.test)("does not judge a relationship inside a polymorphic element", async function(assert) {
-		let result = await checkTicket({
-			attributes: {
-				status: "New",
-				items: [{ label: "Escalation" }]
-			},
-			relationships: {
-				customer: { links: { self: "../Pet/billy" } },
-				"items.0.assignee": { links: { self: "../Pet/billy" } }
-			},
-			metaFields: { items: [{ adoptsFrom: {
-				module: "../ticket",
-				name: "AssignedItemField"
-			} }] }
-		});
-		assert.true(result.correct, "the instance is correct");
-		assert.deepEqual(result.errors, [], "no errors are reported");
-		assert.deepEqual(result.warnings, [], "a field declared only on the element subtype is not reported");
-	});
-	(0, import_qunit.test)("warns about an undeclared key inside a compound containsMany field", async function(assert) {
-		let result = await checkTicket({ attributes: {
-			status: "New",
-			timers: [{
-				label: "First response",
-				minutes: 5
-			}]
-		} });
-		assert.true(result.correct, "the undeclared nested key does not fail the check");
-		assert.deepEqual(result.errors, [], "no errors are reported");
-		assert.strictEqual(result.warnings.length, 1, "one warning");
-		assert.ok(result.warnings[0].includes("\"timers.0.minutes\" is not a field of SlaTimer"), "warning names the nested path and the field type");
-	});
-	(0, import_qunit.test)("warns about a value written to a computed field", async function(assert) {
-		let toolService = getService("tool-service");
-		let runRealmCodeCommand = new RunRealmCodeTool(toolService.toolContext);
-		let command = new CheckCorrectnessTool(toolService.toolContext);
-		let roomId = "!room:example.com";
-		await runRealmCodeCommand.execute({
-			realm: testRealmURL,
-			roomId,
-			code: overwriteScript("Pet/billy.json", JSON.stringify({ data: {
-				type: "card",
-				attributes: {
-					name: "Billy",
-					hasError: false,
-					boom: "written"
-				},
-				meta: { adoptsFrom: {
-					module: "../pet",
-					name: "Pet"
-				} }
-			} }, null, 2))
-		});
-		let result = await command.execute({
-			targetType: "file",
-			targetRef: `${testRealmURL}Pet/billy.json`,
-			roomId
-		});
-		assert.true(result.correct, "a computed-field write does not fail the check");
-		assert.deepEqual(result.errors, [], "no errors are reported");
-		assert.strictEqual(result.warnings.length, 1, "one warning");
-		assert.ok(result.warnings[0].includes("\"boom\" is a computed field of Pet"), "warning names the computed field");
-	});
-});
-//#endregion

package/bundled-test-harness/assets/clip-CK6mVuyN.js

@@ -1,92 +0,0 @@
-import "./chunk-Rp0pCe6z.js";
-import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
-import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
-import { t as array } from "./helper-BHX0HLF2.js";
-import "./component-BJO47HTh.js";
-import { t as Component } from "./dist-CkA1rgqO.js";
-import "./template-factory-ds9s0u8l.js";
-import "./src-Bq3lg4hB.js";
-import { t as MotionModifier } from "./motion-l7EBYFii.js";
-import { t as Choreo } from "./choreo-CJDBg03r.js";
-//#region ../choreo/src/film/clip.gts
-/**
-* A CLIP ON THE PICTURE. A video, a still or a freeze of the picture
-* itself, standing over the frame for its window — full frame, or as an
-* inset with its caption like the photograph. The media is not played by
-* the browser's own clock: the film writes its source time every frame
-* (a paused element seeked, a playing one corrected), so a clip is where
-* the clock says it is whether the film played there or was scrubbed
-* there. It arrives the way the insert does — wiped in — and leaves in a
-* short fade.
-*/
-var Clip = class extends Component {
-	/** a pip is placed by the score, in percent of the frame */ get place() {
-		const c = this.args.spec;
-		if (c.fit !== "pip") return "";
-		return [
-			`left:${c.x ?? 66}%`,
-			`top:${c.y ?? 10}%`,
-			`width:${c.w ?? 30}%`,
-			`border-radius:${c.radius ?? 0}%`,
-			`--cf-pip-fade:${c.fade ?? .4}s`
-		].join(";");
-	}
-	/** a pip fades; the editorial card is wiped in and out */
-	get isPip() {
-		return this.args.spec.fit === "pip";
-	}
-	/**
-	* THE LOOK THIS CLIP IS WEARING, as a CSS filter — composed in the same
-	* order the picture's own shader composes its grade (saturate, then
-	* contrast, then brightness, then sepia and hue), because filter order
-	* is not commutative and the two should agree about what a number
-	* means. Blur goes last, where a lens would put it.
-	*
-	* It rides the MEDIA, not the figure, so an inset's caption and its card
-	* are not graded with the footage.
-	*/
-	get look() {
-		const l = this.args.spec.look;
-		if (!l) return "";
-		const f = [];
-		if (l.sat !== void 0) f.push(`saturate(${l.sat})`);
-		if (l.con !== void 0) f.push(`contrast(${l.con})`);
-		if (l.bri !== void 0) f.push(`brightness(${l.bri})`);
-		if (l.sepia !== void 0) f.push(`sepia(${l.sepia})`);
-		if (l.gray !== void 0) f.push(`grayscale(${l.gray})`);
-		if (l.hue !== void 0) f.push(`hue-rotate(${l.hue}deg)`);
-		if (l.blur !== void 0) f.push(`blur(${l.blur}px)`);
-		const out = f.length ? [`filter:${f.join(" ")}`] : [];
-		if (l.opacity !== void 0) out.push(`opacity:${l.opacity}`);
-		return out.join(";");
-	}
-	/** seconds a pip takes to arrive and to go */
-	get fade() {
-		return this.args.spec.fade ?? .4;
-	}
-	get muted() {
-		return !(this.args.spec.volume && this.args.spec.volume > 0);
-	}
-	get volume() {
-		return Math.max(0, Math.min(1, this.args.spec.volume ?? 0));
-	}
-	static {
-		setComponentTemplate(templateFactory({
-			"id": "dq9+2nWu",
-			"block": "[[[8,[32,0],[[16,0,[29,[\"cf-clip is-\",[52,[30,1,[\"fit\"]],[30,1,[\"fit\"]],\"inset\"],\" is-\",[30,2]]]]],[[\"@id\"],[\"clip\"]],[[\"default\"],[[[[1,\"\\n\"],[42,[28,[31,2],[[28,[31,2],[[28,[32,1],[[30,4]],null]],null]],null],\"@identity\",[[[1,\"    \"],[11,\"figure\"],[16,5,[30,0,[\"place\"]]],[4,[32,2],null,[[\"id\",\"role\"],[\"clip\",\"clip\"]]],[12],[1,\"\\n\"],[41,[28,[32,3],[[30,1,[\"kind\"]],\"video\"],null],[[[1,\"        \"],[11,\"video\"],[16,\"src\",[30,5]],[16,5,[30,0,[\"look\"]]],[16,\"muted\",[30,0,[\"muted\"]]],[24,\"playsinline\",\"\"],[24,\"preload\",\"auto\"],[4,[30,6],[[30,7]],null],[12],[13],[1,\"\\n\"]],[]],[[[41,[28,[32,3],[[30,1,[\"kind\"]],\"image\"],null],[[[1,\"        \"],[11,\"img\"],[16,\"src\",[30,5]],[16,5,[30,0,[\"look\"]]],[24,\"alt\",\"\"],[4,[30,6],[[30,7]],null],[12],[13],[1,\"\\n\"]],[]],[[[41,[30,8],[[[1,\"          \"],[11,\"img\"],[16,\"src\",[30,8]],[16,5,[30,0,[\"look\"]]],[24,\"alt\",\"\"],[4,[30,6],[[30,7]],null],[12],[13],[1,\"\\n\"]],[]],null],[1,\"      \"]],[]]]],[]]],[41,[30,1,[\"caption\"]],[[[1,\"        \"],[10,\"figcaption\"],[12],[1,\"\\n          \"],[10,1],[14,0,\"cf-clip-cap\"],[12],[1,[30,1,[\"caption\"]]],[13],[1,\"\\n\"],[41,[30,1,[\"credit\"]],[[[1,\"            \"],[10,1],[14,0,\"cf-clip-cr\"],[12],[1,[30,1,[\"credit\"]]],[13],[1,\"\\n\"]],[]],null],[1,\"        \"],[13],[1,\"\\n\"]],[]],null],[1,\"    \"],[13],[1,\"\\n\"]],[]],null],[41,[30,0,[\"isPip\"]],[[[1,\"    \"],[8,[30,3,[\"Tween\"]],null,[[\"@of\",\"@opacity\",\"@scale\",\"@duration\",\"@ease\"],[[28,[30,3,[\"inserted\"]],[\"clip\"],null],[28,[32,1],[0,1],null],[28,[32,1],[1.04,1],null],[30,0,[\"fade\"]],\"easeOut\"]],null],[1,\"\\n    \"],[8,[30,3,[\"Tween\"]],null,[[\"@of\",\"@opacity\",\"@duration\",\"@ease\"],[[28,[30,3,[\"removed\"]],[\"clip\"],null],0,[30,0,[\"fade\"]],\"easeIn\"]],null],[1,\"\\n\"]],[]],[[[1,\"    \"],[8,[30,3,[\"Tween\"]],null,[[\"@of\",\"@clipPath\",\"@duration\",\"@ease\"],[[28,[30,3,[\"inserted\"]],[\"clip\"],null],[28,[32,1],[\"inset(0 100% 0 0)\",\"inset(0 0% 0 0)\"],null],0.62,[28,[32,1],[0.22,1,0.36,1],null]]],null],[1,\"\\n    \"],[8,[30,3,[\"Tween\"]],null,[[\"@of\",\"@opacity\",\"@duration\",\"@ease\"],[[28,[30,3,[\"removed\"]],[\"clip\"],null],0,0.24,\"easeIn\"]],null],[1,\"\\n\"]],[]]]],[3]]]]]],[\"@spec\",\"@state\",\"g\",\"@key\",\"@src\",\"@mount\",\"@lane\",\"@freeze\"],[\"if\",\"each\",\"-track-array\"]]",
-			"moduleName": "/home/runner/work/boxel/boxel/packages/choreo/src/film/clip.gts",
-			"scope": () => [
-				Choreo,
-				array,
-				MotionModifier,
-				eq
-			],
-			"isStrictMode": true
-		}), this);
-	}
-};
-function eq(a, b) {
-	return a === b;
-}
-//#endregion
-export { Clip as t };

package/bundled-test-harness/assets/clip-CfXD1JTr.js

@@ -1,2 +0,0 @@
-import { t as Clip } from "./clip-CK6mVuyN.js";
-export { Clip };