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

package/bundled-test-harness/assets/prerender-module-test-DpTYAbmI.js

@@ -0,0 +1,409 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
+import { T as rri } from "./paths-C9-NYXnM.js";
+import { Q as trimExecutableExtension, it as baseRealmRRI } from "./constants-Icc0nFW-.js";
+import { k as visit } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, I as setupOnSave, L as setupRealmCacheTeardown, Z as withCachedRealmSetup, a as SYSTEM_CARD_FIXTURE_CONTENTS, c as captureModuleResult, ct as setupApplicationTest, h as createPrerenderAuth, j as setupAcceptanceTestRealm, jt as shimTestModule, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/acceptance/prerender-module-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Acceptance | prerender | module", function(hooks) {
+	setupApplicationTest(hooks);
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	setupRealmCacheTeardown(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, { loggedInAs: "@testuser:localhost" });
+	let adapter;
+	let realm;
+	const DEFAULT_MODULE_OPTIONS_SEGMENT = encodeURIComponent(JSON.stringify({}));
+	const modulePath = (url, nonce = 0, optionsSegment = DEFAULT_MODULE_OPTIONS_SEGMENT) => `/module/${encodeURIComponent(url)}/${nonce}/${optionsSegment}`;
+	const PERSON_MODULE = `
+    import { CardDef, field, contains, StringField } from '@cardstack/base/card-api';
+
+    export class Person extends CardDef {
+      static displayName = 'Person';
+      @field name = contains(StringField);
+    }
+  `;
+	const PARENT_MODULE = `
+    import { CardDef, field, contains, StringField } from '@cardstack/base/card-api';
+
+    export class Parent extends CardDef {
+      static displayName = 'Parent';
+      @field cardTitle = contains(StringField);
+    }
+  `;
+	const CHILD_MODULE = `
+    import { Parent } from './parent';
+    import { field, contains, StringField } from '@cardstack/base/card-api';
+
+    export class Child extends Parent {
+      static displayName = 'Child';
+      @field nickname = contains(StringField);
+    }
+  `;
+	const BROKEN_MODULE = `export const Broken = ;`;
+	const SEARCHABLE_MODULE = `
+    import { CardDef, field, contains, linksTo, StringField } from '@cardstack/base/card-api';
+
+    export class SearchAuthor extends CardDef {
+      static displayName = 'SearchAuthor';
+      @field name = contains(StringField);
+    }
+
+    export class SearchArticle extends CardDef {
+      static displayName = 'SearchArticle';
+      @field title = contains(StringField);
+      @field author = linksTo(() => SearchAuthor, { searchable: 'name' });
+      @field reviewer = linksTo(() => SearchAuthor, { searchable: 'bogus' });
+    }
+  `;
+	const FAMILIES_MODULE = `
+    import { CardDef, FieldDef, field, contains, StringField } from '@cardstack/base/card-api';
+    import { FileDef } from '@cardstack/base/file-api';
+
+    export class Caption extends FieldDef {
+      static displayName = 'Caption';
+      @field text = contains(StringField);
+    }
+
+    export class Photo extends CardDef {
+      static displayName = 'Photo';
+      @field caption = contains(Caption);
+    }
+
+    export class PhotoFile extends FileDef {
+      static displayName = 'PhotoFile';
+    }
+
+    export class PlainFile extends FileDef {}
+  `;
+	const OPERATIONS_MODULE = `
+    import { CardDef, field, contains, containsMany, StringField } from '@cardstack/base/card-api';
+    import { FileDef } from '@cardstack/base/file-api';
+    import { operation, params, realmConfig } from '@cardstack/base/operations';
+
+    export class Note extends CardDef {
+      static displayName = 'Note';
+      @field body = contains(StringField);
+      @field tags = containsMany(StringField);
+
+      @operation static addTag = {
+        base: 'transform',
+        label: 'Tag this note',
+        params: { tag: StringField },
+        append: { to: 'tags', value: params('tag') },
+      };
+
+      @operation static addNote = {
+        base: 'transform',
+        params: { text: StringField },
+        set: { bdy: params('text') },
+      };
+
+      @operation static logTag = {
+        base: 'appendContainsMany',
+        params: { tag: StringField },
+        field: 'tags',
+        item: params('tag'),
+      };
+    }
+
+    export class NoteLog extends FileDef {
+      static displayName = 'NoteLog';
+
+      @operation static record = {
+        base: 'appendLine',
+        label: 'Add a line to the log',
+        params: { line: StringField },
+      };
+
+      @operation static readRedacted = {
+        base: 'read',
+        output: { name: true, at: realmConfig('timezone') },
+      };
+    }
+  `;
+	hooks.beforeEach(async function() {
+		({adapter, realm} = await withCachedRealmSetup(async () => setupAcceptanceTestRealm({
+			mockMatrixUtils,
+			contents: {
+				...SYSTEM_CARD_FIXTURE_CONTENTS,
+				"person.gts": PERSON_MODULE,
+				"parent.gts": PARENT_MODULE,
+				"child.gts": CHILD_MODULE,
+				"broken.gts": BROKEN_MODULE,
+				"searchable-card.gts": SEARCHABLE_MODULE,
+				"note.gts": OPERATIONS_MODULE,
+				"families.gts": FAMILIES_MODULE
+			}
+		})));
+	});
+	(0, import_qunit.test)("captures module metadata when module loads successfully", async function(assert) {
+		let moduleURL = `${testRealmURL}person.gts`;
+		await visit(modulePath(moduleURL));
+		let { status, model } = captureModuleResult();
+		assert.strictEqual(status, "ready", "route reports ready status");
+		assert.strictEqual(model.id, moduleURL, "returns module id");
+		assert.false(model.isShimmed, "module is not marked shimmed");
+		assert.ok(model.lastModified > 0, "lastModified recorded");
+		assert.ok(model.createdAt > 0, "createdAt recorded");
+		let personKey = `${trimExecutableExtension(rri(moduleURL))}/Person`;
+		assert.ok(personKey in model.definitions, "includes person definition");
+		let personEntry = model.definitions[personKey];
+		assert.strictEqual(personEntry.type, "definition", "person definition entry");
+		assert.strictEqual(personEntry.definition.type, "card-def", "captures definition details");
+		assert.strictEqual(personEntry.moduleURL, trimExecutableExtension(rri(moduleURL)), "moduleURL exposes trimmed module path");
+		assert.ok(personEntry.types.includes(personKey), "types include the card itself");
+		assert.ok(personEntry.types.includes(`${baseRealmRRI}card-api/CardDef`), "types include base card");
+	});
+	(0, import_qunit.test)("renders a base-realm module named by prefix and reports the same id", async function(assert) {
+		let moduleId = `${baseRealmRRI}card-api`;
+		await visit(modulePath(moduleId));
+		let { status, model } = captureModuleResult();
+		assert.strictEqual(status, "ready", "route reports ready status");
+		assert.strictEqual(model.id, moduleId, "returns the prefix-form id unchanged");
+	});
+	(0, import_qunit.test)("classifies each of the three BaseDef families", async function(assert) {
+		let moduleURL = `${testRealmURL}families.gts`;
+		await visit(modulePath(moduleURL));
+		let { model } = captureModuleResult();
+		let moduleAlias = trimExecutableExtension(rri(moduleURL));
+		let definitionFor = (name) => {
+			let entry = model.definitions[`${moduleAlias}/${name}`];
+			assert.strictEqual(entry?.type, "definition", `${name} has a definition`);
+			return entry?.type === "definition" ? entry.definition : void 0;
+		};
+		let photo = definitionFor("Photo");
+		let caption = definitionFor("Caption");
+		let photoFile = definitionFor("PhotoFile");
+		assert.strictEqual(photo?.type, "card-def", "a card def is a card def");
+		assert.strictEqual(caption?.type, "field-def", "a field def is a field def");
+		assert.strictEqual(photoFile?.type, "file-def", "a file def is a file def");
+		assert.strictEqual(photo?.displayName, "Photo", "a card's display name");
+		assert.strictEqual(photoFile?.displayName, "PhotoFile", "a file's display name");
+		assert.strictEqual(caption?.displayName, null, "the entry for a field def records none");
+		assert.strictEqual(definitionFor("PlainFile")?.displayName, "File", "an undeclared file def's inherited display name");
+		assert.ok("contentType" in (photoFile?.fields ?? {}), "a file def's fields are captured");
+		let typesFor = (name) => {
+			let entry = model.definitions[`${moduleAlias}/${name}`];
+			return entry?.type === "definition" ? entry.types : [];
+		};
+		assert.ok(typesFor("Photo").includes(`${baseRealmRRI}card-api/CardDef`), "a card's ancestry reaches CardDef");
+		assert.ok(typesFor("PhotoFile").includes(`${moduleAlias}/PhotoFile`), "a file's ancestry includes itself");
+		assert.ok(typesFor("PhotoFile").includes(`${baseRealmRRI}card-api/FileDef`), "a file's ancestry reaches FileDef");
+		assert.notOk(typesFor("PhotoFile").includes(`${baseRealmRRI}card-api/CardDef`), "a file's ancestry stops at its own family root");
+		assert.deepEqual(typesFor("Caption"), [], "a field def records no ancestry");
+	});
+	(0, import_qunit.test)("surface a top-level error when module import fails", async function(assert) {
+		await visit(modulePath(`${testRealmURL}missing.gts`));
+		let { status, model } = captureModuleResult();
+		assert.strictEqual(status, "error", "capture reports error status");
+		assert.strictEqual(model.status, "error", "model status is error");
+		assert.ok(model.error, "model contains error entry");
+		assert.strictEqual(model.error.error.status, 404, "error status is correct");
+	});
+	(0, import_qunit.test)("surface a compile error when module has syntax error", async function(assert) {
+		await visit(modulePath(`${testRealmURL}broken.gts`));
+		let { status, model } = captureModuleResult();
+		assert.strictEqual(status, "error", "capture reports error status");
+		assert.strictEqual(model.status, "error", "model status is error");
+		assert.ok(model.error, "model contains error entry");
+		assert.strictEqual(model.error.error.status, 406, "compile error surfaces as 406");
+		assert.strictEqual(model.error.error.message, `Parse Error at broken.gts:1:23: 1:24 (${testRealmURL}broken.gts)`, "message includes enough information for AI to fix the problem");
+		assert.ok(model.error.error.stack?.includes("at transpileJS"), `stack should include "at transpileJS" but was ${model.error.error.stack}`);
+		assert.strictEqual(model.error.error.additionalErrors, null, "error is primary and not nested in additionalErrors");
+		assert.strictEqual(Object.keys(model.definitions).length, 0, "no definitions produced when module fails to compile");
+	});
+	(0, import_qunit.test)("identifies shimmed modules", async function(assert) {
+		let loader = getService("loader-service").loader;
+		let cardApi;
+		cardApi = await loader.import("@cardstack/base/card-api");
+		let { field, contains, CardDef, StringField } = cardApi;
+		class Shimmed extends CardDef {
+			static displayName = "Shimmed";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		let shimURL = `${testRealmURL}shimmed.gts`;
+		shimTestModule(loader, shimURL, { Shimmed });
+		await visit(modulePath(shimURL));
+		let { status, model } = captureModuleResult();
+		assert.strictEqual(status, "ready", "shimmed module still resolves");
+		assert.true(model.isShimmed, "module flagged as shimmed");
+		assert.strictEqual(model.lastModified, 0, "shimmed module lastModified zeroed");
+		assert.strictEqual(model.createdAt, 0, "shimmed module createdAt zeroed");
+		assert.deepEqual(model.deps, [trimExecutableExtension(rri(shimURL))], "deps limited to shimmed file");
+		let shimKey = `${trimExecutableExtension(rri(shimURL))}/Shimmed`;
+		let shimEntry = model.definitions[shimKey];
+		assert.ok(shimEntry, "definition generated for shimmed export");
+		assert.strictEqual(shimEntry.type, "definition", "shim definition entry");
+		assert.strictEqual(shimEntry.moduleURL, trimExecutableExtension(rri(shimURL)), "moduleURL always omits executable extension");
+	});
+	(0, import_qunit.test)("card prerenderer can prerender modules", async function(assert) {
+		let moduleURL = `${testRealmURL}person.gts`;
+		let prerenderer = getService("local-indexer").prerenderer;
+		let auth = createPrerenderAuth("@testuser:localhost", { [testRealmURL]: [
+			"read",
+			"write",
+			"realm-owner"
+		] });
+		let response = await prerenderer.prerenderModule({
+			affinityType: "realm",
+			affinityValue: testRealmURL,
+			realm: testRealmURL,
+			url: moduleURL,
+			auth
+		});
+		assert.strictEqual(response.status, "ready", "module prerender reports ready");
+		assert.strictEqual(response.id, moduleURL, "module id echoed back");
+		let key = `${trimExecutableExtension(rri(moduleURL))}/Person`;
+		assert.ok(response.definitions[key], "definition captured");
+		assert.strictEqual(response.definitions[key]?.type, "definition", "definition entry returned");
+	});
+	(0, import_qunit.test)("card prerenderer surfaces module errors", async function(assert) {
+		let moduleURL = `${testRealmURL}broken.gts`;
+		let prerenderer = getService("local-indexer").prerenderer;
+		let auth = createPrerenderAuth("@testuser:localhost", { [testRealmURL]: [
+			"read",
+			"write",
+			"realm-owner"
+		] });
+		let response = await prerenderer.prerenderModule({
+			affinityType: "realm",
+			affinityValue: testRealmURL,
+			realm: testRealmURL,
+			url: moduleURL,
+			auth
+		});
+		assert.strictEqual(response.status, "error", "module prerender reports error");
+		assert.ok(response.error, "error payload present");
+		assert.strictEqual(response.error?.error.status, 406, "compile error status surfaced");
+	});
+	(0, import_qunit.test)("module prerender captures updated definitions after clear cache", async function(assert) {
+		let moduleURL = `${testRealmURL}person.gts`;
+		await visit(modulePath(moduleURL));
+		let initial = captureModuleResult();
+		let definitionKey = `${trimExecutableExtension(rri(moduleURL))}/Person`;
+		let initialEntry = initial.model.definitions[definitionKey];
+		assert.ok(initialEntry, "initial definition exists");
+		assert.strictEqual(initialEntry?.type, "definition", "initial definition entry present");
+		assert.strictEqual(initialEntry?.type === "definition" ? initialEntry.definition.displayName : void 0, "Person", "initial display name recorded");
+		await adapter.write("person.gts", `
+      import { CardDef, field, contains, StringField } from '@cardstack/base/card-api';
+
+      export class Person extends CardDef {
+        static displayName = 'Updated Person';
+        @field name = contains(StringField);
+      }
+    `);
+		realm.__testOnlyClearCaches();
+		await visit(modulePath(moduleURL));
+		let cachedEntry = captureModuleResult().model.definitions[definitionKey];
+		assert.ok(cachedEntry, "cached definition exists");
+		assert.strictEqual(cachedEntry?.type, "definition", "cached definition entry present");
+		assert.strictEqual(cachedEntry?.type === "definition" ? cachedEntry.definition.displayName : void 0, "Person", "cache retains original display name without clearCache flag");
+		await visit(modulePath(moduleURL, 1, encodeURIComponent(JSON.stringify({ clearCache: true }))));
+		let updatedEntry = captureModuleResult().model.definitions[definitionKey];
+		assert.ok(updatedEntry, "updated definition exists");
+		assert.strictEqual(updatedEntry?.type, "definition", "updated definition entry present");
+		assert.strictEqual(updatedEntry?.type === "definition" ? updatedEntry.definition.displayName : void 0, "Updated Person", "updated display name observed after clearCache flag");
+	});
+	(0, import_qunit.test)("records unresolvable searchable paths on meta.diagnostics, tagged with the owning def", async function(assert) {
+		let moduleURL = `${testRealmURL}searchable-card.gts`;
+		await visit(modulePath(moduleURL));
+		let { status, model } = captureModuleResult();
+		assert.strictEqual(status, "ready", "module loads");
+		let articleKey = `${trimExecutableExtension(rri(moduleURL))}/SearchArticle`;
+		assert.deepEqual(model.meta?.diagnostics?.searchablePathIssues, [{
+			codeRef: articleKey,
+			fieldName: "reviewer",
+			path: "bogus"
+		}], "only the unresolvable path is recorded, tagged with its owning def — the resolvable author→name path is not");
+	});
+	(0, import_qunit.test)("a module with no searchable annotations produces no diagnostics meta (inert)", async function(assert) {
+		await visit(modulePath(`${testRealmURL}person.gts`));
+		let { model } = captureModuleResult();
+		assert.strictEqual(model.meta?.diagnostics?.searchablePathIssues, void 0, "no searchablePathIssues meta when nothing is annotated");
+	});
+	(0, import_qunit.test)("captures lowered @operation declarations onto the definition entry", async function(assert) {
+		let moduleURL = `${testRealmURL}note.gts`;
+		await visit(modulePath(moduleURL));
+		let { status, model } = captureModuleResult();
+		assert.strictEqual(status, "ready", "module loads");
+		let noteKey = `${trimExecutableExtension(rri(moduleURL))}/Note`;
+		let entry = model.definitions[noteKey];
+		assert.strictEqual(entry?.type, "definition", "the definition was built");
+		let operations = entry?.type === "definition" ? entry.definition.operations : void 0;
+		assert.deepEqual(Object.keys(operations ?? {}).sort(), [
+			"addNote",
+			"addTag",
+			"logTag"
+		], "every declaration is captured — a declaration with findings is stored too, so invoking it reports them rather than reading as unknown");
+		assert.deepEqual(operations?.addTag.program, {
+			source: "append(.tags;params(\"tag\"));",
+			syntax: "solidified"
+		}, "the convenience clause reaches the entry as canonical BXL");
+		assert.true(operations?.addNote.invalid, "the bad declaration is flagged");
+		assert.strictEqual(operations?.addTag.label, "Tag this note", "the label reaches the entry as data");
+		assert.false("label" in (operations?.logTag ?? {}), "a declaration without one carries none");
+		assert.deepEqual(operations?.logTag.items, { tags: {
+			$ref: "params",
+			key: "tag"
+		} }, "an append to a containsMany reaches the entry as the item template it substitutes, and no program");
+	});
+	(0, import_qunit.test)("captures a file def's declarations, including the writes on its bytes", async function(assert) {
+		let moduleURL = `${testRealmURL}note.gts`;
+		await visit(modulePath(moduleURL));
+		let { model } = captureModuleResult();
+		let logKey = `${trimExecutableExtension(rri(moduleURL))}/NoteLog`;
+		let entry = model.definitions[logKey];
+		assert.strictEqual(entry?.type, "definition", "the definition was built");
+		assert.strictEqual(entry?.type === "definition" ? entry.definition.type : void 0, "file-def", "and is recorded as the family whose declarations these were checked against");
+		let operations = entry?.type === "definition" ? entry.definition.operations : void 0;
+		assert.deepEqual(Object.keys(operations ?? {}).sort(), ["readRedacted", "record"], "a file def declares the reads and the writes that work on its bytes");
+		assert.strictEqual(operations?.record.program, void 0, "an appendLine carries no program: the line is the payload");
+		assert.deepEqual(Object.keys(operations?.record.params ?? {}), ["line"], "which the schema names");
+		assert.deepEqual(operations?.readRedacted.output, {
+			source: "{name:true, at:realmConfig(\"timezone\")}",
+			syntax: "solidified"
+		}, "a realm setting lowers to the builtin of the same name");
+		assert.notOk(operations?.record.invalid, "the appendLine has no findings");
+		assert.strictEqual(operations?.record.label, "Add a line to the log", "a file def's declaration carries its label too");
+		assert.notOk(operations?.readRedacted.invalid, "and neither does the read that reads a realm setting");
+	});
+	(0, import_qunit.test)("records operation-lowering findings on meta.diagnostics, tagged with the owning def", async function(assert) {
+		let moduleURL = `${testRealmURL}note.gts`;
+		await visit(modulePath(moduleURL));
+		let { model } = captureModuleResult();
+		let noteKey = `${trimExecutableExtension(rri(moduleURL))}/Note`;
+		assert.deepEqual(model.meta?.diagnostics?.operationIssues?.map((issue) => ({
+			codeRef: issue.codeRef,
+			code: issue.code,
+			operation: issue.operation,
+			path: issue.path
+		})), [{
+			codeRef: noteKey,
+			code: "unknown-field",
+			operation: "addNote",
+			path: "set.bdy"
+		}], "only the bad clause is recorded, tagged with its owning def");
+	});
+	(0, import_qunit.test)("a module that declares no operations produces no operations key and no findings", async function(assert) {
+		let moduleURL = `${testRealmURL}person.gts`;
+		await visit(modulePath(moduleURL));
+		let { model } = captureModuleResult();
+		let personKey = `${trimExecutableExtension(rri(moduleURL))}/Person`;
+		let entry = model.definitions[personKey];
+		assert.strictEqual(entry?.type, "definition", "the definition was built");
+		assert.notOk(entry?.type === "definition" ? "operations" in entry.definition : void 0, "the definition entry for every existing card is unchanged");
+		assert.strictEqual(model.meta?.diagnostics?.operationIssues, void 0, "and no operationIssues meta is emitted");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/prerender-persistence-block-test-BhIt-7kK.js

@@ -0,0 +1,124 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Br as testRealmURL, Gr as Tool } from "./runtime-common-BTaLJEw-.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import "./template-factory-ds9s0u8l.js";
+import { k as visit, o as waitFor } from "./dist-BOAdzfkP.js";
+import { t as SaveCardTool } from "./save-card-ijP2lSOP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, I as setupOnSave, a as SYSTEM_CARD_FIXTURE_CONTENTS, ct as setupApplicationTest, j as setupAcceptanceTestRealm, l as capturePrerenderResult, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { A as field, a as CardDef, s as Component, w as contains } from "./card-api-Cc8uZunB.js";
+import { t as string_default } from "./string-5IAMEUit.js";
+//#region tests/acceptance/prerender-persistence-block-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Acceptance | prerender | persistence block", function(hooks) {
+	setupApplicationTest(hooks);
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, { loggedInAs: "@testuser:localhost" });
+	const RENDER_OPTIONS_SEGMENT = encodeURIComponent(JSON.stringify({ clearCache: true }));
+	async function renderCard(id) {
+		await visit(`/render/${encodeURIComponent(`${id}.json`)}/0/${RENDER_OPTIONS_SEGMENT}/html/isolated/0`);
+		return await capturePrerenderResult("textContent");
+	}
+	function runCommand(requestId, nonce, command) {
+		window.localStorage.setItem(`boxel-command-request:${requestId}`, JSON.stringify({
+			command,
+			input: null,
+			nonce,
+			createdAt: Date.now()
+		}));
+		return visit(`/command-runner/${requestId}/${nonce}`);
+	}
+	function raisePersistenceBlock() {
+		globalThis.__boxelPrerenderApp = true;
+	}
+	hooks.beforeEach(async function() {
+		class Pet extends CardDef {
+			static displayName = "Pet";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static isolated = class Isolated extends Component {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "KJnNso4I",
+						"block": "[[[10,\"h2\"],[14,\"data-test-pet\",\"\"],[12],[8,[30,1,[\"name\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/acceptance/prerender-persistence-block-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class SavePetResult extends CardDef {
+			static displayName = "SavePetResult";
+			static {
+				decorateFieldV2(this.prototype, "savedId", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#savedId = (initializeDeferredDecorator(this, "savedId"), void 0);
+			static isolated = class Isolated extends Component {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "m9eb1IGZ",
+						"block": "[[[10,1],[14,\"data-test-saved-pet-id\",\"\"],[12],[8,[30,1,[\"savedId\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/acceptance/prerender-persistence-block-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class SavePetCommand extends Tool {
+			static displayName = "SavePetCommand";
+			async getInputType() {}
+			async run() {
+				return new SavePetResult({ savedId: (await new SaveCardTool(this.toolContext).execute({
+					card: new Pet({ name: "Ringo" }),
+					realm: testRealmURL
+				}))?.id ?? "" });
+			}
+		}
+		await setupAcceptanceTestRealm({
+			mockMatrixUtils,
+			contents: {
+				...SYSTEM_CARD_FIXTURE_CONTENTS,
+				"pet.gts": { Pet },
+				"Pet/mango.json": new Pet({ name: "Mango" }),
+				"save-pet-command.gts": {
+					SavePetResult,
+					default: SavePetCommand
+				}
+			}
+		});
+	});
+	hooks.afterEach(function() {
+		delete globalThis.__boxelPrerenderApp;
+	});
+	(0, import_qunit.test)("entering the command route drops the block", async function(assert) {
+		raisePersistenceBlock();
+		await runCommand("prerender-persistence-block-drop", "1", `${testRealmURL}save-pet-command/default`);
+		assert.strictEqual(globalThis.__boxelPrerenderApp, void 0, "the command route drops the persistence block on entry");
+	});
+	(0, import_qunit.test)("a command saves a durable card on a tab that has served a card render", async function(assert) {
+		raisePersistenceBlock();
+		let { value } = await renderCard(`${testRealmURL}Pet/mango`);
+		assert.true(value.includes("Mango"), "the card rendered");
+		await runCommand("prerender-persistence-block-save", "1", `${testRealmURL}save-pet-command/default`);
+		await waitFor("[data-prerender][data-prerender-status=\"ready\"]");
+		let savedId = document.querySelector("[data-test-saved-pet-id]")?.textContent?.trim() ?? "";
+		assert.ok(savedId.startsWith(testRealmURL), `the save came back with a realm id: ${savedId || "<empty>"}`);
+		if (savedId) {
+			let source = await getService("card-service").getSource(new URL(`${savedId}.json`));
+			assert.strictEqual(source.status, 200, "the saved card is durable");
+			assert.true(source.content.includes("Ringo"), "the durable document holds what the command wrote");
+		}
+	});
+});
+//#endregion

package/bundled-test-harness/assets/prerender-pre-model-error-test-DxKPQKqx.js

@@ -0,0 +1,61 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL, I as serializeRenderRouteOptions } from "./runtime-common-BTaLJEw-.js";
+import { M as waitUntil, O as setupOnerror, k as visit, w as resetOnerror } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { ct as setupApplicationTest, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+//#region tests/acceptance/prerender-pre-model-error-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Acceptance | prerender | pre-model error", function(hooks) {
+	setupApplicationTest(hooks);
+	setupMockMatrix(hooks, { loggedInAs: "@testuser:localhost" });
+	hooks.beforeEach(function() {
+		globalThis.__doNotSuppressRenderRouteError = true;
+		setupOnerror((error) => {
+			if (!/boom before model/.test(error?.message ?? "")) throw error;
+		});
+	});
+	hooks.afterEach(function() {
+		delete globalThis.__doNotSuppressRenderRouteError;
+		resetOnerror();
+	});
+	function readErrorPayload() {
+		let payloadText = document.querySelector("[data-prerender-error]").textContent.trim();
+		let payload = JSON.parse(payloadText);
+		return {
+			deps: payload?.error?.deps ?? [],
+			message: payload?.error?.message
+		};
+	}
+	(0, import_qunit.test)("named transition from standby page surfaces pre-model error with card deps", async function(assert) {
+		await visit("/_standby");
+		let renderRoute = this.owner.lookup("route:render");
+		let originalBeforeModel = renderRoute.beforeModel;
+		renderRoute.beforeModel = async function(...args) {
+			await originalBeforeModel.apply(this, args);
+			renderRoute.beforeModel = originalBeforeModel;
+			throw new Error("boom before model");
+		};
+		let options = serializeRenderRouteOptions({ cardRender: true });
+		let boxelTransitionTo = globalThis.boxelTransitionTo;
+		assert.strictEqual(typeof boxelTransitionTo, "function", "standby page registered boxelTransitionTo");
+		try {
+			boxelTransitionTo("render.html", `${testRealmURL}1.json`, "42", options, "isolated", "0");
+		} catch (e) {}
+		await waitUntil(() => {
+			let el = document.querySelector("[data-prerender-error]");
+			return Boolean(el?.textContent && el.textContent.trim().length > 0);
+		}, {
+			timeout: 5e3,
+			timeoutMessage: "prerender error element populated"
+		});
+		let expectedDeps = [`${testRealmURL}1.json`, `${testRealmURL}1`];
+		let { deps, message } = readErrorPayload();
+		assert.true(message?.includes("boom before model"), `error message captured (got: ${message})`);
+		assert.true(expectedDeps.some((dep) => deps.includes(dep)), `pre-model error deps name the card (deps: ${JSON.stringify(deps)})`);
+		renderRoute.errorHandler(new CustomEvent("test-unhandled-rejection", { detail: { reason: /* @__PURE__ */ new Error("boom before model") } }));
+		let overwrite = readErrorPayload();
+		assert.true(overwrite.message?.includes("boom before model"), `window-error overwrite keeps the message (got: ${overwrite.message})`);
+		assert.true(expectedDeps.some((dep) => overwrite.deps.includes(dep)), `window-error overwrite still names the card in deps (deps: ${JSON.stringify(overwrite.deps)})`);
+	});
+});
+//#endregion