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

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

@@ -1,409 +0,0 @@
-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-Dd8k0DNa.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-Da0dJO_N.js

@@ -1,124 +0,0 @@
-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-Dd8k0DNa.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-BVLyhk8R.js

@@ -1,61 +0,0 @@
-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-Dd8k0DNa.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