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

package/bundled-test-harness/assets/operations-test-BQhlrfe3.js

@@ -1,2518 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
-import { na as DEFINITION_FREE_BASE_OPERATIONS } from "./runtime-common-BTaLJEw-.js";
-import "./card-operations-CzugytHO.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { F as setupLocalIndexing, M as setupCardLogs, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-import { a as CardDef, d as FileDef, l as FieldDef, n as BaseDef } from "./card-api-Cc8uZunB.js";
-import "./file-api-BsT3Q6C9.js";
-import { t as string_default } from "./string-5IAMEUit.js";
-import { t as DateField } from "./date-DTBQL-Hc.js";
-//#region tests/integration/operations-test.ts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var loader;
-var operation;
-var getOperations;
-var getDeclaredOperations;
-var params;
-var actor;
-var instance;
-var realmConfig;
-var card;
-var bxl;
-var linkTo;
-function implied(base) {
-	return { base };
-}
-(0, import_qunit.module)("Integration | operations", function(hooks) {
-	setupRenderingTest(hooks);
-	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/card-api"));
-	setupLocalIndexing(hooks);
-	setupMockMatrix(hooks);
-	hooks.beforeEach(async function() {
-		loader = getService("loader-service").loader;
-		({operation, getOperations, getDeclaredOperations, params, actor, instance, realmConfig, card, bxl, linkTo} = await loader.import("@cardstack/base/operations"));
-	});
-	(0, import_qunit.test)("getOperations merges declarations up the prototype chain, subclass winning per name", function(assert) {
-		class Report extends CardDef {
-			static {
-				decorateFieldV2(this, "addComment", [operation], function() {
-					return {
-						base: "transform",
-						params: { body: string_default },
-						append: {
-							to: "comments",
-							value: {
-								body: params("body"),
-								postedBy: actor()
-							}
-						}
-					};
-				});
-			}
-			#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
-			static {
-				decorateFieldV2(this, "escalate", [operation], function() {
-					return {
-						base: "transform",
-						transformations: bxl`.status = "escalated";`
-					};
-				});
-			}
-			#escalate = (initializeDeferredDecorator(this, "escalate"), void 0);
-		}
-		class ExternalReport extends Report {
-			static {
-				decorateFieldV2(this, "escalate", [operation], function() {
-					return {
-						base: "transform",
-						params: { reason: string_default },
-						set: {
-							status: "escalated",
-							escalationReason: params("reason")
-						}
-					};
-				});
-			}
-			#escalate = (initializeDeferredDecorator(this, "escalate"), void 0);
-			static {
-				decorateFieldV2(this, "listMine", [operation], function() {
-					return {
-						base: "query",
-						query: { filter: {
-							on: () => ExternalReport,
-							eq: { author: actor() }
-						} }
-					};
-				});
-			}
-			#listMine = (initializeDeferredDecorator(this, "listMine"), void 0);
-		}
-		assert.deepEqual(Object.keys(getDeclaredOperations(Report)).sort(), ["addComment", "escalate"], "a class sees the operations it declares");
-		assert.deepEqual(Object.keys(getDeclaredOperations(ExternalReport)).sort(), [
-			"addComment",
-			"escalate",
-			"listMine"
-		], "a subclass sees its own operations and the ones it inherits");
-		assert.deepEqual(Object.keys(getOperations(ExternalReport)).sort(), [
-			"addComment",
-			"appendContainsMany",
-			"create",
-			"delete",
-			"escalate",
-			"listMine",
-			"query",
-			"read",
-			"readSource",
-			"transform",
-			"update"
-		], "and reads them alongside the base operations its def type carries");
-		assert.deepEqual(getDeclaredOperations(Report).escalate, {
-			base: "transform",
-			transformations: { $bxl: ".status = \"escalated\";" }
-		}, "the ancestor keeps its own declaration");
-		let overridden = getOperations(ExternalReport).escalate;
-		assert.deepEqual(Object.keys(overridden.params ?? {}), ["reason"], "the subclass declaration replaces the inherited one of the same name");
-		assert.deepEqual(JSON.parse(JSON.stringify(overridden.set)), {
-			status: "escalated",
-			escalationReason: {
-				$ref: "params",
-				key: "reason"
-			}
-		}, "the overriding declaration is the one that comes back");
-		assert.deepEqual(Object.keys(getOperations(new ExternalReport())).sort(), Object.keys(getOperations(ExternalReport)).sort(), "an instance reads the same operations as its class");
-		assert.strictEqual(getOperations(new ExternalReport()).escalate, getOperations(ExternalReport).escalate, "and reads the very declarations the class holds");
-	});
-	(0, import_qunit.test)("the base operations a def type carries come back without being declared", function(assert) {
-		assert.deepEqual(getOperations(CardDef), {
-			read: implied("read"),
-			readSource: implied("readSource"),
-			create: implied("create"),
-			update: implied("update"),
-			delete: implied("delete"),
-			query: implied("query"),
-			transform: implied("transform"),
-			appendContainsMany: implied("appendContainsMany")
-		}, "a card def carries every base operation, implied by the def type");
-		assert.deepEqual(Object.keys(getDeclaredOperations(CardDef)), [], "none of which is written in author code");
-		assert.deepEqual(getOperations(FileDef), {
-			read: implied("read"),
-			readSource: implied("readSource"),
-			update: implied("update"),
-			appendLine: implied("appendLine")
-		}, "a file's metadata is read-only, so what a file def carries beyond its two reads are the two writes that work on its bytes");
-		assert.deepEqual(getOperations(FieldDef), {}, "a field has no URL, so nothing is invocable on one");
-		class Report extends CardDef {
-			static {
-				decorateFieldV2(this, "read", [operation], function() {
-					return {
-						base: "read",
-						output: {
-							title: true,
-							comments: true
-						}
-					};
-				});
-			}
-			#read = (initializeDeferredDecorator(this, "read"), void 0);
-		}
-		assert.deepEqual(JSON.parse(JSON.stringify(getOperations(Report).read)), {
-			base: "read",
-			output: {
-				title: true,
-				comments: true
-			}
-		}, "the declaration takes the place of the base operation it names");
-		assert.deepEqual(Object.keys(getOperations(Report)).sort(), [
-			"appendContainsMany",
-			"create",
-			"delete",
-			"query",
-			"read",
-			"readSource",
-			"transform",
-			"update"
-		], "and adds no name, because it is that base operation");
-		class Archivable extends CardDef {
-			static {
-				decorateFieldV2(this, "delete", [operation], function() {
-					return {
-						base: "transform",
-						set: { archived: true }
-					};
-				});
-			}
-			#delete = (initializeDeferredDecorator(this, "delete"), void 0);
-		}
-		assert.deepEqual(JSON.parse(JSON.stringify(getOperations(Archivable).delete)), {
-			base: "transform",
-			set: { archived: true }
-		}, "a delete declared on transform is a soft delete");
-		assert.deepEqual(Object.keys(getOperations(Archivable)).sort(), [
-			"appendContainsMany",
-			"create",
-			"delete",
-			"query",
-			"read",
-			"readSource",
-			"transform",
-			"update"
-		], "which stands in for the removal rather than beside it");
-	});
-	(0, import_qunit.test)("typed references are JSON-serializable markers", function(assert) {
-		class ClassroomActivity extends CardDef {}
-		class Classroom extends CardDef {
-			static {
-				decorateFieldV2(this, "createActivity", [operation], function() {
-					return {
-						base: "create",
-						of: ClassroomActivity,
-						params: {
-							title: string_default,
-							dueOn: DateField
-						},
-						fill: {
-							title: params("title"),
-							dueOn: params("dueOn"),
-							postedBy: actor(),
-							classroom: instance("id"),
-							room: realmConfig("defaultRoom"),
-							settings: realmConfig()
-						}
-					};
-				});
-			}
-			#createActivity = (initializeDeferredDecorator(this, "createActivity"), void 0);
-			static {
-				decorateFieldV2(this, "addActivity", [operation], function() {
-					return {
-						base: "transform",
-						params: { activity: linkTo(ClassroomActivity) },
-						append: {
-							to: "activities",
-							value: card(params("activity"))
-						}
-					};
-				});
-			}
-			#addActivity = (initializeDeferredDecorator(this, "addActivity"), void 0);
-			static {
-				decorateFieldV2(this, "addOwner", [operation], function() {
-					return {
-						base: "transform",
-						assert: {
-							unique: "owners",
-							by: instance("id"),
-							message: "This classroom already owns itself"
-						},
-						append: {
-							to: "owners",
-							value: card("https://example.test/people/1")
-						}
-					};
-				});
-			}
-			#addOwner = (initializeDeferredDecorator(this, "addOwner"), void 0);
-		}
-		let declarations = getOperations(Classroom);
-		let createActivity = declarations.createActivity;
-		let addActivity = declarations.addActivity;
-		let addOwner = declarations.addOwner;
-		assert.deepEqual(JSON.parse(JSON.stringify(createActivity.fill)), {
-			title: {
-				$ref: "params",
-				key: "title"
-			},
-			dueOn: {
-				$ref: "params",
-				key: "dueOn"
-			},
-			postedBy: { $ref: "actor" },
-			classroom: {
-				$ref: "instance",
-				key: "id"
-			},
-			room: {
-				$ref: "realmConfig",
-				key: "defaultRoom"
-			},
-			settings: { $ref: "realmConfig" }
-		}, "every accessor reference survives JSON round-tripping, with and without a key");
-		assert.strictEqual(createActivity.of, ClassroomActivity, "a create carries the class it creates");
-		assert.deepEqual(JSON.parse(JSON.stringify(addActivity.append)), {
-			to: "activities",
-			value: {
-				$ref: "card",
-				value: {
-					$ref: "params",
-					key: "activity"
-				}
-			}
-		}, "a card reference carries the reference that resolves to the card");
-		assert.deepEqual(JSON.parse(JSON.stringify(addOwner.assert)), {
-			unique: "owners",
-			by: {
-				$ref: "instance",
-				key: "id"
-			},
-			message: "This classroom already owns itself"
-		}, "an assertion keys its uniqueness check on a reference");
-		assert.deepEqual(JSON.parse(JSON.stringify(bxl`assert(.status == "open"; "not open");`)), { $bxl: "assert(.status == \"open\"; \"not open\");" }, "a raw program is a marker carrying its source");
-	});
-	(0, import_qunit.test)("the bxl tag rejects interpolation", function(assert) {
-		let fieldName = "status";
-		assert.throws(() => bxl`.${fieldName} = "escalated";`, /does not interpolate values/, "a program reads the operation context through builtins, not spliced text");
-	});
-	(0, import_qunit.test)("the decorator rejects a target that is not a card definition", function(assert) {
-		assert.throws(() => {
-			class NotADef {
-				static {
-					decorateFieldV2(this, "addComment", [operation], function() {
-						return { base: "read" };
-					});
-				}
-				#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
-			}
-			return NotADef;
-		}, /can only be used on static properties of classes that extend BaseDef/, "a plain class cannot carry operations");
-	});
-	(0, import_qunit.test)("the decorator rejects a symbol operation name", function(assert) {
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, Symbol.for("cardstack-test-operation"), [operation], function() {
-						return { base: "read" };
-					});
-				}
-				#_ = (initializeDeferredDecorator(this, Symbol.for("cardstack-test-operation")), void 0);
-			}
-			return Report;
-		}, /only supports string operation names, not symbols/, "an operation is addressed by name on the wire, so it needs a string");
-	});
-	(0, import_qunit.test)("the decorator rejects a declaration that is not an object", function(assert) {
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "addComment", [operation], function() {
-						return "transform";
-					});
-				}
-				#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
-			}
-			return Report;
-		}, /must be a declaration object/, "a declaration is plain data, not a value of some other kind");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "addComment", [operation]);
-				}
-				#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
-			}
-			return Report;
-		}, /must be assigned a declaration object/, "an operation with no declaration names no behavior at all");
-	});
-	(0, import_qunit.test)("a field cannot declare operations", function(assert) {
-		assert.throws(() => {
-			class Comment extends FieldDef {
-				static {
-					decorateFieldV2(this, "addReply", [operation], function() {
-						return { base: "read" };
-					});
-				}
-				#addReply = (initializeDeferredDecorator(this, "addReply"), void 0);
-			}
-			return Comment;
-		}, /a field has no URL of its own/, "field data is reached through the operations of the card that contains it");
-	});
-	(0, import_qunit.test)("a file definition declares reads and the writes that work on its bytes", function(assert) {
-		class LogFile extends FileDef {
-			static {
-				decorateFieldV2(this, "readRedacted", [operation], function() {
-					return {
-						base: "read",
-						output: { name: true }
-					};
-				});
-			}
-			#readRedacted = (initializeDeferredDecorator(this, "readRedacted"), void 0);
-			static {
-				decorateFieldV2(this, "record", [operation], function() {
-					return {
-						base: "appendLine",
-						params: { line: string_default }
-					};
-				});
-			}
-			#record = (initializeDeferredDecorator(this, "record"), void 0);
-			static {
-				decorateFieldV2(this, "replace", [operation], function() {
-					return { base: "update" };
-				});
-			}
-			#replace = (initializeDeferredDecorator(this, "replace"), void 0);
-		}
-		assert.deepEqual(Object.keys(getDeclaredOperations(LogFile)).sort(), [
-			"readRedacted",
-			"record",
-			"replace"
-		], "each is declarable on a file definition");
-		assert.strictEqual(getOperations(LogFile).record, LogFile.record, "and an author-declared one comes back from the read every consumer dispatches from, as the declaration itself");
-		assert.deepEqual(Object.keys(getOperations(LogFile)).sort(), [
-			"appendLine",
-			"read",
-			"readRedacted",
-			"readSource",
-			"record",
-			"replace",
-			"update"
-		], "beside every base operation the def type carries — a declaration under a name of its own adds to them rather than standing in for one");
-		assert.throws(() => {
-			class Mutable extends FileDef {
-				static {
-					decorateFieldV2(this, "rename", [operation], function() {
-						return {
-							base: "transform",
-							set: { name: "renamed" }
-						};
-					});
-				}
-				#rename = (initializeDeferredDecorator(this, "rename"), void 0);
-			}
-			return Mutable;
-		}, /carries only "read", "readSource", "update", "appendLine"/, "file metadata is content-derived, so there is no JSON:API document to transform");
-		assert.throws(() => {
-			class Bare extends FileDef {
-				static {
-					decorateFieldV2(this, "record", [operation], function() {
-						return { base: "appendLine" };
-					});
-				}
-				#record = (initializeDeferredDecorator(this, "record"), void 0);
-			}
-			return Bare;
-		}, /declares a `line` param — or an `input` program that produces one/, "an append with no line to append would be refused at every invocation");
-		assert.throws(() => {
-			class Linked extends FileDef {
-				static {
-					decorateFieldV2(this, "record", [operation], function() {
-						return {
-							base: "appendLine",
-							params: { line: linkTo(CardDef) }
-						};
-					});
-				}
-				#record = (initializeDeferredDecorator(this, "record"), void 0);
-			}
-			return Linked;
-		}, /`params.line` is the text a line holds/, "a link is a card identity, and what goes into a text file is text");
-	});
-	(0, import_qunit.test)("a card definition carries every behavior but the one that appends a line", function(assert) {
-		assert.throws(() => {
-			class Ledger extends CardDef {
-				static {
-					decorateFieldV2(this, "record", [operation], function() {
-						return {
-							base: "appendLine",
-							params: { line: string_default }
-						};
-					});
-				}
-				#record = (initializeDeferredDecorator(this, "record"), void 0);
-			}
-			return Ledger;
-		}, /carries only "read", "readSource", "create", "update", "delete", "query", "transform", "appendContainsMany"/, "a card's stored bytes are a JSON:API document, and a line appended to one is no longer a card");
-	});
-	(0, import_qunit.test)("an appendContainsMany names the fields it appends to and the item for each", function(assert) {
-		class EventLog extends CardDef {
-			static {
-				decorateFieldV2(this, "log", [operation], function() {
-					return {
-						base: "appendContainsMany",
-						params: { body: string_default },
-						field: "events",
-						item: {
-							body: params("body"),
-							at: actor()
-						}
-					};
-				});
-			}
-			#log = (initializeDeferredDecorator(this, "log"), void 0);
-			static {
-				decorateFieldV2(this, "logBoth", [operation], function() {
-					return {
-						base: "appendContainsMany",
-						params: {
-							body: string_default,
-							label: string_default
-						},
-						fields: {
-							events: { body: params("body") },
-							labels: params("label")
-						}
-					};
-				});
-			}
-			#logBoth = (initializeDeferredDecorator(this, "logBoth"), void 0);
-		}
-		assert.deepEqual(Object.keys(getDeclaredOperations(EventLog)).sort(), ["log", "logBoth"], "both spellings are declarations");
-		let rejected = [
-			[
-				"both spellings at once",
-				() => {
-					class Both extends CardDef {
-						static {
-							decorateFieldV2(this, "log", [operation], function() {
-								return {
-									base: "appendContainsMany",
-									field: "events",
-									item: { body: "x" },
-									fields: { events: { body: "y" } }
-								};
-							});
-						}
-						#log = (initializeDeferredDecorator(this, "log"), void 0);
-					}
-					return Both;
-				},
-				/names one field with its `item`, or several under `fields` — not both/
-			],
-			[
-				"neither spelling",
-				() => {
-					class Neither extends CardDef {
-						static {
-							decorateFieldV2(this, "log", [operation], function() {
-								return { base: "appendContainsMany" };
-							});
-						}
-						#log = (initializeDeferredDecorator(this, "log"), void 0);
-					}
-					return Neither;
-				},
-				/needs `field` and `item`, or `fields`/
-			],
-			[
-				"a field with no item",
-				() => {
-					class NoItem extends CardDef {
-						static {
-							decorateFieldV2(this, "log", [operation], function() {
-								return {
-									base: "appendContainsMany",
-									field: "events"
-								};
-							});
-						}
-						#log = (initializeDeferredDecorator(this, "log"), void 0);
-					}
-					return NoItem;
-				},
-				/needs an `item` to append to "events"/
-			],
-			[
-				"an empty fields map",
-				() => {
-					class Empty extends CardDef {
-						static {
-							decorateFieldV2(this, "log", [operation], function() {
-								return {
-									base: "appendContainsMany",
-									fields: {}
-								};
-							});
-						}
-						#log = (initializeDeferredDecorator(this, "log"), void 0);
-					}
-					return Empty;
-				},
-				/`fields` must be an object mapping each `containsMany` field/
-			]
-		];
-		for (let [name, build, pattern] of rejected) assert.throws(build, pattern, `${name} is refused`);
-	});
-	(0, import_qunit.test)("an appendContainsMany under its own name may name nothing, and is then the built-in", function(assert) {
-		class Journal extends CardDef {
-			static {
-				decorateFieldV2(this, "appendContainsMany", [operation], function() {
-					return {
-						base: "appendContainsMany",
-						nonGrantable: true
-					};
-				});
-			}
-			#appendContainsMany = (initializeDeferredDecorator(this, "appendContainsMany"), void 0);
-		}
-		assert.deepEqual(JSON.parse(JSON.stringify(getDeclaredOperations(Journal).appendContainsMany)), {
-			base: "appendContainsMany",
-			nonGrantable: true
-		}, "a def can mark the built-in append without changing what it appends");
-		assert.throws(() => {
-			class Named extends CardDef {
-				static {
-					decorateFieldV2(this, "log", [operation], function() {
-						return {
-							base: "appendContainsMany",
-							nonGrantable: true
-						};
-					});
-				}
-				#log = (initializeDeferredDecorator(this, "log"), void 0);
-			}
-			return Named;
-		}, /needs `field` and `item`, or `fields`/, "under any other name an append that names nothing is refused");
-	});
-	(0, import_qunit.test)("nonGrantable is a boolean any declaration may carry", function(assert) {
-		class Ledger extends CardDef {
-			static {
-				decorateFieldV2(this, "seal", [operation], function() {
-					return {
-						base: "transform",
-						set: { status: "sealed" },
-						nonGrantable: true
-					};
-				});
-			}
-			#seal = (initializeDeferredDecorator(this, "seal"), void 0);
-			static {
-				decorateFieldV2(this, "update", [operation], function() {
-					return {
-						base: "update",
-						nonGrantable: true
-					};
-				});
-			}
-			#update = (initializeDeferredDecorator(this, "update"), void 0);
-		}
-		assert.deepEqual(Object.keys(getDeclaredOperations(Ledger)).sort(), ["seal", "update"], "a named operation and a built-in both carry it");
-		assert.throws(() => {
-			class Loose extends CardDef {
-				static {
-					decorateFieldV2(this, "seal", [operation], function() {
-						return {
-							base: "transform",
-							set: { status: "sealed" },
-							nonGrantable: "yes"
-						};
-					});
-				}
-				#seal = (initializeDeferredDecorator(this, "seal"), void 0);
-			}
-			return Loose;
-		}, /`nonGrantable` must be a boolean/);
-	});
-	(0, import_qunit.test)("label is a short line of plain text any declaration may carry", function(assert) {
-		class Inbox extends CardDef {
-			static {
-				decorateFieldV2(this, "archive", [operation], function() {
-					return {
-						base: "transform",
-						label: "Archive this inbox",
-						set: { status: "archived" }
-					};
-				});
-			}
-			#archive = (initializeDeferredDecorator(this, "archive"), void 0);
-			static {
-				decorateFieldV2(this, "listOpen", [operation], function() {
-					return {
-						base: "query",
-						label: "List open inboxes",
-						query: { filter: {
-							on: () => Inbox,
-							eq: { status: "open" }
-						} }
-					};
-				});
-			}
-			#listOpen = (initializeDeferredDecorator(this, "listOpen"), void 0);
-			static {
-				decorateFieldV2(this, "update", [operation], function() {
-					return {
-						base: "update",
-						label: "Edit this inbox"
-					};
-				});
-			}
-			#update = (initializeDeferredDecorator(this, "update"), void 0);
-		}
-		class LogFile extends FileDef {
-			static {
-				decorateFieldV2(this, "record", [operation], function() {
-					return {
-						base: "appendLine",
-						label: "Add a line to the log",
-						params: { line: string_default }
-					};
-				});
-			}
-			#record = (initializeDeferredDecorator(this, "record"), void 0);
-		}
-		assert.deepEqual(Object.fromEntries(Object.entries({
-			...getDeclaredOperations(Inbox),
-			...getDeclaredOperations(LogFile)
-		}).map(([name, declaration]) => [name, declaration.label])), {
-			archive: "Archive this inbox",
-			listOpen: "List open inboxes",
-			update: "Edit this inbox",
-			record: "Add a line to the log"
-		}, "a named operation, a saved search, a built-in and a file operation all carry one");
-		let refused = [
-			[
-				"an empty label",
-				"",
-				/a label must not be empty/
-			],
-			[
-				"a blank label",
-				"   ",
-				/a label must not be empty/
-			],
-			[
-				"a label over 80 characters",
-				"x".repeat(81),
-				/a label must be at most 80 characters, and this one is 81/
-			],
-			[
-				"a label with markup",
-				"Archive <b>now</b>",
-				/without markup/
-			],
-			[
-				"a label with a line break",
-				"Archive\nthis inbox",
-				/without line breaks/
-			],
-			[
-				"a label with a tab",
-				"Archive	this inbox",
-				/without line breaks/
-			],
-			[
-				"a label that is not a string",
-				42,
-				/a label must be a string/
-			]
-		];
-		for (let [what, label, pattern] of refused) assert.throws(() => {
-			class Loose extends CardDef {
-				static {
-					decorateFieldV2(this, "update", [operation], function() {
-						return {
-							base: "update",
-							label
-						};
-					});
-				}
-				#update = (initializeDeferredDecorator(this, "update"), void 0);
-			}
-			return Loose;
-		}, pattern, `${what} is refused`);
-		class AtTheLimit extends CardDef {
-			static {
-				decorateFieldV2(this, "update", [operation], function() {
-					return {
-						base: "update",
-						label: "x".repeat(80)
-					};
-				});
-			}
-			#update = (initializeDeferredDecorator(this, "update"), void 0);
-		}
-		assert.strictEqual(getDeclaredOperations(AtTheLimit).update.label, "x".repeat(80), "a label of exactly 80 characters is accepted");
-	});
-	(0, import_qunit.test)("an explain is carried only where a card declares one, and is never grantable", function(assert) {
-		class Plain extends CardDef {}
-		assert.false("explain" in getOperations(Plain), "no card carries an explain it did not declare");
-		class Policy extends CardDef {
-			static {
-				decorateFieldV2(this, "explain", [operation], function() {
-					return {
-						base: "explain",
-						params: {
-							actor: string_default,
-							target: string_default,
-							operation: string_default
-						},
-						nonGrantable: true
-					};
-				});
-			}
-			#explain = (initializeDeferredDecorator(this, "explain"), void 0);
-		}
-		assert.strictEqual(getOperations(Policy).explain?.base, "explain", "a card that declares one carries it under the name it declared");
-		let rejected = [
-			[
-				"an explain that leaves the flag off",
-				() => {
-					class Open extends CardDef {
-						static {
-							decorateFieldV2(this, "explain", [operation], function() {
-								return { base: "explain" };
-							});
-						}
-						#explain = (initializeDeferredDecorator(this, "explain"), void 0);
-					}
-					return Open;
-				},
-				/declare it with `nonGrantable: true`/
-			],
-			[
-				"an explain that carries a program",
-				() => {
-					class Scripted extends CardDef {
-						static {
-							decorateFieldV2(this, "explain", [operation], function() {
-								return {
-									base: "explain",
-									nonGrantable: true,
-									transformations: bxl`.status = "x";`
-								};
-							});
-						}
-						#explain = (initializeDeferredDecorator(this, "explain"), void 0);
-					}
-					return Scripted;
-				},
-				/so it carries no `transformations`/
-			],
-			[
-				"an explain that reshapes its answer",
-				() => {
-					class Projected extends CardDef {
-						static {
-							decorateFieldV2(this, "explain", [operation], function() {
-								return {
-									base: "explain",
-									nonGrantable: true,
-									output: { decision: bxl`.decision` }
-								};
-							});
-						}
-						#explain = (initializeDeferredDecorator(this, "explain"), void 0);
-					}
-					return Projected;
-				},
-				/carries no `output` to reshape it/
-			],
-			[
-				"an explain that rewrites its question",
-				() => {
-					class Rewritten extends CardDef {
-						static {
-							decorateFieldV2(this, "explain", [operation], function() {
-								return {
-									base: "explain",
-									nonGrantable: true,
-									input: bxl`.`
-								};
-							});
-						}
-						#explain = (initializeDeferredDecorator(this, "explain"), void 0);
-					}
-					return Rewritten;
-				},
-				/carries no `input` to rewrite it/
-			],
-			[
-				"an explain on a file def",
-				() => {
-					class LogFile extends FileDef {
-						static {
-							decorateFieldV2(this, "explain", [operation], function() {
-								return {
-									base: "explain",
-									nonGrantable: true
-								};
-							});
-						}
-						#explain = (initializeDeferredDecorator(this, "explain"), void 0);
-					}
-					return LogFile;
-				},
-				/cannot declare a "explain" operation/
-			]
-		];
-		for (let [name, build, pattern] of rejected) assert.throws(build, pattern, `${name} is refused`);
-	});
-	(0, import_qunit.test)("a validate is carried only where a card declares one, and is never grantable", function(assert) {
-		class Plain extends CardDef {}
-		assert.false("validate" in getOperations(Plain), "no card carries a validate it did not declare");
-		class Policy extends CardDef {
-			static {
-				decorateFieldV2(this, "validate", [operation], function() {
-					return {
-						base: "validate",
-						nonGrantable: true
-					};
-				});
-			}
-			#validate = (initializeDeferredDecorator(this, "validate"), void 0);
-		}
-		assert.strictEqual(getOperations(Policy).validate?.base, "validate", "a card that declares one carries it under the name it declared");
-		let rejected = [
-			[
-				"a validate that leaves the flag off",
-				() => {
-					class Open extends CardDef {
-						static {
-							decorateFieldV2(this, "validate", [operation], function() {
-								return { base: "validate" };
-							});
-						}
-						#validate = (initializeDeferredDecorator(this, "validate"), void 0);
-					}
-					return Open;
-				},
-				/declare it with `nonGrantable: true`/
-			],
-			[
-				"a validate that carries a program",
-				() => {
-					class Scripted extends CardDef {
-						static {
-							decorateFieldV2(this, "validate", [operation], function() {
-								return {
-									base: "validate",
-									nonGrantable: true,
-									transformations: bxl`.status = "x";`
-								};
-							});
-						}
-						#validate = (initializeDeferredDecorator(this, "validate"), void 0);
-					}
-					return Scripted;
-				},
-				/so it carries no `transformations`/
-			],
-			[
-				"a validate that reshapes its answer",
-				() => {
-					class Projected extends CardDef {
-						static {
-							decorateFieldV2(this, "validate", [operation], function() {
-								return {
-									base: "validate",
-									nonGrantable: true,
-									output: { issues: bxl`.issues` }
-								};
-							});
-						}
-						#validate = (initializeDeferredDecorator(this, "validate"), void 0);
-					}
-					return Projected;
-				},
-				/carries no `output` to reshape it/
-			],
-			[
-				"a validate that takes params",
-				() => {
-					class WithParams extends CardDef {
-						static {
-							decorateFieldV2(this, "validate", [operation], function() {
-								return {
-									base: "validate",
-									nonGrantable: true,
-									params: { realm: string_default }
-								};
-							});
-						}
-						#validate = (initializeDeferredDecorator(this, "validate"), void 0);
-					}
-					return WithParams;
-				},
-				/takes no payload.*so it carries no `params`/
-			],
-			[
-				"a validate that takes an input",
-				() => {
-					class WithInput extends CardDef {
-						static {
-							decorateFieldV2(this, "validate", [operation], function() {
-								return {
-									base: "validate",
-									nonGrantable: true,
-									input: bxl`{ strict: true }`
-								};
-							});
-						}
-						#validate = (initializeDeferredDecorator(this, "validate"), void 0);
-					}
-					return WithInput;
-				},
-				/takes no payload.*so it carries no `input`/
-			],
-			[
-				"a validate on a file def",
-				() => {
-					class LogFile extends FileDef {
-						static {
-							decorateFieldV2(this, "validate", [operation], function() {
-								return {
-									base: "validate",
-									nonGrantable: true
-								};
-							});
-						}
-						#validate = (initializeDeferredDecorator(this, "validate"), void 0);
-					}
-					return LogFile;
-				},
-				/cannot declare a "validate" operation/
-			]
-		];
-		for (let [name, build, pattern] of rejected) assert.throws(build, pattern, `${name} is refused`);
-	});
-	(0, import_qunit.test)("a declaration that runs no program carries no raw one", function(assert) {
-		let rejected = [
-			["appendContainsMany", () => {
-				class Ledger extends CardDef {
-					static {
-						decorateFieldV2(this, "log", [operation], function() {
-							return {
-								base: "appendContainsMany",
-								transformations: bxl`.status = "logged";`
-							};
-						});
-					}
-					#log = (initializeDeferredDecorator(this, "log"), void 0);
-				}
-				return Ledger;
-			}],
-			["appendLine", () => {
-				class LogFile extends FileDef {
-					static {
-						decorateFieldV2(this, "record", [operation], function() {
-							return {
-								base: "appendLine",
-								params: { line: string_default },
-								transformations: bxl`.name = "x";`
-							};
-						});
-					}
-					#record = (initializeDeferredDecorator(this, "record"), void 0);
-				}
-				return LogFile;
-			}],
-			["update on a file def", () => {
-				class Replaceable extends FileDef {
-					static {
-						decorateFieldV2(this, "replace", [operation], function() {
-							return {
-								base: "update",
-								transformations: bxl`.name = "x";`
-							};
-						});
-					}
-					#replace = (initializeDeferredDecorator(this, "replace"), void 0);
-				}
-				return Replaceable;
-			}]
-		];
-		for (let [name, build] of rejected) assert.throws(build, /so it carries no `transformations`/, `${name} runs no program over a document`);
-	});
-	(0, import_qunit.test)("a stored-bytes read takes no declaration at all", function(assert) {
-		for (let Def of [CardDef, FileDef]) assert.throws(() => {
-			class Exported extends Def {
-				static {
-					decorateFieldV2(this, "exportBytes", [operation], function() {
-						return { base: "readSource" };
-					});
-				}
-				#exportBytes = (initializeDeferredDecorator(this, "exportBytes"), void 0);
-			}
-			return Exported;
-		}, /serves the bytes stored at the def's URL/, `a ${Def.name} cannot build an operation on a stored-bytes read`);
-		assert.throws(() => {
-			class Redacted extends CardDef {
-				static {
-					decorateFieldV2(this, "readSource", [operation], function() {
-						return {
-							base: "readSource",
-							output: { redacted: true }
-						};
-					});
-				}
-				#readSource = (initializeDeferredDecorator(this, "readSource"), void 0);
-			}
-			return Redacted;
-		}, /reserved operation name/, "and it cannot be specialized under its own name either");
-		assert.throws(() => {
-			class Sneaky extends CardDef {
-				static {
-					decorateFieldV2(this, "readSource", [operation], function() {
-						return {
-							base: "read",
-							output: { redacted: true }
-						};
-					});
-				}
-				#readSource = (initializeDeferredDecorator(this, "readSource"), void 0);
-			}
-			return Sneaky;
-		}, /reserved operation name/, "a declaration cannot take the name by building on another base");
-	});
-	(0, import_qunit.test)("a saved search may not be named `query`", function(assert) {
-		assert.throws(() => {
-			class Listing extends CardDef {
-				static {
-					decorateFieldV2(this, "query", [operation], function() {
-						return {
-							base: "query",
-							query: { filter: { type: () => Listing } }
-						};
-					});
-				}
-				#query = (initializeDeferredDecorator(this, "query"), void 0);
-			}
-			return Listing;
-		}, /"query" is a reserved operation name/);
-	});
-	(0, import_qunit.test)("the decorator refuses every name the realm answers definition-free", function(assert) {
-		assert.ok(DEFINITION_FREE_BASE_OPERATIONS.length > 0, "the list is non-empty, so the loop below asserts something");
-		let applyOperation = operation;
-		for (let name of DEFINITION_FREE_BASE_OPERATIONS) assert.throws(() => {
-			class Shadow extends CardDef {}
-			applyOperation(Shadow, name, { initializer: () => ({ base: "read" }) });
-			return Shadow;
-		}, /reserved operation name/, `${name} is refused as a declaration name`);
-	});
-	(0, import_qunit.test)("the decorator rejects an operation name that is already a static", function(assert) {
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "displayName", [operation], function() {
-						return { base: "read" };
-					});
-				}
-				#displayName = (initializeDeferredDecorator(this, "displayName"), void 0);
-			}
-			return Report;
-		}, /already resolves on this class/, "an operation name that shadows a system static is refused");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "toString", [operation], function() {
-						return { base: "read" };
-					});
-				}
-				#toString = (initializeDeferredDecorator(this, "toString"), void 0);
-			}
-			return Report;
-		}, /already resolves on this class/, "nor one that shadows something every class inherits");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "__proto__", [operation], function() {
-						return { base: "read" };
-					});
-				}
-				#__proto__ = (initializeDeferredDecorator(this, "__proto__"), void 0);
-			}
-			return Report;
-		}, /already resolves on this class/, "and least of all a name that would reset a prototype instead of keying a map");
-		class Report extends CardDef {
-			static {
-				decorateFieldV2(this, "addComment", [operation], function() {
-					return {
-						base: "transform",
-						params: { body: string_default },
-						append: {
-							to: "comments",
-							value: { body: params("body") }
-						}
-					};
-				});
-			}
-			#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
-		}
-		assert.deepEqual(Object.keys(getDeclaredOperations(Report)), ["addComment"], "a rejected name leaves the store working");
-		for (let inherited of [
-			"toString",
-			"constructor",
-			"__proto__",
-			"valueOf",
-			"hasOwnProperty"
-		]) {
-			assert.false(inherited in getOperations(Report), `a name-keyed record does not answer for ${inherited}`);
-			assert.false(inherited in getDeclaredOperations(Report), `nor does the declared-only record answer for ${inherited}`);
-		}
-		assert.true("addComment" in getOperations(Report), "while still answering for the operations it holds");
-		assert.true("read" in getOperations(Report), "and for the base operations its def type carries");
-	});
-	(0, import_qunit.test)("the decorator installs the declaration on the class", function(assert) {
-		class Report extends CardDef {
-			static {
-				decorateFieldV2(this, "addComment", [operation], function() {
-					return {
-						base: "transform",
-						params: { body: string_default },
-						append: {
-							to: "comments",
-							value: { body: params("body") }
-						}
-					};
-				});
-			}
-			#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
-		}
-		assert.strictEqual(Report.addComment, getDeclaredOperations(Report).addComment, "the class carries the very declaration the reader returns");
-	});
-	(0, import_qunit.test)("the decorator validates the declaration against its base operation", function(assert) {
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "addComment", [operation], function() {
-						return { base: "append" };
-					});
-				}
-				#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
-			}
-			return Report;
-		}, /must name the built-in behavior/, "a declaration builds on one of the built-in behaviors");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "addComment", [operation], function() {
-						return {
-							base: "read",
-							append: {
-								to: "comments",
-								value: "hello"
-							}
-						};
-					});
-				}
-				#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
-			}
-			return Report;
-		}, /"append" is not a valid key for a "read" operation/, "a clause is only legal on the base that can express it");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "createComment", [operation], function() {
-						return {
-							base: "create",
-							fill: { body: "x" }
-						};
-					});
-				}
-				#createComment = (initializeDeferredDecorator(this, "createComment"), void 0);
-			}
-			return Report;
-		}, /a "create" operation needs/, "a create names the type it creates");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "createComment", [operation], function() {
-						return {
-							base: "create",
-							of: () => Report,
-							links: "none"
-						};
-					});
-				}
-				#createComment = (initializeDeferredDecorator(this, "createComment"), void 0);
-			}
-			return Report;
-		}, /"links" is not a valid key for a "create" operation/, "only a read or a query carries a link graph to narrow");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "summary", [operation], function() {
-						return {
-							base: "read",
-							links: "some"
-						};
-					});
-				}
-				#summary = (initializeDeferredDecorator(this, "summary"), void 0);
-			}
-			return Report;
-		}, /`links` must name how much of the card's link graph this read carries/, "and it names one of the strategies a read applies");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "read", [operation], function() {
-						return {
-							base: "read",
-							links: "none"
-						};
-					});
-				}
-				#read = (initializeDeferredDecorator(this, "read"), void 0);
-			}
-			return Report;
-		}, /this read carries — one of "full", "ids"\. .*"ids" narrows a read/, "a read may not withhold its links from the host that edits the card");
-		class Gradebook extends CardDef {
-			static {
-				decorateFieldV2(this, "listAll", [operation], function() {
-					return {
-						base: "query",
-						query: { filter: { type: () => Gradebook } },
-						links: "none"
-					};
-				});
-			}
-			#listAll = (initializeDeferredDecorator(this, "listAll"), void 0);
-		}
-		assert.strictEqual(getDeclaredOperations(Gradebook).listAll.links, "none", "while a query may");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "listAll", [operation], function() {
-						return {
-							base: "query",
-							query: { filter: { type: () => Report } },
-							links: "some"
-						};
-					});
-				}
-				#listAll = (initializeDeferredDecorator(this, "listAll"), void 0);
-			}
-			return Report;
-		}, /`links` must name how much of the card's link graph each of this query's results carries/, "a query names one of the same three");
-		class Roster extends CardDef {
-			static {
-				decorateFieldV2(this, "listAll", [operation], function() {
-					return {
-						base: "query",
-						query: { filter: { type: () => Roster } },
-						links: "ids"
-					};
-				});
-			}
-			#listAll = (initializeDeferredDecorator(this, "listAll"), void 0);
-		}
-		assert.strictEqual(getDeclaredOperations(Roster).listAll.links, "ids", "and a query that names one is declared with it");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "rename", [operation], function() {
-						return {
-							base: "transform",
-							set: { title: "Renamed" },
-							html: { embedded: "unshareable" }
-						};
-					});
-				}
-				#rename = (initializeDeferredDecorator(this, "rename"), void 0);
-			}
-			return Report;
-		}, /"html" is not a valid key for a "transform" operation/, "only a read or a query serves prerendered HTML to withhold");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "summary", [operation], function() {
-						return {
-							base: "read",
-							html: { edit: "unshareable" }
-						};
-					});
-				}
-				#summary = (initializeDeferredDecorator(this, "summary"), void 0);
-			}
-			return Report;
-		}, /`html` names "edit", which is not a prerendered format/, "it names prerendered formats");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "summary", [operation], function() {
-						return {
-							base: "read",
-							html: { embedded: "hidden" }
-						};
-					});
-				}
-				#summary = (initializeDeferredDecorator(this, "summary"), void 0);
-			}
-			return Report;
-		}, /`html.embedded` must say whether the format's prerendered HTML is served/, "each shareable or unshareable");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "listAll", [operation], function() {
-						return {
-							base: "query",
-							query: { filter: { type: () => Report } },
-							html: ["embedded"]
-						};
-					});
-				}
-				#listAll = (initializeDeferredDecorator(this, "listAll"), void 0);
-			}
-			return Report;
-		}, /`html` must be an object naming which prerendered formats this query's results are served data-only for/, "by format");
-		class Classroom extends CardDef {
-			static {
-				decorateFieldV2(this, "read", [operation], function() {
-					return {
-						base: "read",
-						html: { embedded: "unshareable" }
-					};
-				});
-			}
-			#read = (initializeDeferredDecorator(this, "read"), void 0);
-			static {
-				decorateFieldV2(this, "listAll", [operation], function() {
-					return {
-						base: "query",
-						query: { filter: { type: () => Classroom } },
-						html: {
-							fitted: "unshareable",
-							isolated: "shareable"
-						}
-					};
-				});
-			}
-			#listAll = (initializeDeferredDecorator(this, "listAll"), void 0);
-		}
-		assert.deepEqual(getDeclaredOperations(Classroom).read.html, { embedded: "unshareable" }, "a read that names formats is declared with them");
-		assert.deepEqual(getDeclaredOperations(Classroom).listAll.html, {
-			fitted: "unshareable",
-			isolated: "shareable"
-		}, "and so is a query");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "escalate", [operation], function() {
-						return {
-							base: "transform",
-							set: { status: "escalated" },
-							transformations: bxl`.status = "escalated";`
-						};
-					});
-				}
-				#escalate = (initializeDeferredDecorator(this, "escalate"), void 0);
-			}
-			return Report;
-		}, /either with clauses .* or with a raw/, "the declarative clauses and a raw program are alternatives");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "escalate", [operation], function() {
-						return {
-							base: "transform",
-							transformations: ".status = \"escalated\";"
-						};
-					});
-				}
-				#escalate = (initializeDeferredDecorator(this, "escalate"), void 0);
-			}
-			return Report;
-		}, /must be a program written with the bxl tag/, "a raw program comes from the bxl tag, not a bare string");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "listMine", [operation], function() {
-						return { base: "query" };
-					});
-				}
-				#listMine = (initializeDeferredDecorator(this, "listMine"), void 0);
-			}
-			return Report;
-		}, /a "query" operation needs/, "a named query is the query it saves");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "addComment", [operation], function() {
-						return {
-							base: "transform",
-							append: {
-								to: "comments",
-								value: "hello",
-								into: "comments"
-							}
-						};
-					});
-				}
-				#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
-			}
-			return Report;
-		}, /"into" is not a valid key/, "a clause accepts only the keys it is made of");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "addComment", [operation], function() {
-						return {
-							base: "transform",
-							append: {
-								to: "comments",
-								value: { body: { $ref: "payload" } }
-							}
-						};
-					});
-				}
-				#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
-			}
-			return Report;
-		}, /is not a typed reference/, "a reference comes from one of the reference constructors");
-	});
-	(0, import_qunit.test)("a param is typed by a field class, and nothing else", function(assert) {
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "addComment", [operation], function() {
-						return {
-							base: "transform",
-							params: { author: CardDef },
-							append: {
-								to: "comments",
-								value: { author: params("author") }
-							}
-						};
-					});
-				}
-				#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
-			}
-			return Report;
-		}, /a card or file identity is a linkTo/, "a card class types a link param, which is what linkTo declares");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "addComment", [operation], function() {
-						return {
-							base: "transform",
-							params: { body: () => string_default },
-							append: {
-								to: "comments",
-								value: { body: params("body") }
-							}
-						};
-					});
-				}
-				#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
-			}
-			return Report;
-		}, /param "body" must be a field class or linkTo/, "a scalar param takes the field class itself, not a thunk");
-	});
-	(0, import_qunit.test)("a declaration carries only what survives as data", function(assert) {
-		for (let [value, pattern, message] of [
-			[
-				() => "escalated",
-				/is a function; a declaration is data/,
-				"a function would never reach the realm"
-			],
-			[
-				/* @__PURE__ */ new Date(),
-				/is a Date instance/,
-				"a date would flatten to a string"
-			],
-			[
-				/* @__PURE__ */ new Map(),
-				/is a Map instance/,
-				"a map would flatten to an empty object"
-			],
-			[
-				void 0,
-				/omit an optional key rather than declaring it as undefined/,
-				"an undefined value would be dropped"
-			],
-			[
-				1n,
-				/is a bigint/,
-				"a bigint cannot be serialized at all"
-			]
-		]) assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "escalate", [operation], function() {
-						return {
-							base: "transform",
-							set: { status: value }
-						};
-					});
-				}
-				#escalate = (initializeDeferredDecorator(this, "escalate"), void 0);
-			}
-			return Report;
-		}, pattern, message);
-		class Activity extends CardDef {}
-		class Classroom extends CardDef {
-			static {
-				decorateFieldV2(this, "createActivity", [operation], function() {
-					return {
-						base: "create",
-						of: Activity,
-						params: { title: string_default },
-						fill: { title: params("title") }
-					};
-				});
-			}
-			#createActivity = (initializeDeferredDecorator(this, "createActivity"), void 0);
-			static {
-				decorateFieldV2(this, "listActivities", [operation], function() {
-					return {
-						base: "query",
-						query: { filter: {
-							on: Activity,
-							eq: { classroom: instance("id") }
-						} }
-					};
-				});
-			}
-			#listActivities = (initializeDeferredDecorator(this, "listActivities"), void 0);
-		}
-		let declarations = getOperations(Classroom);
-		assert.strictEqual(declarations.createActivity.of, Activity, "a create names the class it creates");
-		assert.strictEqual(declarations.listActivities.query.filter.on, Activity, "and a query names the class it filters on");
-	});
-	(0, import_qunit.test)("a def class is legal only where a slot names a type", function(assert) {
-		class Activity extends CardDef {}
-		class Classroom extends CardDef {
-			static {
-				decorateFieldV2(this, "listActivities", [operation], function() {
-					return {
-						base: "query",
-						query: { filter: { any: [{
-							on: () => Activity,
-							eq: { status: "open" }
-						}] } }
-					};
-				});
-			}
-			#listActivities = (initializeDeferredDecorator(this, "listActivities"), void 0);
-			static {
-				decorateFieldV2(this, "makeActivity", [operation], function() {
-					return {
-						base: "create",
-						of: Activity,
-						params: { title: string_default },
-						transformations: bxl`.title = params("title");`
-					};
-				});
-			}
-			#makeActivity = (initializeDeferredDecorator(this, "makeActivity"), void 0);
-		}
-		let declarations = getDeclaredOperations(Classroom);
-		assert.strictEqual(declarations.makeActivity.of, Activity, "a program-driven create still names what it creates");
-		assert.strictEqual(typeof declarations.listActivities.query.filter.any[0].on, "function", "and a nested filter still names its type");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "listSome", [operation], function() {
-						return {
-							base: "query",
-							query: { filter: {
-								on: Activity,
-								eq: { owner: () => 1 }
-							} }
-						};
-					});
-				}
-				#listSome = (initializeDeferredDecorator(this, "listSome"), void 0);
-			}
-			return Report;
-		}, /is a function; a declaration is data/, "but a function anywhere else in a query would lower to nothing");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "makeOne", [operation], function() {
-						return {
-							base: "create",
-							of: string_default
-						};
-					});
-				}
-				#makeOne = (initializeDeferredDecorator(this, "makeOne"), void 0);
-			}
-			return Report;
-		}, /must be a card class/, "and only a card can be created");
-		assert.throws(() => linkTo(string_default), /card or file class/, "while a link points at something that has a URL");
-	});
-	(0, import_qunit.test)("a shared value is checked in every slot it appears", function(assert) {
-		assert.throws(() => {
-			let shared = { on: CardDef };
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "listSome", [operation], function() {
-						return {
-							base: "query",
-							query: { filter: shared },
-							output: { leak: shared }
-						};
-					});
-				}
-				#listSome = (initializeDeferredDecorator(this, "listSome"), void 0);
-			}
-			return Report;
-		}, /is a function; a declaration is data/, "validation does not memoize, so it cannot depend on key order");
-	});
-	(0, import_qunit.test)("a declaration must be a tree of finite values", function(assert) {
-		assert.throws(() => {
-			let value = { body: "x" };
-			value.self = value;
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "escalate", [operation], function() {
-						return {
-							base: "transform",
-							set: value
-						};
-					});
-				}
-				#escalate = (initializeDeferredDecorator(this, "escalate"), void 0);
-			}
-			return Report;
-		}, /refers back to a value that contains it/, "a cycle would throw when the declaration is serialized, far from here");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "escalate", [operation], function() {
-						return {
-							base: "transform",
-							set: { score: NaN }
-						};
-					});
-				}
-				#escalate = (initializeDeferredDecorator(this, "escalate"), void 0);
-			}
-			return Report;
-		}, /serializes as null/, "and a non-finite number would quietly become null");
-	});
-	(0, import_qunit.test)("a marker carries only its own key", function(assert) {
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "escalate", [operation], function() {
-						return {
-							base: "transform",
-							transformations: {
-								$bxl: ".a = 1;",
-								hook: () => 1
-							}
-						};
-					});
-				}
-				#escalate = (initializeDeferredDecorator(this, "escalate"), void 0);
-			}
-			return Report;
-		}, /is not a valid key/, "a program marker is not a place to smuggle a value past the walk");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "addActivity", [operation], function() {
-						return {
-							base: "transform",
-							params: { activity: {
-								$linkTo: CardDef,
-								junk: 1
-							} },
-							append: {
-								to: "activities",
-								value: card(params("activity"))
-							}
-						};
-					});
-				}
-				#addActivity = (initializeDeferredDecorator(this, "addActivity"), void 0);
-			}
-			return Report;
-		}, /is not a valid key/, "nor is a link param, which the reference walk skips");
-	});
-	(0, import_qunit.test)("a named query is checked for the shape a search needs", function(assert) {
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "listSome", [operation], function() {
-						return {
-							base: "query",
-							query: {}
-						};
-					});
-				}
-				#listSome = (initializeDeferredDecorator(this, "listSome"), void 0);
-			}
-			return Report;
-		}, /at least one of/, "a query with no query names no search");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "listSome", [operation], function() {
-						return {
-							base: "query",
-							query: {
-								filter: { type: CardDef },
-								page: { size: 0 }
-							}
-						};
-					});
-				}
-				#listSome = (initializeDeferredDecorator(this, "listSome"), void 0);
-			}
-			return Report;
-		}, /must be a positive integer/, "a page size is a count");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "listSome", [operation], function() {
-						return {
-							base: "query",
-							query: {
-								filter: { type: CardDef },
-								realms: "https://x/"
-							}
-						};
-					});
-				}
-				#listSome = (initializeDeferredDecorator(this, "listSome"), void 0);
-			}
-			return Report;
-		}, /non-empty array of realm URLs/, "and realms is the fan-out list, not one realm");
-	});
-	(0, import_qunit.test)("a query names a type only where the filter grammar has one", function(assert) {
-		class Activity extends CardDef {}
-		class Classroom extends CardDef {
-			static {
-				decorateFieldV2(this, "listAll", [operation], function() {
-					return {
-						base: "query",
-						query: {
-							filter: { any: [{ type: Activity }, { not: { type: Activity } }] },
-							sort: [{
-								by: "title",
-								on: Activity
-							}]
-						}
-					};
-				});
-			}
-			#listAll = (initializeDeferredDecorator(this, "listAll"), void 0);
-			static {
-				decorateFieldV2(this, "listOpen", [operation], function() {
-					return {
-						base: "query",
-						query: { filter: {
-							on: Activity,
-							eq: { status: "open" }
-						} }
-					};
-				});
-			}
-			#listOpen = (initializeDeferredDecorator(this, "listOpen"), void 0);
-			static {
-				decorateFieldV2(this, "listEvery", [operation], function() {
-					return {
-						base: "query",
-						query: { filter: { every: [{
-							on: Activity,
-							eq: { status: "open" }
-						}, {
-							on: Activity,
-							range: { views: { gt: 10 } }
-						}] } }
-					};
-				});
-			}
-			#listEvery = (initializeDeferredDecorator(this, "listEvery"), void 0);
-			static {
-				decorateFieldV2(this, "listRecent", [operation], function() {
-					return {
-						base: "query",
-						query: { filter: {
-							on: Activity,
-							range: { on: { gt: 1 } }
-						} }
-					};
-				});
-			}
-			#listRecent = (initializeDeferredDecorator(this, "listRecent"), void 0);
-		}
-		let declarations = getDeclaredOperations(Classroom);
-		let queryOf = (name) => declarations[name].query;
-		assert.strictEqual(queryOf("listAll").filter.any[0].type, Activity, "a pure card-type filter names the class itself");
-		assert.strictEqual(queryOf("listEvery").filter.every[0].on, Activity, "and `every` holds filter nodes the same way `any` does");
-		assert.strictEqual(queryOf("listAll").sort[0].on, Activity, "and so does a sort entry");
-		assert.deepEqual(JSON.parse(JSON.stringify(queryOf("listRecent").filter.range)), { on: { gt: 1 } }, "a field named `on` under a predicate is data, not a type slot");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "listSome", [operation], function() {
-						return {
-							base: "query",
-							query: { filter: { eq: {
-								on: Activity,
-								status: "open"
-							} } }
-						};
-					});
-				}
-				#listSome = (initializeDeferredDecorator(this, "listSome"), void 0);
-			}
-			return Report;
-		}, /`query.filter.eq.on` is a function/, "a class under a predicate would lower to nothing and match everything");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "listSome", [operation], function() {
-						return {
-							base: "query",
-							query: { filter: {
-								on: string_default,
-								eq: { a: 1 }
-							} }
-						};
-					});
-				}
-				#listSome = (initializeDeferredDecorator(this, "listSome"), void 0);
-			}
-			return Report;
-		}, /must be a card or file class/, "and a type slot names something that has a type of its own");
-	});
-	(0, import_qunit.test)("a declaration pins the page the realm implements", function(assert) {
-		class Activity extends CardDef {}
-		class Report extends CardDef {
-			static {
-				decorateFieldV2(this, "listRecent", [operation], function() {
-					return {
-						base: "query",
-						query: {
-							filter: { type: Activity },
-							page: {
-								size: 20,
-								number: 1
-							}
-						}
-					};
-				});
-			}
-			#listRecent = (initializeDeferredDecorator(this, "listRecent"), void 0);
-		}
-		assert.deepEqual(JSON.parse(JSON.stringify(getDeclaredOperations(Report).listRecent.query?.page)), {
-			size: 20,
-			number: 1
-		}, "a page is a length and a 0-based offset, which is how the realm pages");
-	});
-	(0, import_qunit.test)("a declared query is checked against the realm grammar itself", function(assert) {
-		class Activity extends CardDef {}
-		class Report extends CardDef {
-			static {
-				decorateFieldV2(this, "search", [operation], function() {
-					return {
-						base: "query",
-						params: { term: string_default },
-						query: {
-							filter: { type: Activity },
-							queryString: params("term")
-						}
-					};
-				});
-			}
-			#search = (initializeDeferredDecorator(this, "search"), void 0);
-		}
-		assert.strictEqual(getDeclaredOperations(Report).search.query.queryString.$ref, "params", "a query carrying a reference is left to the placement rule");
-		assert.throws(() => {
-			class Listing extends CardDef {
-				static {
-					decorateFieldV2(this, "listSome", [operation], function() {
-						return {
-							base: "query",
-							query: { filter: { any: [{ on: Activity }] } }
-						};
-					});
-				}
-				#listSome = (initializeDeferredDecorator(this, "listSome"), void 0);
-			}
-			return Listing;
-		}, /is not a query the realm accepts/, "a filter node with no predicate is not a filter");
-		assert.throws(() => {
-			class Listing extends CardDef {
-				static {
-					decorateFieldV2(this, "listSome", [operation], function() {
-						return {
-							base: "query",
-							query: {
-								filter: { type: Activity },
-								sort: [{ by: "title" }]
-							}
-						};
-					});
-				}
-				#listSome = (initializeDeferredDecorator(this, "listSome"), void 0);
-			}
-			return Listing;
-		}, /is not a query the realm accepts/, "and a sort by a card field names the type it is rooted in");
-		assert.throws(() => {
-			class Listing extends CardDef {
-				static {
-					decorateFieldV2(this, "listSome", [operation], function() {
-						return {
-							base: "query",
-							query: {
-								filter: { type: Activity },
-								queryString: 42
-							}
-						};
-					});
-				}
-				#listSome = (initializeDeferredDecorator(this, "listSome"), void 0);
-			}
-			return Listing;
-		}, /`query.queryString` must be a search term/, "a full-text term is a string, or a reference to one");
-	});
-	(0, import_qunit.test)("a create names what it creates whichever form its work takes", function(assert) {
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "makeOne", [operation], function() {
-						return {
-							base: "create",
-							transformations: bxl`.title = "x";`
-						};
-					});
-				}
-				#makeOne = (initializeDeferredDecorator(this, "makeOne"), void 0);
-			}
-			return Report;
-		}, /needs `of` to name what it creates/, "a program computes fields without saying what kind of card to create");
-	});
-	(0, import_qunit.test)("a marker is identified by a key of its own", function(assert) {
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "escalate", [operation], function() {
-						return {
-							base: "transform",
-							set: { author: Object.create({ $ref: "actor" }) }
-						};
-					});
-				}
-				#escalate = (initializeDeferredDecorator(this, "escalate"), void 0);
-			}
-			return Report;
-		}, /a declaration carries plain objects, arrays and primitives/, "a reference reached through a prototype is not a reference");
-		assert.throws(() => {
-			let reference = { $ref: "card" };
-			reference.value = reference;
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "escalate", [operation], function() {
-						return {
-							base: "transform",
-							set: { owner: reference }
-						};
-					});
-				}
-				#escalate = (initializeDeferredDecorator(this, "escalate"), void 0);
-			}
-			return Report;
-		}, /refers back to a value that contains it/, "and a reference that contains itself is refused, not recursed into");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "addComment", [operation], function() {
-						return {
-							base: "transform",
-							params: { body: string_default },
-							append: {
-								to: "comments",
-								value: { body: {
-									$ref: "params",
-									key: "body",
-									extra: 1
-								} }
-							}
-						};
-					});
-				}
-				#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
-			}
-			return Report;
-		}, /"extra" is not a valid key/, "a reference marker carries only what its constructor puts there");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "addActivity", [operation], function() {
-						return {
-							base: "transform",
-							params: { activity: { $linkTo: string_default } },
-							append: {
-								to: "activities",
-								value: card(params("activity"))
-							}
-						};
-					});
-				}
-				#addActivity = (initializeDeferredDecorator(this, "addActivity"), void 0);
-			}
-			return Report;
-		}, /links to a card or file class/, "a hand-written link marker is held to what linkTo requires");
-	});
-	(0, import_qunit.test)("the bxl tag reports being called as a function", function(assert) {
-		assert.throws(() => bxl([".a = 1;"]), /template tag/, "every reference constructor says what it wanted");
-	});
-	(0, import_qunit.test)("every declaration guard reports what it wanted", function(assert) {
-		let rejected = [
-			[
-				"optimistic",
-				{
-					base: "read",
-					optimistic: "yes"
-				},
-				/`optimistic` must be a boolean/
-			],
-			[
-				"input",
-				{
-					base: "read",
-					input: ".a = 1;"
-				},
-				/`input` must be a program written with the bxl tag/
-			],
-			[
-				"output",
-				{
-					base: "read",
-					output: "title"
-				},
-				/`output` must be a projection object or a bxl program/
-			],
-			[
-				"append not an object",
-				{
-					base: "transform",
-					append: "comments"
-				},
-				/`append` must be an object naming the field/
-			],
-			[
-				"append.to empty",
-				{
-					base: "transform",
-					append: {
-						to: "",
-						value: 1
-					}
-				},
-				/`append.to` must name the collection field/
-			],
-			[
-				"append with no value",
-				{
-					base: "transform",
-					append: { to: "comments" }
-				},
-				/`append` must carry a `value` to append/
-			],
-			[
-				"assert not an object",
-				{
-					base: "transform",
-					assert: "unique"
-				},
-				/`assert` must be an object naming the collection/
-			],
-			[
-				"assert.unique empty",
-				{
-					base: "transform",
-					assert: {
-						unique: "",
-						by: 1
-					}
-				},
-				/`assert.unique` must name the collection field/
-			],
-			[
-				"assert with no by",
-				{
-					base: "transform",
-					assert: { unique: "owners" }
-				},
-				/`assert` must carry a `by` value/
-			],
-			[
-				"assert.message",
-				{
-					base: "transform",
-					assert: {
-						unique: "o",
-						by: 1,
-						message: 2
-					}
-				},
-				/`assert.message` must be a string/
-			],
-			[
-				"set empty",
-				{
-					base: "transform",
-					set: {}
-				},
-				/`set` must be an object mapping field names to values/
-			],
-			[
-				"fill empty",
-				{
-					base: "create",
-					of: CardDef,
-					fill: {}
-				},
-				/`fill` must be an object mapping field names to values/
-			],
-			[
-				"of not a function",
-				{
-					base: "create",
-					of: "Activity"
-				},
-				/`of` must be the card class to create/
-			],
-			[
-				"query not an object",
-				{
-					base: "query",
-					query: "everything"
-				},
-				/`query` must be an object with at least one of/
-			],
-			[
-				"query with an unknown key",
-				{
-					base: "query",
-					query: {
-						filter: { type: CardDef },
-						junk: 1
-					}
-				},
-				/"junk" is not a valid key for `query`/
-			],
-			[
-				"query.page not an object",
-				{
-					base: "query",
-					query: {
-						filter: { type: CardDef },
-						page: 10
-					}
-				},
-				/`query.page` must be an object/
-			],
-			[
-				"query.page with no size",
-				{
-					base: "query",
-					query: {
-						filter: { type: CardDef },
-						page: { number: 1 }
-					}
-				},
-				/`query.page.size` must be a positive integer/
-			],
-			[
-				"query.page.number below zero",
-				{
-					base: "query",
-					query: {
-						filter: { type: CardDef },
-						page: {
-							size: 10,
-							number: -1
-						}
-					}
-				},
-				/`query.page.number` must be a whole number/
-			],
-			[
-				"cursor is not a page key",
-				{
-					base: "query",
-					query: {
-						filter: { type: CardDef },
-						page: {
-							size: 10,
-							cursor: "x"
-						}
-					}
-				},
-				/"cursor" is not a valid key for `query.page`/
-			],
-			[
-				"a params reference with a non-string key",
-				{
-					base: "transform",
-					params: { body: string_default },
-					set: { x: {
-						$ref: "params",
-						key: 1
-					} }
-				},
-				/must name a param/
-			],
-			[
-				"an actor reference carrying a key",
-				{
-					base: "transform",
-					set: { x: {
-						$ref: "actor",
-						key: "id"
-					} }
-				},
-				/carries a key; actor\(\) is the caller's user id and has no members to read/
-			],
-			[
-				"an instance reference with an empty key",
-				{
-					base: "transform",
-					set: { x: {
-						$ref: "instance",
-						key: ""
-					} }
-				},
-				/must name a member, or none at all/
-			],
-			[
-				"a card reference wrapping the caller",
-				{
-					base: "transform",
-					set: { x: {
-						$ref: "card",
-						value: { $ref: "actor" }
-					} }
-				},
-				/`actor\(\)` is the caller's user id rather than a card/
-			],
-			[
-				"a card reference with a non-reference value",
-				{
-					base: "transform",
-					set: { x: {
-						$ref: "card",
-						value: 1
-					} }
-				},
-				/must carry a card URL or a reference to one/
-			]
-		];
-		for (let [name, declaration, pattern] of rejected) assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "candidate", [operation], function() {
-						return declaration;
-					});
-				}
-				#candidate = (initializeDeferredDecorator(this, "candidate"), void 0);
-			}
-			return Report;
-		}, pattern, `a declaration is refused for ${name}`);
-	});
-	(0, import_qunit.test)("the caller is typed as a user id, not as a card", function(assert) {
-		let keyed = () => actor("id");
-		let wrapped = () => card(actor());
-		assert.throws(keyed, /takes no argument/);
-		assert.throws(wrapped, /rather than a card/);
-		assert.deepEqual(actor(), { $ref: "actor" }, "the one form it does have carries nothing but its kind");
-	});
-	(0, import_qunit.test)("every reference constructor reports what it wanted", function(assert) {
-		let rejected = [
-			[
-				"params with no name",
-				() => params(""),
-				/takes the name of a param declared/
-			],
-			[
-				"params with a non-string",
-				() => params(1),
-				/takes the name of a param declared/
-			],
-			[
-				"card with no URL",
-				() => card(""),
-				/takes a card URL or a typed reference to one/
-			],
-			[
-				"card with a non-reference",
-				() => card(1),
-				/takes a card URL or a typed reference to one/
-			],
-			[
-				"linkTo with a non-class",
-				() => linkTo("Activity"),
-				/takes a card class/
-			],
-			[
-				"actor with an argument",
-				() => actor("id"),
-				/actor\(\) takes no argument; it is the caller's user id/
-			],
-			[
-				"card wrapping the caller",
-				() => card(actor()),
-				/`actor\(\)` is the caller's user id rather than a card/
-			],
-			[
-				"instance with a non-string key",
-				() => instance(1),
-				/takes the name of a member to read, or no argument at all/
-			],
-			[
-				"realmConfig with an empty key",
-				() => realmConfig(""),
-				/takes the name of a member to read, or no argument at all/
-			]
-		];
-		for (let [name, build, pattern] of rejected) assert.throws(build, pattern, `${name} is refused`);
-	});
-	(0, import_qunit.test)("a def with no mutation surface carries only its reads", function(assert) {
-		class Bare extends BaseDef {}
-		assert.deepEqual(getOperations(Bare), {
-			read: implied("read"),
-			readSource: implied("readSource")
-		}, "the two reads are what every addressable def shares");
-		assert.throws(() => {
-			class Mutable extends BaseDef {
-				static {
-					decorateFieldV2(this, "escalate", [operation], function() {
-						return {
-							base: "transform",
-							set: { status: "escalated" }
-						};
-					});
-				}
-				#escalate = (initializeDeferredDecorator(this, "escalate"), void 0);
-			}
-			return Mutable;
-		}, /carries only "read", "readSource"/, "and a def that carries no mutation base cannot declare one");
-	});
-	(0, import_qunit.test)("getOperations rejects a target that is not a card definition", function(assert) {
-		assert.throws(() => getDeclaredOperations({}), /getDeclaredOperations\(\) takes a class that extends BaseDef/, "each reader names itself in its own error");
-		assert.throws(() => getOperations({}), /getOperations\(\) takes a class that extends BaseDef/, "operations hang off a definition, so a plain object reads none");
-	});
-	(0, import_qunit.test)("a params reference must name a declared param", function(assert) {
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "addComment", [operation], function() {
-						return {
-							base: "transform",
-							params: { body: string_default },
-							append: {
-								to: "comments",
-								value: { body: params("title") }
-							}
-						};
-					});
-				}
-				#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
-			}
-			return Report;
-		}, /references the param "title"/, "the declared schema is the single source for what the payload carries");
-		assert.throws(() => {
-			class Report extends CardDef {
-				static {
-					decorateFieldV2(this, "addComment", [operation], function() {
-						return {
-							base: "transform",
-							params: { body: "string" },
-							append: {
-								to: "comments",
-								value: { body: params("body") }
-							}
-						};
-					});
-				}
-				#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
-			}
-			return Report;
-		}, /param "body" must be a field class or linkTo/, "a param names the field class that types it");
-	});
-	(0, import_qunit.test)("the declared params schema types the operation payload", function(assert) {
-		class ClassroomActivity extends CardDef {}
-		let addActivity = {
-			base: "transform",
-			params: {
-				note: string_default,
-				activity: linkTo(ClassroomActivity)
-			},
-			append: {
-				to: "activities",
-				value: card(params("activity"))
-			}
-		};
-		let bodyReference = params("body");
-		class Report extends CardDef {
-			static {
-				decorateFieldV2(this, "addComment", [operation], function() {
-					return {
-						base: "transform",
-						params: { body: string_default },
-						append: {
-							to: "comments",
-							value: { body: params("body") }
-						}
-					};
-				});
-			}
-			#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
-		}
-		class Themed extends CardDef {
-			static theme = {
-				base: "dark",
-				accent: "#fff"
-			};
-			static {
-				decorateFieldV2(this, "ping", [operation], function() {
-					return { base: "read" };
-				});
-			}
-			#ping = (initializeDeferredDecorator(this, "ping"), void 0);
-		}
-		assert.deepEqual(Object.keys(getDeclaredOperations(Themed)), ["ping"], "and the reader agrees with the type at run time");
-		class Classroom extends CardDef {
-			static {
-				decorateFieldV2(this, "addActivity", [operation], function() {
-					return addActivity;
-				});
-			}
-			#addActivity = (initializeDeferredDecorator(this, "addActivity"), void 0);
-		}
-		assert.deepEqual(Object.keys(getDeclaredOperations(Classroom).addActivity.params ?? {}), ["note", "activity"], "a scalar param and a link param sit in the same schema");
-		assert.deepEqual(bodyReference, {
-			$ref: "params",
-			key: "body"
-		}, "the key a reference names is carried in the marker and in its type");
-		assert.deepEqual(Object.keys(getDeclaredOperations(Report)), ["addComment"], "a declaration written against the exported types is recorded like any other");
-	});
-});
-//#endregion