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

package/bundled-test-harness/assets/check-correctness-test-DjE7r1X2.js

@@ -0,0 +1,1093 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL, Zr as delay, c as hasExecutableExtension } from "./runtime-common-BTaLJEw-.js";
+import { t as config } from "./environment-DIUJgBKt.js";
+import { M as waitUntil } from "./dist-BOAdzfkP.js";
+import { t as CheckCorrectnessTool } from "./check-correctness-UcmAxEhS.js";
+import { t as PatchCardInstanceTool } from "./patch-card-instance-_uyQMYb9.js";
+import { t as RunRealmCodeTool } from "./run-realm-code-DsBUf1si.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, L as setupRealmCacheTeardown, P as setupIntegrationTestRealm, Z as withCachedRealmSetup, h as createPrerenderAuth, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.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 milestoneModule(template) {
+	return `import { contains, field, CardDef, Component } from '@cardstack/base/card-api';
+import StringField from '@cardstack/base/string';
+import DateField from '@cardstack/base/date';
+${template.includes("isoDay") ? `
+function isoDay(value: unknown) {
+  return new Date(value + 'T12:00:00Z').toISOString();
+}
+` : ""}
+export class Milestone extends CardDef {
+  static displayName = 'Milestone';
+  @field title = contains(StringField);
+  @field date = contains(DateField);
+  static isolated = class Isolated extends Component<typeof this> {
+    <template>
+      ${template}
+    </template>
+  };
+}
+`;
+}
+function milestoneDocument(title) {
+	return { data: {
+		type: "card",
+		attributes: {
+			title,
+			date: "2026-11-08"
+		},
+		meta: { adoptsFrom: {
+			module: "../milestone",
+			name: "Milestone"
+		} }
+	} };
+}
+function mountPrerenderEndpoints() {
+	let localIndexer = getService("local-indexer");
+	let realmServerURL = getService("realm-server").url;
+	let renderedCards = [];
+	getService("network").virtualNetwork.mount(async (request) => {
+		let { origin, pathname } = new URL(request.url);
+		if (origin !== realmServerURL.origin || pathname !== "/_prerender-module" && pathname !== "/_prerender-card") return null;
+		let { realm, url } = (await request.json()).data.attributes;
+		let args = {
+			affinityType: "realm",
+			affinityValue: realm,
+			realm,
+			url,
+			auth: createPrerenderAuth("@testuser:localhost", {})
+		};
+		let attributes;
+		if (pathname === "/_prerender-module") attributes = await localIndexer.prerenderer.prerenderModule(args);
+		else {
+			renderedCards.push(url);
+			attributes = (await localIndexer.prerenderer.prerenderVisit({
+				...args,
+				renderOptions: { cardRender: true }
+			})).card;
+		}
+		return new Response(JSON.stringify({ data: {
+			type: "prerender-result",
+			id: url,
+			attributes
+		} }), {
+			status: 201,
+			headers: { "content-type": "application/vnd.api+json" }
+		});
+	}, { prepend: true });
+	return renderedCards;
+}
+function serveUnrenderedInstances(prefix) {
+	getService("network").virtualNetwork.mount(async (request) => {
+		if (!request.url.startsWith(prefix) || request.headers.get("x-boxel-link-shape") !== "links-only") return null;
+		return new Response(JSON.stringify({ data: {
+			type: "card",
+			id: request.url,
+			attributes: {},
+			meta: {
+				adoptsFrom: {
+					module: "../milestone",
+					name: "Milestone"
+				},
+				generation: 1e6
+			}
+		} }), { headers: { "content-type": "application/vnd.card+json" } });
+	}, { prepend: true });
+}
+function announceRendersWithIndexEvents() {
+	let messageService = getService("message-service");
+	let renders = { announced: 0 };
+	messageService.subscribe(testRealmURL, (event) => {
+		if (event.eventName !== "index" || event.indexType !== "incremental" || event.generation === void 0) return;
+		let generation = event.generation;
+		let invalidations = event.invalidations.map((href) => hasExecutableExtension(href) ? href : `${href}.json`);
+		Promise.resolve().then(() => {
+			messageService.relayRealmEvent({
+				eventName: "prerender_html",
+				invalidations,
+				generation,
+				realmURL: testRealmURL
+			});
+			renders.announced++;
+		});
+	});
+	return renders;
+}
+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: {
+					"milestone.gts": milestoneModule("<h1>{{@model.title}}</h1>"),
+					"Milestone/launch.json": milestoneDocument("Product launch"),
+					"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");
+	});
+	async function targetFields(targets) {
+		let { CorrectnessTargetField } = await getService("loader-service").loader.import("@cardstack/base/command");
+		return targets.map((target) => new CorrectnessTargetField(target));
+	}
+	(0, import_qunit.test)("checks several targets in one call and names the one that fails", async function(assert) {
+		let toolService = getService("tool-service");
+		let roomId = "!room:example.com";
+		await new RunRealmCodeTool(toolService.toolContext).execute({
+			realm: testRealmURL,
+			roomId,
+			code: writeTextScript("Pet/bill.json", petDocument("Bill", true))
+		});
+		let result = await new CheckCorrectnessTool(toolService.toolContext).execute({
+			roomId,
+			targets: await targetFields([
+				{
+					type: "card",
+					ref: `${testRealmURL}Pet/billy`
+				},
+				{
+					type: "card",
+					ref: `${testRealmURL}Pet/bill`
+				},
+				{
+					type: "file",
+					ref: `${testRealmURL}ticket-notes.txt`
+				},
+				{
+					type: "file",
+					ref: `${testRealmURL}settings.json`
+				}
+			])
+		});
+		assert.false(result.correct, "the check fails");
+		assert.strictEqual(result.checkedCount, 4, "every target was checked");
+		assert.strictEqual(result.passedCount, 3, "the other three passed");
+		assert.deepEqual(result.targetResults.map((entry) => entry.targetRef), [`${testRealmURL}Pet/bill`], "only the failing card has an entry");
+		assert.ok(result.targetResults[0]?.errors.some((error) => error.includes("Name cannot be \"Bill\"")), "with its error");
+		assert.ok(result.errors.some((error) => error.includes("Name cannot be \"Bill\"")), "the error is also among the result’s errors");
+	});
+	(0, import_qunit.test)("a check of several targets settles each target on its own", async function(assert) {
+		let toolService = getService("tool-service");
+		let environmentService = getService("environment-service");
+		let roomId = "!room:example.com";
+		let originalMaxSize = environmentService.fileSizeLimitBytes;
+		environmentService.fileSizeLimitBytes = 20;
+		try {
+			await assert.rejects(new RunRealmCodeTool(toolService.toolContext).execute({
+				realm: testRealmURL,
+				roomId,
+				code: writeTextScript("notes.txt", "x".repeat(21))
+			}), "the oversized write is refused");
+			let result = await new CheckCorrectnessTool(toolService.toolContext).execute({
+				roomId,
+				targets: await targetFields([{
+					type: "file",
+					ref: `${testRealmURL}notes.txt`
+				}, {
+					type: "card",
+					ref: `${testRealmURL}Pet/billy`
+				}])
+			});
+			assert.deepEqual(result.targetResults.map((entry) => entry.targetRef), [`${testRealmURL}notes.txt`], "the size limit fails only the oversized file");
+			assert.ok(result.targetResults[0]?.errors[0]?.includes("exceeds maximum allowed size (20 bytes)"), "with the size limit error");
+			assert.strictEqual(result.passedCount, 1, "the card is still checked");
+		} finally {
+			environmentService.fileSizeLimitBytes = originalMaxSize;
+		}
+	});
+	(0, import_qunit.test)("a one-target check answers as it always has", async function(assert) {
+		let result = await new CheckCorrectnessTool(getService("tool-service").toolContext).execute({
+			targetType: "card",
+			targetRef: `${testRealmURL}Pet/billy`,
+			roomId: "!room:example.com"
+		});
+		assert.true(result.correct);
+		assert.deepEqual(result.targetResults, [], "no per-target entries");
+		assert.notOk(result.checkedCount, "no counts");
+	});
+	(0, import_qunit.test)("a check of many targets gets more time", async function(assert) {
+		let cards = Array.from({ length: 20 }, (_, n) => ({
+			type: "card",
+			ref: `${testRealmURL}Pet/${n}`
+		}));
+		assert.strictEqual(CheckCorrectnessTool.extraExecuteTimeMsFor({ targets: cards.slice(0, 8) }), 0, "one round fits the standard timeout");
+		assert.strictEqual(CheckCorrectnessTool.extraExecuteTimeMsFor({ targets: [...cards, {
+			type: "file",
+			ref: `${testRealmURL}pet.gts`
+		}] }), 3 * config.cardRenderTimeout, "three cards rounds and one module round: three more render timeouts");
+		assert.strictEqual(CheckCorrectnessTool.extraExecuteTimeMsFor({
+			targetType: "card",
+			targetRef: `${testRealmURL}Pet/billy`
+		}), 0, "a one-target check needs no more");
+	});
+	(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);
+		}
+	});
+	async function checkMilestoneEdit(template, afterWrite) {
+		let toolService = getService("tool-service");
+		let roomId = "!room:example.com";
+		await new RunRealmCodeTool(toolService.toolContext).execute({
+			realm: testRealmURL,
+			roomId,
+			code: overwriteScript("milestone.gts", milestoneModule(template))
+		});
+		await afterWrite?.();
+		return await new CheckCorrectnessTool(toolService.toolContext).execute({
+			targetType: "file",
+			targetRef: `${testRealmURL}milestone.gts`,
+			roomId
+		});
+	}
+	(0, import_qunit.test)("reports an instance whose render a module edit breaks", async function(assert) {
+		mountPrerenderEndpoints();
+		announceRendersWithIndexEvents();
+		let result = await checkMilestoneEdit("<h1>{{@model.title}}</h1><p>{{isoDay @model.date}}</p>");
+		assert.false(result.correct, "the broken render fails the check");
+		assert.strictEqual(result.errors.length, 1, "one error");
+		assert.ok(result.errors[0].startsWith(`${testRealmURL}Milestone/launch: `), `the error names the instance: ${result.errors[0]}`);
+		assert.ok(result.errors[0].includes("Invalid time value"), "the error carries the render error message");
+		assert.ok(result.errors[0].endsWith("(an instance of the edited module; the cause may be the edit or this card's own data)"), "the error says the cause may be the edit or the instance");
+	});
+	(0, import_qunit.test)("passes a module edit whose instances render", async function(assert) {
+		let renderedCards = mountPrerenderEndpoints();
+		announceRendersWithIndexEvents();
+		let result = await checkMilestoneEdit("<h2>{{@model.title}}</h2>");
+		assert.deepEqual(renderedCards, [], "the check renders nothing itself once the render job has");
+		assert.deepEqual(result.errors, [], "no errors are reported");
+		assert.deepEqual(result.warnings, [], "the instance was rendered again, so it was checked");
+		assert.true(result.correct, "the edit passes");
+	});
+	(0, import_qunit.test)("checks an instance whose name holds a dot", async function(assert) {
+		mountPrerenderEndpoints();
+		await testRealm.write("Milestone/v1.2.json", JSON.stringify(milestoneDocument("Version 1.2")));
+		announceRendersWithIndexEvents();
+		let result = await checkMilestoneEdit("<h1>{{@model.title}}</h1><p>{{isoDay @model.date}}</p>");
+		assert.false(result.correct, "the broken render fails the check");
+		assert.ok(result.errors.some((error) => error.startsWith(`${testRealmURL}Milestone/v1.2: `)), `the instance named with a dot is checked: ${result.errors.join("; ")}`);
+	});
+	(0, import_qunit.test)("reads an instance's document without fetching its source", async function(assert) {
+		mountPrerenderEndpoints();
+		let renders = announceRendersWithIndexEvents();
+		let announcedBefore = renders.announced;
+		let cardURL = `${testRealmURL}Milestone/launch`;
+		let reads = {
+			source: 0,
+			document: 0
+		};
+		let result = await checkMilestoneEdit("<h2>{{@model.title}}</h2>", async () => {
+			await waitUntil(() => renders.announced > announcedBefore, { timeout: 1e4 });
+			getService("network").virtualNetwork.mount(async (request) => {
+				let accept = request.headers.get("Accept") ?? "";
+				if (request.url === `${cardURL}.json` && accept.includes("source")) reads.source++;
+				else if (request.url === cardURL && accept.includes("card+json")) reads.document++;
+				return null;
+			}, { prepend: true });
+		});
+		assert.true(result.correct, "the edit passes");
+		assert.strictEqual(reads.source, 0, "the instance's source is not read");
+		assert.ok(reads.document >= 1, "the instance's document is read");
+		assert.ok(reads.document <= 2, `the instance's document is read at most twice (${reads.document})`);
+	});
+	(0, import_qunit.test)("renders an instance itself when the render job has not reached it", async function(assert) {
+		getService("tool-service").__setWaitsForTesting({ renderJobWaitMs: 100 });
+		let renderedCards = mountPrerenderEndpoints();
+		let cardURL = `${testRealmURL}Milestone/launch`;
+		let result = await checkMilestoneEdit("<h1>{{@model.title}}</h1><p>{{isoDay @model.date}}</p>", async () => serveUnrenderedInstances(`${testRealmURL}Milestone/`));
+		assert.deepEqual(renderedCards, [`${cardURL}.json`], "the check renders the instance");
+		assert.false(result.correct, "the broken render fails the check");
+		assert.strictEqual(result.errors.length, 1, "one error");
+		assert.ok(result.errors[0].startsWith(`${cardURL}: `), `the error names the instance: ${result.errors[0]}`);
+		assert.ok(result.errors[0].includes("Invalid time value"), "the error carries the render error message");
+		assert.deepEqual(result.warnings, [], "the instance was checked");
+	});
+	(0, import_qunit.test)("renders at most three instances itself and says the rest were not checked", async function(assert) {
+		getService("tool-service").__setWaitsForTesting({ renderJobWaitMs: 100 });
+		let renderedCards = mountPrerenderEndpoints();
+		let files = /* @__PURE__ */ new Map();
+		for (let name of "abcd") files.set(`Milestone/${name}.json`, JSON.stringify(milestoneDocument(`Milestone ${name}`)));
+		await testRealm.writeMany(files);
+		let result = await checkMilestoneEdit("<h1>{{@model.title}}</h1><p>{{isoDay @model.date}}</p>", async () => serveUnrenderedInstances(`${testRealmURL}Milestone/`));
+		assert.strictEqual(renderedCards.length, 3, "three instances are rendered");
+		assert.strictEqual(result.errors.length, 3, "each rendered one fails");
+		assert.strictEqual(result.warnings.length, 2, "the two it did not render are named");
+		for (let warning of result.warnings) assert.ok(warning.endsWith(": not checked, because the indexer had not rendered it with the edited module yet, and a check renders at most 3 instances itself"), warning);
+		assert.false(result.correct, "the check fails");
+	});
+	(0, import_qunit.test)("says an instance whose render request fails was not checked", async function(assert) {
+		getService("tool-service").__setWaitsForTesting({ renderJobWaitMs: 100 });
+		mountPrerenderEndpoints();
+		let realmServerURL = getService("realm-server").url;
+		getService("network").virtualNetwork.mount(async (request) => new URL(request.url).origin === realmServerURL.origin && new URL(request.url).pathname === "/_prerender-card" ? new Response("{}", { status: 500 }) : null, { prepend: true });
+		let result = await checkMilestoneEdit("<h1>{{@model.title}}</h1><p>{{isoDay @model.date}}</p>", async () => serveUnrenderedInstances(`${testRealmURL}Milestone/`));
+		assert.deepEqual(result.errors, [], "the failed render is not an error");
+		assert.deepEqual(result.warnings, [`${testRealmURL}Milestone/launch: not checked, because rendering it failed`], "the instance is named as not checked");
+		assert.true(result.correct, "the check passes");
+	});
+	(0, import_qunit.test)("does not check an instance deleted after the module write", async function(assert) {
+		mountPrerenderEndpoints();
+		announceRendersWithIndexEvents();
+		let result = await checkMilestoneEdit("<h1>{{@model.title}}</h1><p>{{isoDay @model.date}}</p>", async () => {
+			await testRealm.delete("Milestone/launch.json");
+		});
+		assert.deepEqual(result.errors, [], "no errors are reported");
+		assert.deepEqual(result.warnings, [], "the check does not wait on the deleted instance");
+		assert.true(result.correct, "the edit passes");
+	});
+	(0, import_qunit.test)("passes a module edit with no instances", async function(assert) {
+		let toolService = getService("tool-service");
+		mountPrerenderEndpoints();
+		announceRendersWithIndexEvents();
+		let roomId = "!room:example.com";
+		await new RunRealmCodeTool(toolService.toolContext).execute({
+			realm: testRealmURL,
+			roomId,
+			code: writeTextScript("listing.gts", milestoneModule("<h1>{{@model.title}}</h1>").replace(/Milestone/g, "Listing"))
+		});
+		let result = await new CheckCorrectnessTool(toolService.toolContext).execute({
+			targetType: "file",
+			targetRef: `${testRealmURL}listing.gts`,
+			roomId
+		});
+		assert.deepEqual(result.errors, [], "no errors are reported");
+		assert.deepEqual(result.warnings, [], "no warnings are reported");
+		assert.true(result.correct, "the module passes");
+	});
+	(0, import_qunit.test)("checks the instances open in the workspace first", async function(assert) {
+		mountPrerenderEndpoints();
+		announceRendersWithIndexEvents();
+		let files = /* @__PURE__ */ new Map();
+		for (let name of "abcdefghij") files.set(`Milestone/${name}.json`, JSON.stringify(milestoneDocument("2026-11-08")));
+		files.set("Milestone/z-open.json", JSON.stringify(milestoneDocument("Open milestone")));
+		await testRealm.writeMany(files);
+		let openCardId = `${testRealmURL}Milestone/z-open`;
+		getService("operator-mode-state-service").restore({ stacks: [[{
+			id: openCardId,
+			format: "isolated"
+		}]] });
+		let result = await checkMilestoneEdit("<h1>{{isoDay @model.title}}</h1>");
+		assert.false(result.correct, "the open instance fails the check");
+		assert.deepEqual(result.errors.map((error) => error.split(": ")[0]), [openCardId], "the open instance is checked and is the only one that fails");
+	});
+	(0, import_qunit.test)("reports errors in the order the instances are ranked", async function(assert) {
+		mountPrerenderEndpoints();
+		let openCardURL = `${testRealmURL}Milestone/z-open`;
+		await testRealm.write("Milestone/z-open.json", JSON.stringify(milestoneDocument("Open milestone")));
+		let renders = announceRendersWithIndexEvents();
+		let announcedBefore = renders.announced;
+		getService("operator-mode-state-service").restore({ stacks: [[{
+			id: openCardURL,
+			format: "isolated"
+		}]] });
+		let laterGeneration = 1e6;
+		let renderedLater = false;
+		let document = () => ({
+			data: {
+				type: "card",
+				id: openCardURL,
+				attributes: {},
+				meta: {
+					adoptsFrom: {
+						module: "../milestone",
+						name: "Milestone"
+					},
+					generation: laterGeneration
+				}
+			},
+			...renderedLater ? { meta: { renderError: {
+				status: 500,
+				message: "Invalid time value"
+			} } } : {}
+		});
+		let result = await checkMilestoneEdit("<h1>{{@model.title}}</h1><p>{{isoDay @model.date}}</p>", async () => {
+			await waitUntil(() => renders.announced > announcedBefore, { timeout: 1e4 });
+			getService("network").virtualNetwork.mount(async (request) => {
+				if (request.url !== openCardURL || !request.headers.get("Accept")?.includes("card+json")) return null;
+				let response = new Response(JSON.stringify(document()), { headers: { "content-type": "application/vnd.card+json" } });
+				if (!renderedLater) setTimeout(() => {
+					renderedLater = true;
+					getService("message-service").relayRealmEvent({
+						eventName: "prerender_html",
+						invalidations: [`${openCardURL}.json`],
+						generation: laterGeneration,
+						realmURL: testRealmURL
+					});
+				}, 100);
+				return response;
+			}, { prepend: true });
+		});
+		assert.deepEqual(result.errors.map((error) => error.split(": ")[0]), [openCardURL, `${testRealmURL}Milestone/launch`], "the open instance is reported first");
+	});
+	(0, import_qunit.test)("does not report an instance whose document cannot be read", async function(assert) {
+		mountPrerenderEndpoints();
+		let renders = announceRendersWithIndexEvents();
+		let announcedBefore = renders.announced;
+		let cardURL = `${testRealmURL}Milestone/launch`;
+		let result = await checkMilestoneEdit("<h1>{{@model.title}}</h1><p>{{isoDay @model.date}}</p>", async () => {
+			await waitUntil(() => renders.announced > announcedBefore, { timeout: 1e4 });
+			getService("network").virtualNetwork.mount(async (request) => request.url === cardURL && request.headers.get("Accept")?.includes("card+json") ? new Response("{}", { status: 500 }) : null, { prepend: true });
+		});
+		assert.deepEqual(result.errors, [], "the failed read is not an error");
+		assert.true(result.correct, "the check passes");
+	});
+	(0, import_qunit.test)("waits for the render of an instance indexed again after the module write", async function(assert) {
+		mountPrerenderEndpoints();
+		let renders = announceRendersWithIndexEvents();
+		let announcedBefore = renders.announced;
+		let cardURL = `${testRealmURL}Milestone/launch`;
+		let laterGeneration = 1e6;
+		let renderedLater = false;
+		let document = () => ({
+			data: {
+				type: "card",
+				id: cardURL,
+				attributes: {},
+				meta: {
+					adoptsFrom: {
+						module: "../milestone",
+						name: "Milestone"
+					},
+					generation: laterGeneration
+				}
+			},
+			...renderedLater ? { meta: { renderError: {
+				status: 500,
+				message: "Invalid time value"
+			} } } : {}
+		});
+		let result = await checkMilestoneEdit("<h2>{{@model.title}}</h2>", async () => {
+			await waitUntil(() => renders.announced > announcedBefore, { timeout: 1e4 });
+			getService("network").virtualNetwork.mount(async (request) => {
+				if (request.url !== cardURL || !request.headers.get("Accept")?.includes("card+json")) return null;
+				let response = new Response(JSON.stringify(document()), { headers: { "content-type": "application/vnd.card+json" } });
+				if (!renderedLater) setTimeout(() => {
+					renderedLater = true;
+					getService("message-service").relayRealmEvent({
+						eventName: "prerender_html",
+						invalidations: [`${cardURL}.json`],
+						generation: laterGeneration,
+						realmURL: testRealmURL
+					});
+				}, 100);
+				return response;
+			}, { prepend: true });
+		});
+		assert.deepEqual(result.errors, [`${cardURL}: Invalid time value (an instance of the edited module; the cause may be the edit or this card's own data)`], "the error from the later render is reported");
+		assert.false(result.correct, "the check fails");
+	});
+	(0, import_qunit.test)("a render wait counts only renders at or past each file's generation", async function(assert) {
+		let toolService = getService("tool-service");
+		let messageService = getService("message-service");
+		toolService.trackAiAssistantCardRequest({
+			action: "test",
+			roomId: "!room:example.com",
+			fileUrl: `${testRealmURL}milestone.gts`
+		});
+		let a = `${testRealmURL}Milestone/a.json`;
+		let b = `${testRealmURL}Milestone/b.json`;
+		let announce = (generation, invalidations) => messageService.relayRealmEvent({
+			eventName: "prerender_html",
+			invalidations,
+			generation,
+			realmURL: testRealmURL
+		});
+		let wait = async (files, timeoutMs) => [...await toolService.waitForRenderedHTML(testRealmURL, new Map(files), timeoutMs)];
+		announce(4, [a]);
+		assert.deepEqual(await wait([[a, 5]], 50), [], "a render below the file's generation does not count");
+		announce(5, [a]);
+		let start = Date.now();
+		assert.deepEqual(await wait([[a, 5]], 1e4), [a], "a render at the file's generation counts");
+		assert.ok(Date.now() - start < 1e3, "a wait already satisfied returns at once");
+		assert.deepEqual(await wait([[a, 5], [b, 5]], 50), [a], "a wait that times out returns the files rendered so far");
+		let waiting = wait([[b, 6]], 1e4);
+		announce(6, [b]);
+		assert.deepEqual(await waiting, [b], "a render announced during the wait ends it");
+	});
+	(0, import_qunit.test)("a realm's render watch ends once its module write's time is up and no wait holds it", async function(assert) {
+		let toolService = getService("tool-service");
+		let messageService = getService("message-service");
+		toolService.__setWaitsForTesting({ renderedHTMLWatchMs: 50 });
+		let a = `${testRealmURL}Milestone/a.json`;
+		let trackModuleWrite = () => toolService.trackAiAssistantCardRequest({
+			action: "test",
+			roomId: "!room:example.com",
+			fileUrl: `${testRealmURL}milestone.gts`
+		});
+		let announce = () => messageService.relayRealmEvent({
+			eventName: "prerender_html",
+			invalidations: [a],
+			generation: 1,
+			realmURL: testRealmURL
+		});
+		let wait = async () => [...await toolService.waitForRenderedHTML(testRealmURL, new Map([[a, 1]]), 1e4)];
+		trackModuleWrite();
+		await delay(150);
+		announce();
+		assert.deepEqual(await wait(), [], "a render announced after the write's time is up is not recorded");
+		trackModuleWrite();
+		let waiting = wait();
+		await delay(150);
+		announce();
+		assert.deepEqual(await waiting, [a], "a wait under way keeps the watch past the write's time");
+		assert.deepEqual(await wait(), [], "the watch ends with the last wait on it");
+	});
+	(0, import_qunit.test)("a wait that a newer write to its target replaces leaves the newer write tracked", async function(assert) {
+		let toolService = getService("tool-service");
+		let roomId = "!room:example.com";
+		let fileUrl = `${testRealmURL}milestone.gts`;
+		toolService.trackAiAssistantCardRequest({
+			action: "test",
+			roomId,
+			fileUrl
+		});
+		let first = toolService.waitForInvalidationAfterAIAssistantRequest(roomId, fileUrl, 1e4);
+		let clientRequestId = toolService.trackAiAssistantCardRequest({
+			action: "test",
+			roomId,
+			fileUrl
+		});
+		assert.strictEqual(await first, void 0, "the replaced wait ends without an index event");
+		let second = toolService.waitForInvalidationAfterAIAssistantRequest(roomId, fileUrl, 1e4);
+		getService("message-service").relayRealmEvent({
+			eventName: "index",
+			indexType: "incremental",
+			invalidations: [],
+			generation: 7,
+			clientRequestId,
+			realmURL: testRealmURL
+		});
+		assert.deepEqual(await second, {
+			invalidations: [],
+			generation: 7
+		}, "the newer write's wait gets its index event");
+	});
+	(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