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

package/bundled-test-harness/assets/operations-test-79ipSnpM.js

@@ -0,0 +1,2518 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Ui as DEFINITION_FREE_BASE_OPERATIONS } from "./runtime-common-ClpqhbwG.js";
+import "./card-operations-EgX45pFB.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-DPQ0j2MD.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-Dzje0smT.js";
+import "./file-api-DPMJghBY.js";
+import { t as string_default } from "./string-BHZZwNlZ.js";
+import { t as DateField } from "./date-B27PrSFT.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