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

package/bundled-test-harness/assets/operation-lowering-test-CKkamOQt.js

@@ -0,0 +1,2957 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Br as testRealmURL, Fa as maybeHandleScopedCSSRequest, Go as identifyCard, Ka as VirtualNetwork, Ss as definitionKind, Ys as Loader, Za as fetcher, is as loadCardDef, na as DEFINITION_FREE_BASE_OPERATIONS, wi as slotKeyKinds, ws as getFieldDefinitions } from "./runtime-common-BTaLJEw-.js";
+import { O as baseRealm } from "./constants-Icc0nFW-.js";
+import { t as config } from "./environment-DIUJgBKt.js";
+import { t as shimExternals } from "./externals-CDQm-Lm7.js";
+import { t as lowerOperationDeclarations } from "./card-operations-CzugytHO.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { jt as shimTestModule } from "./mock-matrix-FjsXmU7-.js";
+//#region tests/unit/operation-lowering-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var { resolvedBaseRealmURL } = config;
+(0, import_qunit.module)("Unit | operation lowering", function(hooks) {
+	let loader;
+	let api;
+	let operations;
+	let virtualNetwork;
+	let StringField;
+	let NumberField;
+	let fixtures;
+	hooks.beforeEach(async function() {
+		virtualNetwork = new VirtualNetwork();
+		virtualNetwork.addURLMapping(new URL(baseRealm.url), new URL(resolvedBaseRealmURL));
+		virtualNetwork.addRealmMapping("@cardstack/base/", resolvedBaseRealmURL);
+		virtualNetwork.addImportMap("@cardstack/boxel-icons/", (rest) => {
+			return `${config.iconsURL}/@cardstack/boxel-icons/v1/icons/${rest}.js`;
+		});
+		shimExternals(virtualNetwork);
+		loader = new Loader(fetcher(virtualNetwork.fetch, [async (req, next) => {
+			return await maybeHandleScopedCSSRequest(req) || next(req);
+		}]), virtualNetwork.resolveImport, { virtualNetwork });
+		api = await loader.import("@cardstack/base/card-api");
+		operations = await loader.import("@cardstack/base/operations");
+		({default: StringField} = await loader.import("@cardstack/base/string"));
+		({default: NumberField} = await loader.import("@cardstack/base/number"));
+		let { field, contains, linksTo, linksToMany, CardDef, FieldDef } = api;
+		class Author extends CardDef {
+			static displayName = "Author";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		class Address extends FieldDef {
+			static displayName = "Address";
+			static {
+				decorateFieldV2(this.prototype, "city", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#city = (initializeDeferredDecorator(this, "city"), void 0);
+		}
+		class Comment extends FieldDef {
+			static displayName = "Comment";
+			static {
+				decorateFieldV2(this.prototype, "body", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#body = (initializeDeferredDecorator(this, "body"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "postedBy", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#postedBy = (initializeDeferredDecorator(this, "postedBy"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "author", [field], function() {
+					return linksTo(() => Author);
+				});
+			}
+			#author = (initializeDeferredDecorator(this, "author"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "where", [field], function() {
+					return contains(Address);
+				});
+			}
+			#where = (initializeDeferredDecorator(this, "where"), void 0);
+		}
+		class Activity extends CardDef {
+			static displayName = "Activity";
+			static {
+				decorateFieldV2(this.prototype, "label", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#label = (initializeDeferredDecorator(this, "label"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "postedBy", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#postedBy = (initializeDeferredDecorator(this, "postedBy"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "owner", [field], function() {
+					return linksTo(() => Author);
+				});
+			}
+			#owner = (initializeDeferredDecorator(this, "owner"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "witnesses", [field], function() {
+					return linksToMany(() => Author);
+				});
+			}
+			#witnesses = (initializeDeferredDecorator(this, "witnesses"), void 0);
+		}
+		shim({
+			Author,
+			Address,
+			Comment,
+			Activity
+		});
+		fixtures = {
+			Author,
+			Comment,
+			Activity
+		};
+	});
+	function shim(exports) {
+		for (let [name, def] of Object.entries(exports)) shimTestModule(loader, `${testRealmURL}${name.toLowerCase()}`, { [name]: def });
+	}
+	function buildDefinition(def) {
+		let { fields, fieldDefs } = getFieldDefinitions(api, def);
+		return {
+			codeRef: identifyCard(def),
+			displayName: def.displayName ?? null,
+			fields,
+			fieldDefs,
+			type: definitionKind(def)
+		};
+	}
+	async function lookupDefinition(codeRef) {
+		try {
+			return buildDefinition(await loadCardDef(codeRef, { loader }));
+		} catch {
+			return;
+		}
+	}
+	async function lower(def) {
+		return await lowerOperationDeclarations(operations.getDeclaredOperations(def), {
+			definition: buildDefinition(def),
+			lookupDefinition,
+			identifyCard: (target) => identifyCard(target)
+		});
+	}
+	function codes(result) {
+		return result.issues.map((issue) => issue.code);
+	}
+	(0, import_qunit.test)("append lowers to an append statement, with a link-typed member as a card identity", async function(assert) {
+		let { field, contains, containsMany, CardDef } = api;
+		let { operation, params, actor, linkTo } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "comments", [field], function() {
+					return containsMany(fixtures.Comment);
+				});
+			}
+			#comments = (initializeDeferredDecorator(this, "comments"), void 0);
+			static {
+				decorateFieldV2(this, "addComment", [operation], function() {
+					return {
+						base: "transform",
+						params: {
+							body: StringField,
+							author: linkTo(() => fixtures.Author)
+						},
+						append: {
+							to: "comments",
+							value: {
+								body: params("body"),
+								postedBy: actor(),
+								author: params("author")
+							}
+						}
+					};
+				});
+			}
+			#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
+		}
+		shim({ Report });
+		let { operations: lowered, issues } = await lower(Report);
+		assert.deepEqual(issues, [], "the declaration lowers cleanly");
+		assert.deepEqual(lowered.addComment, {
+			base: "transform",
+			params: {
+				body: {
+					kind: "field",
+					codeRef: identifyCard(StringField)
+				},
+				author: {
+					kind: "link",
+					codeRef: identifyCard(fixtures.Author)
+				}
+			},
+			program: {
+				source: "append(.comments;{body:params(\"body\"),postedBy:actor(),author:card(params(\"author\"))});",
+				syntax: "solidified"
+			},
+			deterministic: true,
+			readsActor: true
+		}, "a link-typed member becomes a card identity while a scalar one stays the bare builtin, and a program naming the actor says so");
+	});
+	(0, import_qunit.test)("an actor in a link position is an authoring issue, not a spelling the lowering repairs", async function(assert) {
+		let { field, contains, containsMany, linksTo, CardDef } = api;
+		let { operation, actor } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "owner", [field], function() {
+					return linksTo(() => fixtures.Author);
+				});
+			}
+			#owner = (initializeDeferredDecorator(this, "owner"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "comments", [field], function() {
+					return containsMany(fixtures.Comment);
+				});
+			}
+			#comments = (initializeDeferredDecorator(this, "comments"), void 0);
+			static {
+				decorateFieldV2(this, "claim", [operation], function() {
+					return {
+						base: "transform",
+						set: { owner: actor() }
+					};
+				});
+			}
+			#claim = (initializeDeferredDecorator(this, "claim"), void 0);
+			static {
+				decorateFieldV2(this, "addComment", [operation], function() {
+					return {
+						base: "transform",
+						append: {
+							to: "comments",
+							value: { author: actor() }
+						}
+					};
+				});
+			}
+			#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
+		}
+		shim({ Report });
+		let result = await lower(Report);
+		assert.deepEqual(codes(result), ["actor-not-a-card", "actor-not-a-card"]);
+		assert.deepEqual(result.issues.map((issue) => issue.path), ["set.owner", "append.value.author"], "both the field itself and a member of a contained value are reached");
+		assert.true(result.issues[0].message.includes("linkTo(…)"), "the message names the declaration that does express a link to a person");
+		assert.true(result.operations.claim.invalid, "an operation carrying the issue reports it rather than running");
+	});
+	(0, import_qunit.test)("a create fills a link field with a card identity, and the caller is not one", async function(assert) {
+		let { field, contains, CardDef } = api;
+		let { operation, actor } = operations;
+		class Classroom extends CardDef {
+			static displayName = "Classroom";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this, "addActivity", [operation], function() {
+					return {
+						base: "create",
+						of: () => fixtures.Activity,
+						fill: { owner: actor() }
+					};
+				});
+			}
+			#addActivity = (initializeDeferredDecorator(this, "addActivity"), void 0);
+			static {
+				decorateFieldV2(this, "addWitnessed", [operation], function() {
+					return {
+						base: "create",
+						of: () => fixtures.Activity,
+						fill: { witnesses: [actor()] }
+					};
+				});
+			}
+			#addWitnessed = (initializeDeferredDecorator(this, "addWitnessed"), void 0);
+		}
+		shim({ Classroom });
+		let result = await lower(Classroom);
+		assert.deepEqual(result.issues.map((issue) => [issue.code, issue.path]), [["actor-not-a-card", "fill.owner"], ["actor-not-a-card", "fill.witnesses[0]"]], "a link collection is filled with a list, so every entry is an identity too");
+	});
+	(0, import_qunit.test)("set lowers to one assignment per field, and a scalar reference stays a bare builtin", async function(assert) {
+		let { field, contains, CardDef } = api;
+		let { operation, params, actor } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "status", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#status = (initializeDeferredDecorator(this, "status"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "closedBy", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#closedBy = (initializeDeferredDecorator(this, "closedBy"), void 0);
+			static {
+				decorateFieldV2(this, "close", [operation], function() {
+					return {
+						base: "transform",
+						params: { note: StringField },
+						set: {
+							status: "closed",
+							closedBy: actor(),
+							"cardInfo.notes": params("note")
+						}
+					};
+				});
+			}
+			#close = (initializeDeferredDecorator(this, "close"), void 0);
+		}
+		shim({ Report });
+		let { operations: lowered, issues } = await lower(Report);
+		assert.deepEqual(issues, [], "the declaration lowers cleanly");
+		assert.strictEqual(lowered.close.program?.source, [
+			".status=\"closed\";",
+			".closedBy=actor();",
+			".cardInfo.notes=params(\"note\");"
+		].join("\n"), "a scalar field reads the builtin directly");
+	});
+	(0, import_qunit.test)("assert lowers to a uniqueness precondition keyed by the collection kind", async function(assert) {
+		let { field, contains, containsMany, linksToMany, CardDef } = api;
+		let { operation, params, actor } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "tags", [field], function() {
+					return containsMany(StringField);
+				});
+			}
+			#tags = (initializeDeferredDecorator(this, "tags"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "reviewers", [field], function() {
+					return linksToMany(() => fixtures.Author, { searchable: true });
+				});
+			}
+			#reviewers = (initializeDeferredDecorator(this, "reviewers"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this, "addTag", [operation], function() {
+					return {
+						base: "transform",
+						params: { tag: StringField },
+						assert: {
+							unique: "tags",
+							by: params("tag"),
+							message: "already tagged"
+						},
+						append: {
+							to: "tags",
+							value: params("tag")
+						}
+					};
+				});
+			}
+			#addTag = (initializeDeferredDecorator(this, "addTag"), void 0);
+			static {
+				decorateFieldV2(this, "addReviewer", [operation], function() {
+					return {
+						base: "transform",
+						params: { who: StringField },
+						assert: {
+							unique: "reviewers",
+							by: params("who"),
+							snapshot: true
+						}
+					};
+				});
+			}
+			#addReviewer = (initializeDeferredDecorator(this, "addReviewer"), void 0);
+			static {
+				decorateFieldV2(this, "claimReview", [operation], function() {
+					return {
+						base: "transform",
+						assert: {
+							unique: "reviewers",
+							by: actor(),
+							snapshot: true
+						}
+					};
+				});
+			}
+			#claimReview = (initializeDeferredDecorator(this, "claimReview"), void 0);
+			static {
+				decorateFieldV2(this, "tagSelf", [operation], function() {
+					return {
+						base: "transform",
+						assert: {
+							unique: "tags",
+							by: actor()
+						},
+						append: {
+							to: "tags",
+							value: actor()
+						}
+					};
+				});
+			}
+			#tagSelf = (initializeDeferredDecorator(this, "tagSelf"), void 0);
+		}
+		shim({ Report });
+		let { operations: lowered, issues } = await lower(Report);
+		assert.deepEqual(issues.map((issue) => [issue.code, issue.path]), [["actor-not-a-card", "assert.by"]], "only the comparison against a link collection is refused");
+		assert.strictEqual(lowered.addTag.program?.source, ["assert(all(.tags[];.!=params(\"tag\"));\"already tagged\");", "append(.tags;params(\"tag\"));"].join("\n"), "a contained collection compares the item itself, and the precondition runs before the write");
+		assert.strictEqual(lowered.addReviewer.program?.source, "assert(all(.reviewers[];.id!=params(\"who\"));\"reviewers already holds this value\");", "a link collection compares the linked card id against the identity itself — not against a card() projection — and an omitted message gets a default");
+		assert.strictEqual(lowered.tagSelf.program?.source, ["assert(all(.tags[];.!=actor());\"tags already holds this value\");", "append(.tags;actor());"].join("\n"), "a contained collection compares the caller id against the item itself");
+		assert.true(lowered.claimReview.invalid, "while a link collection compares against a linked card id, which the caller is not");
+		assert.true(lowered.addReviewer.snapshot, "the gathering the author opted into travels with the program that needs it");
+		assert.strictEqual(lowered.addTag.snapshot, void 0, "while an assert the stored document can answer asks for none");
+	});
+	(0, import_qunit.test)("a create lowers `of` to a code ref and keeps `fill` a marker-carrying template", async function(assert) {
+		let { field, contains, CardDef } = api;
+		let { operation, params, actor, linkTo } = operations;
+		class Classroom extends CardDef {
+			static displayName = "Classroom";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this, "addActivity", [operation], function() {
+					return {
+						base: "create",
+						params: {
+							label: StringField,
+							teacher: linkTo(() => fixtures.Author)
+						},
+						of: () => fixtures.Activity,
+						fill: {
+							label: params("label"),
+							postedBy: actor()
+						}
+					};
+				});
+			}
+			#addActivity = (initializeDeferredDecorator(this, "addActivity"), void 0);
+		}
+		shim({ Classroom });
+		let { operations: lowered, issues } = await lower(Classroom);
+		assert.deepEqual(issues, [], "the declaration lowers cleanly");
+		assert.deepEqual(lowered.addActivity, {
+			base: "create",
+			params: {
+				label: {
+					kind: "field",
+					codeRef: identifyCard(StringField)
+				},
+				teacher: {
+					kind: "link",
+					codeRef: identifyCard(fixtures.Author)
+				}
+			},
+			of: identifyCard(fixtures.Activity),
+			fill: {
+				label: {
+					$ref: "params",
+					key: "label"
+				},
+				postedBy: { $ref: "actor" }
+			},
+			deterministic: true,
+			readsActor: true
+		}, "a linkTo param is a link entry, fill stays data for the coordinator to substitute, and an actor marker inside it is reported the same as one in a program");
+	});
+	(0, import_qunit.test)("a query lowers to an entry-wire query template with code refs in the type slots", async function(assert) {
+		let { field, contains, CardDef } = api;
+		let { operation, actor, params } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this, "mine", [operation], function() {
+					return {
+						base: "query",
+						params: { term: StringField },
+						query: {
+							filter: {
+								on: () => fixtures.Author,
+								eq: { name: actor() }
+							},
+							sort: [{
+								by: "name",
+								on: () => fixtures.Author,
+								direction: "desc"
+							}],
+							page: {
+								size: 20,
+								number: 0
+							},
+							queryString: params("term"),
+							realms: [testRealmURL]
+						}
+					};
+				});
+			}
+			#mine = (initializeDeferredDecorator(this, "mine"), void 0);
+		}
+		shim({ Report });
+		let { operations: lowered, issues } = await lower(Report);
+		assert.deepEqual(issues, [], "the declaration lowers cleanly");
+		assert.deepEqual(lowered.mine.query, {
+			filter: { every: [{
+				"item.on": identifyCard(fixtures.Author),
+				eq: { "item.name": { $ref: "actor" } }
+			}, { matches: {
+				$ref: "params",
+				key: "term"
+			} }] },
+			sort: [{
+				by: "item.name",
+				"item.on": identifyCard(fixtures.Author),
+				direction: "desc"
+			}],
+			page: {
+				size: 20,
+				number: 0
+			},
+			realms: [testRealmURL]
+		}, "the type anchors resolve to code refs, field paths gain item. addressing, and the declared term becomes a matches conjunct");
+	});
+	(0, import_qunit.test)("a raw program is canonicalized rather than stored as written", async function(assert) {
+		let { field, contains, CardDef } = api;
+		let { operation, bxl } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "status", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#status = (initializeDeferredDecorator(this, "status"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "revision", [field], function() {
+					return contains(NumberField);
+				});
+			}
+			#revision = (initializeDeferredDecorator(this, "revision"), void 0);
+			static {
+				decorateFieldV2(this, "escalate", [operation], function() {
+					return {
+						base: "transform",
+						transformations: bxl`.status = "escalated"; .revision = IF(.revision = null; 1; .revision + 1);`
+					};
+				});
+			}
+			#escalate = (initializeDeferredDecorator(this, "escalate"), void 0);
+		}
+		shim({ Report });
+		let { operations: lowered, issues } = await lower(Report);
+		assert.deepEqual(issues, [], "the program parses");
+		assert.deepEqual(lowered.escalate.program, {
+			source: ".status=\"escalated\";\n.revision=IF(.revision==null;1;.revision+1);",
+			syntax: "solidified"
+		}, "the author's Excel-style comparison is stored in canonical form");
+	});
+	(0, import_qunit.test)("an output projection lowers to the program it describes", async function(assert) {
+		let { field, contains, CardDef } = api;
+		let { operation, actor } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this, "read", [operation], function() {
+					return {
+						base: "read",
+						output: { label: actor() }
+					};
+				});
+			}
+			#read = (initializeDeferredDecorator(this, "read"), void 0);
+		}
+		shim({ Report });
+		let { operations: lowered, issues } = await lower(Report);
+		assert.deepEqual(issues, [], "the projection lowers cleanly");
+		assert.deepEqual(lowered.read, {
+			base: "read",
+			output: {
+				source: "{label:actor()}",
+				syntax: "solidified"
+			},
+			deterministic: true,
+			readsActor: true
+		}, "a declarative projection and a raw program reach the realm in one form, and a projection reading the actor is reported like any other stage");
+	});
+	(0, import_qunit.test)("an author-supplied optimistic flag is carried through", async function(assert) {
+		let { field, contains, CardDef } = api;
+		let { operation } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "status", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#status = (initializeDeferredDecorator(this, "status"), void 0);
+			static {
+				decorateFieldV2(this, "close", [operation], function() {
+					return {
+						base: "transform",
+						optimistic: false,
+						set: { status: "closed" }
+					};
+				});
+			}
+			#close = (initializeDeferredDecorator(this, "close"), void 0);
+		}
+		shim({ Report });
+		let { operations: lowered } = await lower(Report);
+		assert.false(lowered.close.optimistic, "the author's override reaches the client unchanged");
+	});
+	(0, import_qunit.test)("a non-grantable declaration is carried through, and nothing else is marked", async function(assert) {
+		let { field, contains, containsMany, CardDef } = api;
+		let { operation } = operations;
+		class Ledger extends CardDef {
+			static displayName = "Ledger";
+			static {
+				decorateFieldV2(this.prototype, "status", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#status = (initializeDeferredDecorator(this, "status"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "entries", [field], function() {
+					return containsMany(StringField);
+				});
+			}
+			#entries = (initializeDeferredDecorator(this, "entries"), void 0);
+			static {
+				decorateFieldV2(this, "seal", [operation], function() {
+					return {
+						base: "transform",
+						nonGrantable: true,
+						set: { status: "sealed" }
+					};
+				});
+			}
+			#seal = (initializeDeferredDecorator(this, "seal"), void 0);
+			static {
+				decorateFieldV2(this, "reopen", [operation], function() {
+					return {
+						base: "transform",
+						set: { status: "open" }
+					};
+				});
+			}
+			#reopen = (initializeDeferredDecorator(this, "reopen"), void 0);
+			static {
+				decorateFieldV2(this, "appendContainsMany", [operation], function() {
+					return {
+						base: "appendContainsMany",
+						nonGrantable: true
+					};
+				});
+			}
+			#appendContainsMany = (initializeDeferredDecorator(this, "appendContainsMany"), void 0);
+			static {
+				decorateFieldV2(this, "broken", [operation], function() {
+					return {
+						base: "transform",
+						nonGrantable: true,
+						set: { missing: "x" }
+					};
+				});
+			}
+			#broken = (initializeDeferredDecorator(this, "broken"), void 0);
+		}
+		shim({ Ledger });
+		let { operations: lowered, issues } = await lower(Ledger);
+		assert.deepEqual(issues.map((issue) => `${issue.operation}: ${issue.code}`), ["broken: unknown-field"], "only the declaration naming a missing field has findings");
+		assert.true(lowered.seal.nonGrantable, "the flag reaches the realm");
+		assert.false("nonGrantable" in lowered.reopen, "a declaration that does not ask carries no flag");
+		assert.deepEqual(lowered.appendContainsMany, {
+			base: "appendContainsMany",
+			deterministic: true,
+			nonGrantable: true
+		}, "the built-in append, marked, lowers to no items, which the executor reads as the built-in");
+		assert.true(lowered.broken.invalid, "the broken declaration is invalid");
+		assert.true(lowered.broken.nonGrantable, "and a finding against it does not make it grantable");
+	});
+	(0, import_qunit.test)("a label is lowered onto the entry as written, on every base", async function(assert) {
+		let { field, contains, containsMany, CardDef } = api;
+		let { operation } = operations;
+		class Inbox extends CardDef {
+			static displayName = "Inbox";
+			static {
+				decorateFieldV2(this.prototype, "status", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#status = (initializeDeferredDecorator(this, "status"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "notes", [field], function() {
+					return containsMany(StringField);
+				});
+			}
+			#notes = (initializeDeferredDecorator(this, "notes"), void 0);
+			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, "read", [operation], function() {
+					return {
+						base: "read",
+						label: "Read your inbox"
+					};
+				});
+			}
+			#read = (initializeDeferredDecorator(this, "read"), void 0);
+			static {
+				decorateFieldV2(this, "appendContainsMany", [operation], function() {
+					return {
+						base: "appendContainsMany",
+						label: "Add a note"
+					};
+				});
+			}
+			#appendContainsMany = (initializeDeferredDecorator(this, "appendContainsMany"), void 0);
+			static {
+				decorateFieldV2(this, "reopen", [operation], function() {
+					return {
+						base: "transform",
+						set: { status: "open" }
+					};
+				});
+			}
+			#reopen = (initializeDeferredDecorator(this, "reopen"), void 0);
+		}
+		shim({ Inbox });
+		let { operations: lowered, issues } = await lower(Inbox);
+		assert.deepEqual(issues, [], "a valid label is no finding");
+		assert.strictEqual(lowered.archive.label, "Archive this inbox");
+		assert.strictEqual(lowered.read.label, "Read your inbox");
+		assert.deepEqual(lowered.appendContainsMany, {
+			base: "appendContainsMany",
+			deterministic: true,
+			label: "Add a note"
+		}, "the label rides beside the rest of the lowered declaration");
+		assert.false("label" in lowered.reopen, "a declaration without a label lowers exactly as before");
+		let context = {
+			definition: buildDefinition(Inbox),
+			lookupDefinition,
+			identifyCard: (target) => identifyCard(target)
+		};
+		let refused = await lowerOperationDeclarations({
+			empty: {
+				base: "update",
+				label: "  "
+			},
+			long: {
+				base: "update",
+				label: "x".repeat(81)
+			},
+			markup: {
+				base: "update",
+				label: "<b>Archive</b>"
+			},
+			multiline: {
+				base: "update",
+				label: "Archive\nthis inbox"
+			},
+			notText: {
+				base: "update",
+				label: 42
+			}
+		}, context);
+		assert.deepEqual(refused.issues.map((issue) => `${issue.operation} ${issue.path}: ${issue.code}`), [
+			"empty label: invalid-label",
+			"long label: invalid-label",
+			"markup label: invalid-label",
+			"multiline label: invalid-label",
+			"notText label: invalid-label"
+		]);
+		for (let name of Object.keys(refused.operations)) {
+			assert.true(refused.operations[name].invalid, `${name} is invalid`);
+			assert.false("label" in refused.operations[name], `${name} stores no label`);
+			assert.deepEqual(refused.operations[name].issues?.map((issue) => issue.code), ["invalid-label"], `${name} carries its finding`);
+		}
+	});
+	(0, import_qunit.test)("an explain lowers to its params, and is non-grantable whatever reaches lowering", async function(assert) {
+		let { CardDef } = api;
+		let { operation } = operations;
+		class Policy extends CardDef {
+			static displayName = "Policy";
+			static {
+				decorateFieldV2(this, "explain", [operation], function() {
+					return {
+						base: "explain",
+						params: {
+							actor: StringField,
+							target: StringField,
+							operation: StringField
+						},
+						nonGrantable: true
+					};
+				});
+			}
+			#explain = (initializeDeferredDecorator(this, "explain"), void 0);
+		}
+		shim({ Policy });
+		let { operations: lowered, issues } = await lower(Policy);
+		assert.deepEqual(issues, [], "the declaration lowers clean");
+		assert.strictEqual(lowered.explain.base, "explain");
+		assert.deepEqual(Object.keys(lowered.explain.params ?? {}).sort(), [
+			"actor",
+			"operation",
+			"target"
+		], "the question travels as declared params");
+		assert.true(lowered.explain.nonGrantable, "the flag reaches the realm");
+		let context = {
+			definition: buildDefinition(Policy),
+			lookupDefinition,
+			identifyCard: (target) => identifyCard(target)
+		};
+		let unmarked = await lowerOperationDeclarations({ explain: { base: "explain" } }, context);
+		assert.true(unmarked.operations.explain.nonGrantable, "an explain is never grantable, flag or no flag");
+		let projected = await lowerOperationDeclarations({ explain: {
+			base: "explain",
+			nonGrantable: true,
+			output: { decision: { $bxl: ".decision" } }
+		} }, context);
+		assert.deepEqual(codes(projected), ["unrunnable-program"], "a projection over the explanation is recorded as never reached");
+		assert.true(projected.operations.explain.invalid);
+	});
+	(0, import_qunit.test)("a validate lowers with no payload, and is non-grantable whatever reaches lowering", async function(assert) {
+		let { CardDef } = api;
+		let { operation } = operations;
+		class Policy extends CardDef {
+			static displayName = "Policy";
+			static {
+				decorateFieldV2(this, "validate", [operation], function() {
+					return {
+						base: "validate",
+						nonGrantable: true
+					};
+				});
+			}
+			#validate = (initializeDeferredDecorator(this, "validate"), void 0);
+		}
+		shim({ Policy });
+		let { operations: lowered, issues } = await lower(Policy);
+		assert.deepEqual(issues, [], "the declaration lowers clean");
+		assert.strictEqual(lowered.validate.base, "validate");
+		assert.true(lowered.validate.nonGrantable, "the flag reaches the realm");
+		let context = {
+			definition: buildDefinition(Policy),
+			lookupDefinition,
+			identifyCard: (target) => identifyCard(target)
+		};
+		let unmarked = await lowerOperationDeclarations({ validate: { base: "validate" } }, context);
+		assert.true(unmarked.operations.validate.nonGrantable, "a validate is never grantable, flag or no flag");
+		let projected = await lowerOperationDeclarations({ validate: {
+			base: "validate",
+			nonGrantable: true,
+			output: { issues: { $bxl: ".issues" } }
+		} }, context);
+		assert.deepEqual(codes(projected), ["unrunnable-program"], "a projection over the validation is recorded as never reached");
+		assert.true(projected.operations.validate.invalid);
+		let withPayload = await lowerOperationDeclarations({ validate: {
+			base: "validate",
+			nonGrantable: true,
+			params: { realm: { type: "string" } },
+			input: { $bxl: "{ strict: true }" }
+		} }, context);
+		assert.deepEqual(withPayload.issues.map((issue) => [issue.code, issue.path]), [["unrunnable-program", "params"], ["unrunnable-program", "input"]], "a payload stage on a validate is recorded as never read");
+		assert.strictEqual(withPayload.operations.validate.params, void 0, "and no payload schema is stored for one");
+		assert.strictEqual(withPayload.operations.validate.input, void 0);
+	});
+	(0, import_qunit.test)("an appendLine on a file def lowers to its payload and nothing else", async function(assert) {
+		let { FileDef } = api;
+		let { operation } = operations;
+		class LogFile extends FileDef {
+			static displayName = "LogFile";
+			static {
+				decorateFieldV2(this, "record", [operation], function() {
+					return {
+						base: "appendLine",
+						params: { line: StringField }
+					};
+				});
+			}
+			#record = (initializeDeferredDecorator(this, "record"), void 0);
+		}
+		shim({ LogFile });
+		let { operations: lowered, issues } = await lower(LogFile);
+		assert.deepEqual(issues, [], "the declaration lowers cleanly");
+		assert.deepEqual(lowered.record, {
+			base: "appendLine",
+			params: { line: {
+				kind: "field",
+				codeRef: identifyCard(StringField)
+			} },
+			deterministic: true
+		}, "there is no program: the base operation appends the line the payload carries");
+	});
+	(0, import_qunit.test)("an appendContainsMany keeps its item a marker-carrying template, per field", async function(assert) {
+		let { field, contains, containsMany, CardDef } = api;
+		let { operation, params, linkTo } = operations;
+		class EventLog extends CardDef {
+			static displayName = "EventLog";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "events", [field], function() {
+					return containsMany(fixtures.Comment);
+				});
+			}
+			#events = (initializeDeferredDecorator(this, "events"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "labels", [field], function() {
+					return containsMany(StringField);
+				});
+			}
+			#labels = (initializeDeferredDecorator(this, "labels"), void 0);
+			static {
+				decorateFieldV2(this, "log", [operation], function() {
+					return {
+						base: "appendContainsMany",
+						params: {
+							body: StringField,
+							author: linkTo(() => fixtures.Author)
+						},
+						field: "events",
+						item: {
+							body: params("body"),
+							author: params("author")
+						}
+					};
+				});
+			}
+			#log = (initializeDeferredDecorator(this, "log"), void 0);
+			static {
+				decorateFieldV2(this, "logBoth", [operation], function() {
+					return {
+						base: "appendContainsMany",
+						params: {
+							body: StringField,
+							label: StringField
+						},
+						fields: {
+							events: { body: params("body") },
+							labels: params("label")
+						}
+					};
+				});
+			}
+			#logBoth = (initializeDeferredDecorator(this, "logBoth"), void 0);
+		}
+		shim({ EventLog });
+		let { operations: lowered, issues } = await lower(EventLog);
+		assert.deepEqual(issues, [], "both declarations lower cleanly");
+		assert.deepEqual(lowered.log.items, { events: {
+			body: {
+				$ref: "params",
+				key: "body"
+			},
+			author: {
+				$ref: "params",
+				key: "author"
+			}
+		} }, "the item reaches the realm as data to substitute into the stored file, not as a program");
+		assert.strictEqual(lowered.log.program, void 0, "an append runs no BXL at all");
+		assert.deepEqual(lowered.logBoth.items, {
+			events: { body: {
+				$ref: "params",
+				key: "body"
+			} },
+			labels: {
+				$ref: "params",
+				key: "label"
+			}
+		}, "each named field carries its own item, and a collection of primitives takes a bare value");
+	});
+	(0, import_qunit.test)("an item member is lowered against the field it lands in", async function(assert) {
+		let { field, containsMany, CardDef } = api;
+		let { operation, actor } = operations;
+		class EventLog extends CardDef {
+			static displayName = "EventLog";
+			static {
+				decorateFieldV2(this.prototype, "events", [field], function() {
+					return containsMany(fixtures.Comment);
+				});
+			}
+			#events = (initializeDeferredDecorator(this, "events"), void 0);
+			static {
+				decorateFieldV2(this, "log", [operation], function() {
+					return {
+						base: "appendContainsMany",
+						field: "events",
+						item: {
+							body: actor(),
+							author: actor()
+						}
+					};
+				});
+			}
+			#log = (initializeDeferredDecorator(this, "log"), void 0);
+		}
+		shim({ EventLog });
+		let result = await lower(EventLog);
+		assert.deepEqual(result.issues.map((issue) => [issue.code, issue.path]), [["actor-not-a-card", "item.author"]], "only the member whose field is a link is refused");
+		assert.deepEqual(result.operations.log.items, { events: {
+			body: { $ref: "actor" },
+			author: { $ref: "actor" }
+		} }, "and both are stored as written, so invoking it reports the finding");
+	});
+	(0, import_qunit.test)("a realmConfig reference lowers to the builtin in a program and stays a marker in a template", async function(assert) {
+		let { field, contains, containsMany, CardDef } = api;
+		let { operation, realmConfig } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "status", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#status = (initializeDeferredDecorator(this, "status"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "tags", [field], function() {
+					return containsMany(StringField);
+				});
+			}
+			#tags = (initializeDeferredDecorator(this, "tags"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "events", [field], function() {
+					return containsMany(fixtures.Comment);
+				});
+			}
+			#events = (initializeDeferredDecorator(this, "events"), void 0);
+			static {
+				decorateFieldV2(this, "escalate", [operation], function() {
+					return {
+						base: "transform",
+						set: { status: realmConfig("escalatedStatus") },
+						append: {
+							to: "tags",
+							value: realmConfig()
+						}
+					};
+				});
+			}
+			#escalate = (initializeDeferredDecorator(this, "escalate"), void 0);
+			static {
+				decorateFieldV2(this, "logDefault", [operation], function() {
+					return {
+						base: "appendContainsMany",
+						field: "events",
+						item: { body: realmConfig("defaultNote") }
+					};
+				});
+			}
+			#logDefault = (initializeDeferredDecorator(this, "logDefault"), void 0);
+			static {
+				decorateFieldV2(this, "open", [operation], function() {
+					return {
+						base: "create",
+						of: () => fixtures.Activity,
+						fill: { label: realmConfig("defaultLabel") }
+					};
+				});
+			}
+			#open = (initializeDeferredDecorator(this, "open"), void 0);
+		}
+		shim({ Report });
+		let { operations: lowered, issues } = await lower(Report);
+		assert.deepEqual(issues, [], "a setting name is never checked here");
+		assert.strictEqual(lowered.escalate.program?.source, ".status=realmConfig(\"escalatedStatus\");\nappend(.tags;realmConfig());", "the marker lowers to the builtin of the same name, with and without a setting to read");
+		assert.deepEqual(lowered.logDefault.items, { events: { body: {
+			$ref: "realmConfig",
+			key: "defaultNote"
+		} } }, "a template carries the marker rather than a value, since which realm the operation runs in is not known here");
+		assert.deepEqual(lowered.open.fill, { label: {
+			$ref: "realmConfig",
+			key: "defaultLabel"
+		} }, "the same in a create");
+		assert.true(lowered.escalate.deterministic, "a realm setting is fixed for a given request, the way the rest of the context is");
+	});
+	(0, import_qunit.test)("a volatile call makes an operation non-deterministic; the request context does not", async function(assert) {
+		let { field, contains, CardDef } = api;
+		let { operation, params, actor, bxl } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this, "stamped", [operation], function() {
+					return {
+						base: "read",
+						output: bxl`{ label: .title, at: TODAY() }`
+					};
+				});
+			}
+			#stamped = (initializeDeferredDecorator(this, "stamped"), void 0);
+			static {
+				decorateFieldV2(this, "contextual", [operation], function() {
+					return {
+						base: "transform",
+						params: { note: StringField },
+						set: { title: params("note") },
+						output: { who: actor() }
+					};
+				});
+			}
+			#contextual = (initializeDeferredDecorator(this, "contextual"), void 0);
+		}
+		shim({ Report });
+		let { operations: lowered } = await lower(Report);
+		assert.false(lowered.stamped.deterministic, "TODAY() yields a different value on every run, so the ledger cannot replay it locally");
+		assert.true(lowered.contextual.deterministic, "params(), actor() and instance() are fixed for a given request");
+	});
+	(0, import_qunit.test)("a field named after a volatile builtin is not read as a call", async function(assert) {
+		let { field, contains, CardDef } = api;
+		let { operation } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "today", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#today = (initializeDeferredDecorator(this, "today"), void 0);
+			static {
+				decorateFieldV2(this, "touch", [operation], function() {
+					return {
+						base: "transform",
+						set: { today: "noted" }
+					};
+				});
+			}
+			#touch = (initializeDeferredDecorator(this, "touch"), void 0);
+		}
+		shim({ Report });
+		let { operations: lowered } = await lower(Report);
+		assert.strictEqual(lowered.touch.program?.source, ".today=\"noted\";");
+		assert.true(lowered.touch.deterministic, "a field access is not a volatile call");
+	});
+	(0, import_qunit.test)("a clause naming a field the type does not have is recorded", async function(assert) {
+		let { field, contains, CardDef } = api;
+		let { operation } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this, "close", [operation], function() {
+					return {
+						base: "transform",
+						set: { staus: "closed" }
+					};
+				});
+			}
+			#close = (initializeDeferredDecorator(this, "close"), void 0);
+		}
+		shim({ Report });
+		let result = await lower(Report);
+		assert.deepEqual(codes(result), ["unknown-field"]);
+		assert.strictEqual(result.issues[0].operation, "close");
+		assert.strictEqual(result.issues[0].path, "set.staus");
+		assert.strictEqual(result.issues[0].message, "\"staus\" is not a field of this type");
+		let lowered = result.operations.close;
+		assert.true(lowered.invalid, "the operation is stored flagged invalid, so invoking it reports the problem rather than reading as unknown");
+		assert.deepEqual(lowered.issues, result.issues);
+		assert.strictEqual(lowered.program, void 0, "and carries no program, since the statement it would have emitted names nothing");
+	});
+	(0, import_qunit.test)("an unknown field inside an appended value is recorded at whatever depth it sits", async function(assert) {
+		let { field, contains, containsMany, CardDef } = api;
+		let { operation, params } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "comments", [field], function() {
+					return containsMany(fixtures.Comment);
+				});
+			}
+			#comments = (initializeDeferredDecorator(this, "comments"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this, "addComment", [operation], function() {
+					return {
+						base: "transform",
+						params: {
+							body: StringField,
+							city: StringField
+						},
+						append: {
+							to: "comments",
+							value: {
+								body: params("body"),
+								bdy: "x",
+								where: {
+									city: params("city"),
+									citty: "x"
+								}
+							}
+						}
+					};
+				});
+			}
+			#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
+		}
+		shim({ Report });
+		let result = await lower(Report);
+		assert.deepEqual(codes(result), ["unknown-field", "unknown-field"]);
+		assert.deepEqual(result.issues.map((issue) => issue.path), ["append.value.bdy", "append.value.where.citty"]);
+		assert.true(result.issues[0].message.includes("Comment"), "the message names the item type the key was checked against");
+		assert.true(result.issues[1].message.includes("Address"), "and the nested key is checked against the type that actually holds it");
+	});
+	(0, import_qunit.test)("params() for a key the schema does not declare is refused in a clause and recorded in a program", async function(assert) {
+		let { field, contains, CardDef } = api;
+		let { operation, params, bxl } = operations;
+		assert.throws(() => {
+			class Flawed extends CardDef {
+				static displayName = "Flawed";
+				static {
+					decorateFieldV2(this.prototype, "status", [field], function() {
+						return contains(StringField);
+					});
+				}
+				#status = (initializeDeferredDecorator(this, "status"), void 0);
+				static {
+					decorateFieldV2(this, "close", [operation], function() {
+						return {
+							base: "transform",
+							params: { note: StringField },
+							set: { status: params("reason") }
+						};
+					});
+				}
+				#close = (initializeDeferredDecorator(this, "close"), void 0);
+			}
+			return Flawed;
+		}, /references the param "reason", which the `params` schema does not declare/, "an undeclared param in a clause never reaches lowering");
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "status", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#status = (initializeDeferredDecorator(this, "status"), void 0);
+			static {
+				decorateFieldV2(this, "raw", [operation], function() {
+					return {
+						base: "transform",
+						params: { note: StringField },
+						transformations: bxl`.status = params("reason");`
+					};
+				});
+			}
+			#raw = (initializeDeferredDecorator(this, "raw"), void 0);
+		}
+		shim({ Report });
+		let result = await lower(Report);
+		assert.deepEqual(codes(result), ["undeclared-param"]);
+		assert.deepEqual(result.issues.map((issue) => issue.operation), ["raw"]);
+		assert.strictEqual(result.issues[0].path, "transformations", "the finding points at the program rather than at a clause");
+	});
+	(0, import_qunit.test)("card() naming a link identity lowers the same as naming it bare", async function(assert) {
+		let { field, contains, linksTo, linksToMany, CardDef } = api;
+		let { operation, params, card, linkTo } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "owner", [field], function() {
+					return linksTo(() => fixtures.Author);
+				});
+			}
+			#owner = (initializeDeferredDecorator(this, "owner"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "reviewers", [field], function() {
+					return linksToMany(() => fixtures.Author, { searchable: true });
+				});
+			}
+			#reviewers = (initializeDeferredDecorator(this, "reviewers"), void 0);
+			static {
+				decorateFieldV2(this, "assignBare", [operation], function() {
+					return {
+						base: "transform",
+						params: { who: linkTo(() => fixtures.Author) },
+						set: { owner: params("who") }
+					};
+				});
+			}
+			#assignBare = (initializeDeferredDecorator(this, "assignBare"), void 0);
+			static {
+				decorateFieldV2(this, "assignExplicit", [operation], function() {
+					return {
+						base: "transform",
+						params: { who: linkTo(() => fixtures.Author) },
+						set: { owner: card(params("who")) }
+					};
+				});
+			}
+			#assignExplicit = (initializeDeferredDecorator(this, "assignExplicit"), void 0);
+			static {
+				decorateFieldV2(this, "enrolExplicit", [operation], function() {
+					return {
+						base: "transform",
+						params: { who: linkTo(() => fixtures.Author) },
+						append: {
+							to: "reviewers",
+							value: card(params("who"))
+						}
+					};
+				});
+			}
+			#enrolExplicit = (initializeDeferredDecorator(this, "enrolExplicit"), void 0);
+		}
+		shim({ Report });
+		let { operations: lowered, issues } = await lower(Report);
+		assert.deepEqual(issues, [], "the declarations lower cleanly");
+		assert.strictEqual(lowered.assignExplicit.program?.source, ".owner=card(params(\"who\"));");
+		assert.strictEqual(lowered.assignBare.program?.source, lowered.assignExplicit.program?.source, "the two spellings are the same program");
+		assert.strictEqual(lowered.enrolExplicit.program?.source, "append(.reviewers;card(params(\"who\")));");
+	});
+	(0, import_qunit.test)("a contained value written whole may leave its link empty", async function(assert) {
+		let { field, contains, containsMany, CardDef } = api;
+		let { operation, params } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "comments", [field], function() {
+					return containsMany(fixtures.Comment);
+				});
+			}
+			#comments = (initializeDeferredDecorator(this, "comments"), void 0);
+			static {
+				decorateFieldV2(this, "addComment", [operation], function() {
+					return {
+						base: "transform",
+						params: { body: StringField },
+						append: {
+							to: "comments",
+							value: {
+								body: params("body"),
+								author: null
+							}
+						}
+					};
+				});
+			}
+			#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
+		}
+		shim({ Report });
+		let result = await lower(Report);
+		assert.deepEqual(codes(result), []);
+		assert.strictEqual(result.operations.addComment.program?.source, "append(.comments;{body:params(\"body\"),author:null});");
+		assert.notOk(result.operations.addComment.invalid);
+	});
+	(0, import_qunit.test)("a value in a link position that is not a card identity is recorded", async function(assert) {
+		let { field, contains, linksTo, linksToMany, CardDef } = api;
+		let { operation } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "owner", [field], function() {
+					return linksTo(() => fixtures.Author);
+				});
+			}
+			#owner = (initializeDeferredDecorator(this, "owner"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "reviewers", [field], function() {
+					return linksToMany(() => fixtures.Author, { searchable: true });
+				});
+			}
+			#reviewers = (initializeDeferredDecorator(this, "reviewers"), void 0);
+			static {
+				decorateFieldV2(this, "misassign", [operation], function() {
+					return {
+						base: "transform",
+						set: { owner: { name: "Ada" } }
+					};
+				});
+			}
+			#misassign = (initializeDeferredDecorator(this, "misassign"), void 0);
+			static {
+				decorateFieldV2(this, "unassign", [operation], function() {
+					return {
+						base: "transform",
+						set: { owner: null }
+					};
+				});
+			}
+			#unassign = (initializeDeferredDecorator(this, "unassign"), void 0);
+			static {
+				decorateFieldV2(this, "misappend", [operation], function() {
+					return {
+						base: "transform",
+						append: {
+							to: "reviewers",
+							value: 7
+						}
+					};
+				});
+			}
+			#misappend = (initializeDeferredDecorator(this, "misappend"), void 0);
+		}
+		shim({ Report });
+		let result = await lower(Report);
+		assert.deepEqual(codes(result), [
+			"link-requires-identity",
+			"link-requires-identity",
+			"link-requires-identity"
+		]);
+		assert.deepEqual(result.issues.map((issue) => issue.path), [
+			"set.owner",
+			"set.owner",
+			"append.value"
+		]);
+		assert.true(result.issues[1].message.includes("already empty"), "clearing a link is called out as its own missing spelling rather than as a bad value");
+		for (let name of [
+			"misassign",
+			"unassign",
+			"misappend"
+		]) assert.true(result.operations[name].invalid, `${name} is flagged rather than stored as though it would run`);
+	});
+	(0, import_qunit.test)("a write into a computed field is recorded", async function(assert) {
+		let { field, contains, CardDef } = api;
+		let { operation } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "slug", [field], function() {
+					return contains(StringField, { computeVia: function() {
+						return this.title;
+					} });
+				});
+			}
+			#slug = (initializeDeferredDecorator(this, "slug"), void 0);
+			static {
+				decorateFieldV2(this, "rename", [operation], function() {
+					return {
+						base: "transform",
+						set: { slug: "x" }
+					};
+				});
+			}
+			#rename = (initializeDeferredDecorator(this, "rename"), void 0);
+		}
+		shim({ Report });
+		let result = await lower(Report);
+		assert.deepEqual(codes(result), ["computed-write"]);
+		assert.strictEqual(result.issues[0].path, "set.slug");
+	});
+	(0, import_qunit.test)("a write through a link is recorded", async function(assert) {
+		let { field, contains, linksTo, CardDef } = api;
+		let { operation } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "owner", [field], function() {
+					return linksTo(() => fixtures.Author, { searchable: true });
+				});
+			}
+			#owner = (initializeDeferredDecorator(this, "owner"), void 0);
+			static {
+				decorateFieldV2(this, "rename", [operation], function() {
+					return {
+						base: "transform",
+						set: { "owner.name": "x" }
+					};
+				});
+			}
+			#rename = (initializeDeferredDecorator(this, "rename"), void 0);
+		}
+		shim({ Report });
+		let result = await lower(Report);
+		assert.deepEqual(codes(result), ["write-through-link"]);
+		assert.strictEqual(result.issues[0].path, "set.owner.name", "an operation binds to its target card, not to the cards it links to");
+	});
+	(0, import_qunit.test)("a read through a link that is not searchable is recorded", async function(assert) {
+		let { field, containsMany, linksTo, CardDef } = api;
+		let { operation, params } = operations;
+		class Tagger extends CardDef {
+			static displayName = "Tagger";
+			static {
+				decorateFieldV2(this.prototype, "tags", [field], function() {
+					return containsMany(StringField);
+				});
+			}
+			#tags = (initializeDeferredDecorator(this, "tags"), void 0);
+		}
+		shim({ Tagger });
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "owner", [field], function() {
+					return linksTo(() => Tagger);
+				});
+			}
+			#owner = (initializeDeferredDecorator(this, "owner"), void 0);
+			static {
+				decorateFieldV2(this, "claim", [operation], function() {
+					return {
+						base: "transform",
+						params: { who: StringField },
+						assert: {
+							unique: "owner.tags",
+							by: params("who"),
+							snapshot: true
+						}
+					};
+				});
+			}
+			#claim = (initializeDeferredDecorator(this, "claim"), void 0);
+		}
+		shim({ Report });
+		let result = await lower(Report);
+		assert.deepEqual(codes(result), ["unsearchable-read"]);
+		assert.true(result.issues[0].message.includes("searchable"), "the message says what makes a linked card's values reachable");
+	});
+	(0, import_qunit.test)("an assert over computed or linked values without a snapshot is recorded", async function(assert) {
+		let { field, contains, linksToMany, CardDef } = api;
+		let { operation, params } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "reviewers", [field], function() {
+					return linksToMany(() => fixtures.Author, { searchable: true });
+				});
+			}
+			#reviewers = (initializeDeferredDecorator(this, "reviewers"), void 0);
+			static {
+				decorateFieldV2(this, "addReviewer", [operation], function() {
+					return {
+						base: "transform",
+						params: { who: StringField },
+						assert: {
+							unique: "reviewers",
+							by: params("who")
+						}
+					};
+				});
+			}
+			#addReviewer = (initializeDeferredDecorator(this, "addReviewer"), void 0);
+		}
+		shim({ Report });
+		let result = await lower(Report);
+		assert.deepEqual(codes(result), ["unsnapshotted-assert"]);
+		assert.true(result.issues[0].message.includes("snapshot: true"), "the message names the clause that resolves it");
+		assert.strictEqual(result.operations.addReviewer.program?.source, "assert(all(.reviewers[];.id!=params(\"who\"));\"reviewers already holds this value\");", "the program is still emitted, so the operation says what it would do");
+	});
+	(0, import_qunit.test)("replacing a whole link collection is recorded — a relationship changes one edge at a time", async function(assert) {
+		let { field, contains, linksToMany, CardDef } = api;
+		let { operation, params } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "reviewers", [field], function() {
+					return linksToMany(() => fixtures.Author);
+				});
+			}
+			#reviewers = (initializeDeferredDecorator(this, "reviewers"), void 0);
+			static {
+				decorateFieldV2(this, "reassign", [operation], function() {
+					return {
+						base: "transform",
+						params: { who: StringField },
+						set: { reviewers: [params("who")] }
+					};
+				});
+			}
+			#reassign = (initializeDeferredDecorator(this, "reassign"), void 0);
+		}
+		shim({ Report });
+		let result = await lower(Report);
+		assert.deepEqual(codes(result), ["link-collection-replace"]);
+		assert.true(result.issues[0].message.includes("append"), "the message names the clause that does express the change");
+		assert.strictEqual(result.operations.reassign.program, void 0, "and no program is emitted, since an assignment here is not executable");
+	});
+	(0, import_qunit.test)("a write into a query-backed field or into `id` is recorded", async function(assert) {
+		let { field, contains, linksTo, CardDef } = api;
+		let { operation } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "featured", [field], function() {
+					return linksTo(() => fixtures.Author, { query: { filter: { type: {
+						module: `${testRealmURL}author`,
+						name: "Author"
+					} } } });
+				});
+			}
+			#featured = (initializeDeferredDecorator(this, "featured"), void 0);
+			static {
+				decorateFieldV2(this, "feature", [operation], function() {
+					return {
+						base: "transform",
+						set: { featured: "http://example.com/a" }
+					};
+				});
+			}
+			#feature = (initializeDeferredDecorator(this, "feature"), void 0);
+			static {
+				decorateFieldV2(this, "rename", [operation], function() {
+					return {
+						base: "transform",
+						set: { id: "http://example.com/r" }
+					};
+				});
+			}
+			#rename = (initializeDeferredDecorator(this, "rename"), void 0);
+		}
+		shim({ Report });
+		let result = await lower(Report);
+		assert.deepEqual(codes(result), ["read-only-write", "read-only-write"]);
+		assert.true(result.issues[0].message.includes("query"), "a query-backed field holds no stored value to write");
+		assert.true(result.issues[1].message.includes("identity"), "and `id` is the card's identity rather than its data");
+	});
+	(0, import_qunit.test)("a path that continues past a collection is recorded — no item is named", async function(assert) {
+		let { field, contains, containsMany, CardDef } = api;
+		let { operation } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "comments", [field], function() {
+					return containsMany(fixtures.Comment);
+				});
+			}
+			#comments = (initializeDeferredDecorator(this, "comments"), void 0);
+			static {
+				decorateFieldV2(this, "editComment", [operation], function() {
+					return {
+						base: "transform",
+						set: { "comments.body": "z" }
+					};
+				});
+			}
+			#editComment = (initializeDeferredDecorator(this, "editComment"), void 0);
+		}
+		shim({ Report });
+		let result = await lower(Report);
+		assert.deepEqual(codes(result), ["path-crosses-collection"]);
+		assert.true(result.issues[0].message.includes("which item"), "the message says what the declaration cannot express");
+	});
+	(0, import_qunit.test)("appending to a field that holds one value is recorded", async function(assert) {
+		let { field, contains, CardDef } = api;
+		let { operation } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this, "addTitle", [operation], function() {
+					return {
+						base: "transform",
+						append: {
+							to: "title",
+							value: "x"
+						}
+					};
+				});
+			}
+			#addTitle = (initializeDeferredDecorator(this, "addTitle"), void 0);
+		}
+		shim({ Report });
+		let result = await lower(Report);
+		assert.deepEqual(codes(result), ["not-a-collection"]);
+	});
+	(0, import_qunit.test)("a raw program that does not parse is recorded", async function(assert) {
+		let { field, contains, CardDef } = api;
+		let { operation, bxl } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "status", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#status = (initializeDeferredDecorator(this, "status"), void 0);
+			static {
+				decorateFieldV2(this, "broken", [operation], function() {
+					return {
+						base: "transform",
+						transformations: bxl`.status = ;`
+					};
+				});
+			}
+			#broken = (initializeDeferredDecorator(this, "broken"), void 0);
+		}
+		shim({ Report });
+		let result = await lower(Report);
+		assert.deepEqual(codes(result), ["invalid-program"]);
+		assert.strictEqual(result.issues[0].path, "transformations");
+		assert.true(result.operations.broken.invalid, "the operation is stored so invoking it reports the parse failure");
+	});
+	(0, import_qunit.test)("a class no module exports has no code ref to store", async function(assert) {
+		let { field, contains, CardDef } = api;
+		let { operation } = operations;
+		class Unexported extends CardDef {
+			static displayName = "Unexported";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this, "make", [operation], function() {
+					return {
+						base: "create",
+						of: () => Unexported
+					};
+				});
+			}
+			#make = (initializeDeferredDecorator(this, "make"), void 0);
+		}
+		shim({ Report });
+		let result = await lower(Report);
+		assert.deepEqual(codes(result), ["unresolved-type"]);
+		assert.strictEqual(result.issues[0].path, "of");
+		assert.strictEqual(result.operations.make.of, void 0);
+	});
+	(0, import_qunit.test)("a def that declares nothing lowers to nothing", async function(assert) {
+		let { field, contains, CardDef } = api;
+		class Plain extends CardDef {
+			static displayName = "Plain";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+		}
+		shim({ Plain });
+		let result = await lower(Plain);
+		assert.deepEqual(result, {
+			operations: {},
+			issues: []
+		}, "the base operations a def type carries are not declarations, so there is nothing to lower");
+	});
+	(0, import_qunit.test)("a behavior the def type does not carry is refused rather than lowered", async function(assert) {
+		let { field, contains, containsMany, CardDef, FieldDef, FileDef } = api;
+		class Ledger extends CardDef {
+			static displayName = "Ledger";
+			static {
+				decorateFieldV2(this.prototype, "entries", [field], function() {
+					return containsMany(StringField);
+				});
+			}
+			#entries = (initializeDeferredDecorator(this, "entries"), void 0);
+		}
+		class Attachment extends FileDef {
+			static displayName = "Attachment";
+		}
+		class Caption extends FieldDef {
+			static displayName = "Caption";
+			static {
+				decorateFieldV2(this.prototype, "text", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#text = (initializeDeferredDecorator(this, "text"), void 0);
+		}
+		shim({
+			Ledger,
+			Attachment,
+			Caption
+		});
+		let refused = [
+			[
+				"appendLine",
+				Ledger,
+				"card definition"
+			],
+			[
+				"appendContainsMany",
+				Attachment,
+				"file definition"
+			],
+			[
+				"transform",
+				Attachment,
+				"file definition"
+			],
+			[
+				"create",
+				Caption,
+				"definition recorded as a field"
+			]
+		];
+		for (let [base, def, kindLabel] of refused) {
+			let result = await lowerOperationDeclarations({ doIt: { base } }, {
+				definition: buildDefinition(def),
+				lookupDefinition,
+				identifyCard: (target) => identifyCard(target)
+			});
+			assert.deepEqual(codes(result), ["base-not-carried"], `a ${kindLabel} cannot build an operation on "${base}"`);
+			assert.strictEqual(result.issues[0].path, "base");
+			assert.true(result.issues[0].message.includes(kindLabel), "the finding names the def kind");
+			assert.true(result.issues[0].message.includes(`"${base}"`), "and the behavior it cannot carry out");
+			assert.true(result.operations.doIt?.invalid, "the operation is stored flagged, so invoking it reports the refusal rather than reading as unknown");
+		}
+		class Addressable extends api.BaseDef {
+			static displayName = "Addressable";
+		}
+		shim({ Addressable });
+		assert.strictEqual(buildDefinition(Addressable).type, "field-def", "the two land under one recorded kind");
+		let addressable = await lowerOperationDeclarations({ readRedacted: {
+			base: "read",
+			output: { name: true }
+		} }, {
+			definition: buildDefinition(Addressable),
+			lookupDefinition,
+			identifyCard: (target) => identifyCard(target)
+		});
+		assert.deepEqual(codes(addressable), [], "so the read lowers");
+		assert.notOk(addressable.operations.readRedacted.invalid);
+	});
+	(0, import_qunit.test)("an append names a containsMany field the type actually has", async function(assert) {
+		let { field, contains, containsMany, linksToMany, CardDef } = api;
+		let { operation } = operations;
+		class Ledger extends CardDef {
+			static displayName = "Ledger";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "helpers", [field], function() {
+					return linksToMany(() => fixtures.Author);
+				});
+			}
+			#helpers = (initializeDeferredDecorator(this, "helpers"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "entries", [field], function() {
+					return containsMany(StringField);
+				});
+			}
+			#entries = (initializeDeferredDecorator(this, "entries"), void 0);
+			static {
+				decorateFieldV2(this, "toScalar", [operation], function() {
+					return {
+						base: "appendContainsMany",
+						field: "title",
+						item: "x"
+					};
+				});
+			}
+			#toScalar = (initializeDeferredDecorator(this, "toScalar"), void 0);
+			static {
+				decorateFieldV2(this, "toLinks", [operation], function() {
+					return {
+						base: "appendContainsMany",
+						field: "helpers",
+						item: "https://example.test/people/1"
+					};
+				});
+			}
+			#toLinks = (initializeDeferredDecorator(this, "toLinks"), void 0);
+			static {
+				decorateFieldV2(this, "toNothing", [operation], function() {
+					return {
+						base: "appendContainsMany",
+						field: "entires",
+						item: "x"
+					};
+				});
+			}
+			#toNothing = (initializeDeferredDecorator(this, "toNothing"), void 0);
+		}
+		shim({ Ledger });
+		let result = await lower(Ledger);
+		assert.deepEqual(codes(result), [
+			"not-a-collection",
+			"not-a-collection",
+			"unknown-field"
+		]);
+		assert.true(result.issues[1].message.includes("linksToMany"), "a link collection is not one a card holds in its own file, so an append cannot splice into it");
+		assert.strictEqual(result.issues[0].path, "field");
+		assert.strictEqual(result.operations.toScalar.items, void 0, "nothing is stored for the field that could not carry the item");
+	});
+	(0, import_qunit.test)("an appended item's members are held to the item type's own fields", async function(assert) {
+		let { field, contains, containsMany, CardDef } = api;
+		let { operation, params } = operations;
+		assert.throws(() => {
+			class Flawed extends CardDef {
+				static displayName = "Flawed";
+				static {
+					decorateFieldV2(this.prototype, "events", [field], function() {
+						return containsMany(fixtures.Comment);
+					});
+				}
+				#events = (initializeDeferredDecorator(this, "events"), void 0);
+				static {
+					decorateFieldV2(this, "log", [operation], function() {
+						return {
+							base: "appendContainsMany",
+							params: { body: StringField },
+							field: "events",
+							item: { body: params("note") }
+						};
+					});
+				}
+				#log = (initializeDeferredDecorator(this, "log"), void 0);
+			}
+			return Flawed;
+		}, /references the param "note", which the `params` schema does not declare/, "an undeclared param inside an item never reaches lowering");
+		class EventLog extends CardDef {
+			static displayName = "EventLog";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "events", [field], function() {
+					return containsMany(fixtures.Comment);
+				});
+			}
+			#events = (initializeDeferredDecorator(this, "events"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "slug", [field], function() {
+					return contains(StringField, { computeVia: function() {
+						return this.title;
+					} });
+				});
+			}
+			#slug = (initializeDeferredDecorator(this, "slug"), void 0);
+			static {
+				decorateFieldV2(this, "log", [operation], function() {
+					return {
+						base: "appendContainsMany",
+						params: { body: StringField },
+						field: "events",
+						item: { bdy: params("body") }
+					};
+				});
+			}
+			#log = (initializeDeferredDecorator(this, "log"), void 0);
+			static {
+				decorateFieldV2(this, "logComputed", [operation], function() {
+					return {
+						base: "appendContainsMany",
+						field: "slug",
+						item: "x"
+					};
+				});
+			}
+			#logComputed = (initializeDeferredDecorator(this, "logComputed"), void 0);
+		}
+		shim({ EventLog });
+		let result = await lower(EventLog);
+		assert.deepEqual(codes(result), ["unknown-field", "computed-write"]);
+		assert.strictEqual(result.issues[0].path, "item.bdy", "the finding names where in the item the author wrote it");
+		assert.true(result.issues[0].message.includes("Comment"), "and the item type the member was checked against");
+		assert.deepEqual(result.operations.log.items, { events: { bdy: {
+			$ref: "params",
+			key: "body"
+		} } }, "the item is stored as written, so invoking it reports the finding rather than appending something else");
+	});
+	(0, import_qunit.test)("a program declared on a base that runs none is recorded", async function(assert) {
+		let { field, containsMany, CardDef, FileDef } = api;
+		class EventLog extends CardDef {
+			static displayName = "EventLog";
+			static {
+				decorateFieldV2(this.prototype, "events", [field], function() {
+					return containsMany(StringField);
+				});
+			}
+			#events = (initializeDeferredDecorator(this, "events"), void 0);
+		}
+		class LogFile extends FileDef {
+			static displayName = "LogFile";
+		}
+		shim({
+			EventLog,
+			LogFile
+		});
+		for (let [def, base, clauses] of [[
+			EventLog,
+			"appendContainsMany",
+			{
+				field: "events",
+				item: "x"
+			}
+		], [
+			LogFile,
+			"update",
+			{}
+		]]) {
+			let result = await lowerOperationDeclarations({ doIt: {
+				base,
+				...clauses,
+				transformations: { $bxl: ".status = \"closed\";" }
+			} }, {
+				definition: buildDefinition(def),
+				lookupDefinition,
+				identifyCard: (target) => identifyCard(target)
+			});
+			assert.deepEqual(codes(result), ["unrunnable-program"], `a "${base}" writes to the stored file rather than running a program`);
+			assert.strictEqual(result.operations.doIt.program, void 0, "and nothing is stored that could later be mistaken for one that runs");
+		}
+	});
+	(0, import_qunit.test)("a link strategy is carried onto a read or a query and recorded on anything else", async function(assert) {
+		let { field, contains, CardDef } = api;
+		class Roster extends CardDef {
+			static displayName = "Roster";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+		}
+		shim({ Roster });
+		let read = await lowerOperationDeclarations({ summary: {
+			base: "read",
+			links: "ids"
+		} }, {
+			definition: buildDefinition(Roster),
+			lookupDefinition,
+			identifyCard: (target) => identifyCard(target)
+		});
+		assert.deepEqual(codes(read), [], "a read may declare one");
+		assert.strictEqual(read.operations.summary.links, "ids", "and the realm executes it from the stored entry");
+		let write = await lowerOperationDeclarations({ rename: {
+			base: "transform",
+			set: { title: "Renamed" },
+			links: "none"
+		} }, {
+			definition: buildDefinition(Roster),
+			lookupDefinition,
+			identifyCard: (target) => identifyCard(target)
+		});
+		assert.deepEqual(codes(write), ["links-without-assembly"], "a base that assembles no link closure has nothing to narrow");
+		assert.strictEqual(write.operations.rename.links, void 0, "and nothing is stored that a serving path would read as a narrowing");
+		let query = await lowerOperationDeclarations({ roll: {
+			base: "query",
+			query: { filter: {
+				on: Roster,
+				eq: { title: "x" }
+			} },
+			links: "ids"
+		} }, {
+			definition: buildDefinition(Roster),
+			lookupDefinition,
+			identifyCard: (target) => identifyCard(target)
+		});
+		assert.deepEqual(codes(query), [], "a query may declare one");
+		assert.strictEqual(query.operations.roll.links, "ids", "and the realm serves its results from the stored entry");
+		let unknown = await lowerOperationDeclarations({ summary: {
+			base: "read",
+			links: "some"
+		} }, {
+			definition: buildDefinition(Roster),
+			lookupDefinition,
+			identifyCard: (target) => identifyCard(target)
+		});
+		assert.deepEqual(codes(unknown), ["invalid-link-strategy"], "a value that names no strategy is its own finding");
+		assert.strictEqual(unknown.operations.summary.links, void 0, "and is not stored for the serving path to read as the narrowest one");
+	});
+	(0, import_qunit.test)("`none` is a query strategy, and a read declaring it is recorded", async function(assert) {
+		let { field, contains, CardDef } = api;
+		class Roster extends CardDef {
+			static displayName = "Roster";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+		}
+		shim({ Roster });
+		let lower = (declarations) => lowerOperationDeclarations(declarations, {
+			definition: buildDefinition(Roster),
+			lookupDefinition,
+			identifyCard: (target) => identifyCard(target)
+		});
+		for (let name of ["read", "summary"]) {
+			let none = await lower({ [name]: {
+				base: "read",
+				links: "none"
+			} });
+			assert.deepEqual(codes(none), ["invalid-link-strategy"], `a read named "${name}" may not withhold its links`);
+			assert.true(none.operations[name].invalid, `and "${name}" is refused rather than served without them`);
+			assert.strictEqual(none.operations[name].links, void 0, `and no narrowing is stored for "${name}"`);
+		}
+		for (let links of ["full", "ids"]) {
+			let narrowed = await lower({ read: {
+				base: "read",
+				links
+			} });
+			assert.deepEqual(codes(narrowed), [], `a read may declare "${links}"`);
+			assert.strictEqual(narrowed.operations.read.links, links, `and "${links}" is stored for the realm to serve`);
+		}
+		let query = await lower({ roll: {
+			base: "query",
+			query: { filter: {
+				on: Roster,
+				eq: { title: "x" }
+			} },
+			links: "none"
+		} });
+		assert.deepEqual(codes(query), [], "a query may declare \"none\"");
+		assert.strictEqual(query.operations.roll.links, "none", "and its rows are served under it");
+	});
+	(0, import_qunit.test)("an html declaration is carried onto a read or a query and recorded on anything else", async function(assert) {
+		let { field, contains, CardDef } = api;
+		class Roster extends CardDef {
+			static displayName = "Roster";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+		}
+		shim({ Roster });
+		let lower = (declarations) => lowerOperationDeclarations(declarations, {
+			definition: buildDefinition(Roster),
+			lookupDefinition,
+			identifyCard: (target) => identifyCard(target)
+		});
+		let read = await lower({ summary: {
+			base: "read",
+			html: {
+				embedded: "unshareable",
+				fitted: "shareable"
+			}
+		} });
+		assert.deepEqual(codes(read), [], "a read may declare one");
+		assert.deepEqual(read.operations.summary.html, {
+			embedded: "unshareable",
+			fitted: "shareable"
+		}, "and the realm serves reads of the card from the stored entry");
+		let query = await lower({ roll: {
+			base: "query",
+			query: { filter: {
+				on: Roster,
+				eq: { title: "x" }
+			} },
+			html: { isolated: "unshareable" }
+		} });
+		assert.deepEqual(codes(query), [], "a query may declare one");
+		assert.deepEqual(query.operations.roll.html, { isolated: "unshareable" }, "and the realm serves its rows from the stored entry");
+		let write = await lower({ rename: {
+			base: "transform",
+			set: { title: "Renamed" },
+			html: { embedded: "unshareable" }
+		} });
+		assert.deepEqual(codes(write), ["html-without-rendering"], "a base that serves no prerendered HTML has nothing to withhold");
+		assert.strictEqual(write.operations.rename.html, void 0, "and nothing is stored that a serving path would read as a withholding");
+		for (let [label, html] of [
+			["a format the realm does not prerender", { edit: "unshareable" }],
+			["a value that says neither", { embedded: "hidden" }],
+			["something other than a record of formats", ["embedded"]]
+		]) {
+			let unknown = await lower({ summary: {
+				base: "read",
+				html
+			} });
+			assert.deepEqual(codes(unknown), ["invalid-html-declaration"], `${label} is its own finding`);
+			assert.strictEqual(unknown.operations.summary.html, void 0, `${label} is not stored for the serving path to read as withholding every format`);
+		}
+	});
+	(0, import_qunit.test)("an append that says nothing to append is recorded rather than stored as work", async function(assert) {
+		let { field, containsMany, CardDef } = api;
+		class Ledger extends CardDef {
+			static displayName = "Ledger";
+			static {
+				decorateFieldV2(this.prototype, "entries", [field], function() {
+					return containsMany(StringField);
+				});
+			}
+			#entries = (initializeDeferredDecorator(this, "entries"), void 0);
+		}
+		shim({ Ledger });
+		for (let [label, declaration, path] of [
+			[
+				"no field named",
+				{ base: "appendContainsMany" },
+				"field"
+			],
+			[
+				"an empty fields map",
+				{
+					base: "appendContainsMany",
+					fields: {}
+				},
+				"field"
+			],
+			[
+				"a field with no item",
+				{
+					base: "appendContainsMany",
+					field: "entries"
+				},
+				"item"
+			],
+			[
+				"both spellings at once",
+				{
+					base: "appendContainsMany",
+					field: "entries",
+					item: "a",
+					fields: { entries: "b" }
+				},
+				"fields"
+			]
+		]) {
+			let result = await lowerOperationDeclarations({ log: declaration }, {
+				definition: buildDefinition(Ledger),
+				lookupDefinition,
+				identifyCard: (target) => identifyCard(target)
+			});
+			assert.deepEqual(result.issues.map((issue) => [issue.code, issue.path]), [["incomplete-append", path]], `${label} is recorded`);
+			assert.strictEqual(result.operations.log.items, void 0, `${label} stores nothing to append`);
+			assert.true(result.operations.log.invalid, `${label} is flagged`);
+		}
+	});
+	(0, import_qunit.test)("a finding under the fields spelling names the field it was written at", async function(assert) {
+		let { field, containsMany, CardDef } = api;
+		let { operation } = operations;
+		class EventLog extends CardDef {
+			static displayName = "EventLog";
+			static {
+				decorateFieldV2(this.prototype, "events", [field], function() {
+					return containsMany(fixtures.Comment);
+				});
+			}
+			#events = (initializeDeferredDecorator(this, "events"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "labels", [field], function() {
+					return containsMany(StringField);
+				});
+			}
+			#labels = (initializeDeferredDecorator(this, "labels"), void 0);
+			static {
+				decorateFieldV2(this, "log", [operation], function() {
+					return {
+						base: "appendContainsMany",
+						fields: {
+							notes: "x",
+							events: { bdy: "y" }
+						}
+					};
+				});
+			}
+			#log = (initializeDeferredDecorator(this, "log"), void 0);
+		}
+		shim({ EventLog });
+		let result = await lower(EventLog);
+		assert.deepEqual(result.issues.map((issue) => [issue.code, issue.path]), [["unknown-field", "fields.notes"], ["unknown-field", "fields.events.bdy"]], "the plural spelling carries its own clause path, at the field and inside its item");
+	});
+	(0, import_qunit.test)("a file def's read keeps the program its output lowers to", async function(assert) {
+		let { FileDef } = api;
+		let { operation, bxl } = operations;
+		class Attachment extends FileDef {
+			static displayName = "Attachment";
+			static {
+				decorateFieldV2(this, "readRedacted", [operation], function() {
+					return {
+						base: "read",
+						output: bxl`{ name: .name }`
+					};
+				});
+			}
+			#readRedacted = (initializeDeferredDecorator(this, "readRedacted"), void 0);
+		}
+		shim({ Attachment });
+		let result = await lower(Attachment);
+		assert.deepEqual(codes(result), [], "the projection is not refused");
+		assert.deepEqual(result.operations.readRedacted.output, {
+			source: "{name:.name}",
+			syntax: "solidified"
+		});
+	});
+	(0, import_qunit.test)("a realmConfig reference with no setting named cannot stand for a card identity", async function(assert) {
+		let { field, contains, linksTo, CardDef } = api;
+		let { operation, realmConfig } = operations;
+		class Report extends CardDef {
+			static displayName = "Report";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "owner", [field], function() {
+					return linksTo(() => fixtures.Author);
+				});
+			}
+			#owner = (initializeDeferredDecorator(this, "owner"), void 0);
+			static {
+				decorateFieldV2(this, "assign", [operation], function() {
+					return {
+						base: "transform",
+						set: { owner: realmConfig() }
+					};
+				});
+			}
+			#assign = (initializeDeferredDecorator(this, "assign"), void 0);
+		}
+		shim({ Report });
+		let result = await lower(Report);
+		assert.deepEqual(codes(result), ["link-requires-identity"]);
+		assert.strictEqual(result.operations.assign.program?.source, ".owner=card(realmConfig());", "the refused form is stored as the executor would read it, so nothing quietly writes something else");
+	});
+	(0, import_qunit.test)("a reserved name is refused rather than lowered", async function(assert) {
+		let { field, contains, CardDef } = api;
+		class Reserved extends CardDef {
+			static displayName = "Reserved";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+		}
+		shim({ Reserved });
+		for (let name of DEFINITION_FREE_BASE_OPERATIONS) {
+			let result = await lowerOperationDeclarations({ [name]: { base: "read" } }, {
+				definition: buildDefinition(Reserved),
+				lookupDefinition,
+				identifyCard: (target) => identifyCard(target)
+			});
+			assert.deepEqual(codes(result), ["reserved-name"], `${name} is recorded as reserved`);
+			assert.true(result.operations[name]?.invalid, `${name} is marked invalid rather than dropped, so a consumer reading the entry sees the refusal`);
+		}
+	});
+	(0, import_qunit.test)("a stored saved search under the name `query` is refused rather than lowered", async function(assert) {
+		let { field, contains, CardDef } = api;
+		class Listed extends CardDef {
+			static displayName = "Listed";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+		}
+		shim({ Listed });
+		let result = await lowerOperationDeclarations({ query: {
+			base: "transform",
+			set: { title: "x" }
+		} }, {
+			definition: buildDefinition(Listed),
+			lookupDefinition,
+			identifyCard: (target) => identifyCard(target)
+		});
+		assert.deepEqual(codes(result), ["reserved-name"]);
+		assert.true(result.operations.query?.invalid, "stored invalid");
+		assert.strictEqual(result.operations.query?.base, "query", "on the base the name means, whatever base the entry named");
+	});
+	async function lowerRequest(request, extra = {}) {
+		let { field, contains, CardDef } = api;
+		class Repo extends CardDef {
+			static displayName = "Repo";
+			static {
+				decorateFieldV2(this.prototype, "owner", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#owner = (initializeDeferredDecorator(this, "owner"), void 0);
+		}
+		shim({ Repo });
+		return await lowerOperationDeclarations({ fetch: {
+			base: "callApi",
+			...request,
+			...extra
+		} }, {
+			definition: buildDefinition(Repo),
+			lookupDefinition,
+			identifyCard: (target) => identifyCard(target)
+		});
+	}
+	const ownerParam = {
+		$ref: "params",
+		key: "owner"
+	};
+	(0, import_qunit.test)("a keyless request lowers to the request it sends, its values still markers", async function(assert) {
+		let result = await lowerRequest({
+			url: "https://api.example.com/repos/{owner}/{repo}/issues",
+			path: {
+				owner: ownerParam,
+				repo: {
+					$ref: "instance",
+					key: "owner"
+				}
+			},
+			query: { state: "open" },
+			headers: { accept: "application/json" }
+		}, { params: { owner: StringField } });
+		assert.deepEqual(codes(result), []);
+		assert.deepEqual(result.operations.fetch, {
+			base: "callApi",
+			params: { owner: {
+				kind: "field",
+				codeRef: identifyCard(StringField)
+			} },
+			callApi: {
+				method: "GET",
+				url: "https://api.example.com/repos/{owner}/{repo}/issues",
+				destination: "https://api.example.com/repos/",
+				path: {
+					owner: ownerParam,
+					repo: {
+						$ref: "instance",
+						key: "owner"
+					}
+				},
+				headers: { accept: "application/json" },
+				query: { state: "open" },
+				slots: []
+			},
+			deterministic: true
+		});
+	});
+	(0, import_qunit.test)("an operation approved per instance says so in its lowered request", async function(assert) {
+		let perInstance = await lowerRequest({
+			url: "https://hooks.example.com/services/{hook}",
+			path: { hook: "{{apiKey:hook}}" },
+			perInstance: true
+		});
+		assert.deepEqual(codes(perInstance), []);
+		assert.true(perInstance.operations.fetch.callApi?.perInstance);
+		let perRealm = await lowerRequest({
+			url: "https://api.example.com/items",
+			perInstance: false
+		});
+		assert.deepEqual(codes(perRealm), []);
+		assert.false("perInstance" in (perRealm.operations.fetch.callApi ?? {}), "false is the same as leaving it out");
+		let notABoolean = await lowerRequest({
+			url: "https://api.example.com/items",
+			perInstance: "yes"
+		});
+		assert.deepEqual(codes(notABoolean), ["invalid-request"]);
+	});
+	(0, import_qunit.test)("a declared key kind is kept on the slots it names", async function(assert) {
+		let everySlot = await lowerRequest({
+			url: "https://sheets.googleapis.com/v4/spreadsheets/abc",
+			headers: { authorization: "Bearer {{userKey}}" },
+			keyKind: "google-service-account"
+		});
+		assert.deepEqual(codes(everySlot), []);
+		assert.deepEqual(everySlot.operations.fetch.callApi?.slots, [{
+			name: "userKey",
+			key: "userKey",
+			placement: "header",
+			at: "headers.authorization",
+			keyKind: "google-service-account"
+		}]);
+		let bySlot = await lowerRequest({
+			url: "https://api.example.com/items",
+			headers: {
+				authorization: "Bearer {{userKey:token}}",
+				"x-tenant": "{{userKey:tenant}}"
+			},
+			keyKind: { token: "oauth" }
+		});
+		assert.deepEqual(codes(bySlot), []);
+		assert.deepEqual(bySlot.operations.fetch.callApi?.slots.map((slot) => slot.keyKind), ["oauth", void 0], "a slot the declaration leaves out has no declared kind");
+		let unknownKind = await lowerRequest({
+			url: "https://api.example.com/items",
+			headers: { authorization: "Bearer {{userKey}}" },
+			keyKind: "password"
+		});
+		assert.deepEqual(codes(unknownKind), ["invalid-request"]);
+		assert.strictEqual(unknownKind.issues[0]?.path, "keyKind");
+		let unknownSlot = await lowerRequest({
+			url: "https://api.example.com/items",
+			headers: { authorization: "Bearer {{userKey}}" },
+			keyKind: { token: "oauth" }
+		});
+		assert.deepEqual(codes(unknownSlot), ["invalid-request"]);
+		assert.strictEqual(unknownSlot.issues[0]?.path, "keyKind.token");
+		let badSlotKind = await lowerRequest({
+			url: "https://api.example.com/items",
+			headers: { authorization: "Bearer {{userKey}}" },
+			keyKind: { userKey: "jwt" }
+		});
+		assert.deepEqual(codes(badSlotKind), ["invalid-request"]);
+		assert.strictEqual(badSlotKind.issues[0]?.path, "keyKind.userKey");
+		let basicEverySlot = await lowerRequest({
+			url: "https://api.example.com/items",
+			headers: { authorization: "Basic {{userKey|basic}}" },
+			keyKind: "oauth"
+		});
+		assert.deepEqual(codes(basicEverySlot), ["invalid-request"], "a minted token is never sent as Basic credentials");
+		assert.strictEqual(basicEverySlot.issues[0]?.path, "keyKind");
+		let basicBySlot = await lowerRequest({
+			url: "https://api.example.com/items",
+			headers: {
+				authorization: "Basic {{userKey:login|basic}}",
+				"x-token": "{{userKey:token}}"
+			},
+			keyKind: {
+				login: "google-service-account",
+				token: "oauth"
+			}
+		});
+		assert.deepEqual(codes(basicBySlot), ["invalid-request"]);
+		assert.strictEqual(basicBySlot.issues[0]?.path, "keyKind.login");
+		let basicStatic = await lowerRequest({
+			url: "https://api.example.com/items",
+			headers: { authorization: "Basic {{userKey|basic}}" },
+			keyKind: "static"
+		});
+		assert.deepEqual(codes(basicStatic), [], "a pasted key is");
+	});
+	(0, import_qunit.test)("the kinds of key a slot takes are its declared one, or every kind that can work where it stands", async function(assert) {
+		let kindsOf = async (request) => {
+			let result = await lowerRequest(request);
+			assert.deepEqual(codes(result), []);
+			let callApi = result.operations.fetch.callApi;
+			return callApi.slots.map((slot) => slotKeyKinds(slot, callApi));
+		};
+		assert.deepEqual(await kindsOf({
+			url: "https://api.github.com/user",
+			headers: { authorization: "Bearer {{userKey}}" }
+		}), [["static", "oauth"]], "a pasted key or a connected account");
+		assert.deepEqual(await kindsOf({
+			url: "https://api.github.com/user",
+			headers: { Authorization: " token {{ userKey }} " }
+		}), [["static", "oauth"]], "whatever the scheme");
+		assert.deepEqual(await kindsOf({
+			url: "https://www.googleapis.com/drive/v3/files",
+			headers: { authorization: "Bearer {{userKey}}" }
+		}), [[
+			"static",
+			"google-service-account",
+			"oauth"
+		]], "a Google API also takes a service account");
+		assert.deepEqual(await kindsOf({
+			url: "https://example-db.firebaseio.com/items.json",
+			query: { access_token: "{{userKey}}" }
+		}), [[
+			"static",
+			"google-service-account",
+			"oauth"
+		]], "and so does the Firebase Realtime Database");
+		assert.deepEqual(await kindsOf({
+			url: "https://api.weather.example/v1/current",
+			query: { appid: "{{userKey}}" }
+		}), [["static", "oauth"]], "a minted token fills a query value too");
+		assert.deepEqual(await kindsOf({
+			url: "https://api.example.com/items",
+			headers: {
+				authorization: "Basic {{userKey|basic}}",
+				"x-api-key": "{{apiKey}}"
+			},
+			json: { token: "{{apiKey:body}}" }
+		}), [
+			["static"],
+			["static", "oauth"],
+			["static", "oauth"]
+		], "a Basic credential is never a minted token, but another header or the body may be");
+		assert.deepEqual(await kindsOf({
+			url: "https://api.example.com/items",
+			query: { access_token: "{{userKey}}" },
+			keyKind: "oauth"
+		}), [["oauth"]], "a declared kind stands wherever the slot does");
+	});
+	(0, import_qunit.test)("the URL lowers to its normalized form and its destination", async function(assert) {
+		let result = await lowerRequest({
+			url: "https://API.openai.com:443/v1/../chat/{id}",
+			path: { id: "7" }
+		}, {});
+		assert.deepEqual(codes(result), []);
+		assert.strictEqual(result.operations.fetch.callApi?.url, "https://api.openai.com/chat/{id}", "the host is lower-cased, the default port dropped and the dot segment resolved, the `{name}` segment kept");
+		assert.strictEqual(result.operations.fetch.callApi?.destination, "https://api.openai.com/chat/", "the destination ends at the last `/` before the first `{name}` segment");
+		let twoSpellings = await Promise.all(["https://API.example.com:443/v1/../x/", "https://api.example.com/x/"].map((url) => lowerRequest({ url })));
+		assert.deepEqual(twoSpellings.map(({ operations }) => [operations.fetch.callApi?.url, operations.fetch.callApi?.destination]), [["https://api.example.com/x/", "https://api.example.com/x/"], ["https://api.example.com/x/", "https://api.example.com/x/"]], "two spellings of one place lower alike");
+	});
+	(0, import_qunit.test)("a URL with no `{name}` segment has the destination its path has up to the last `/`", async function(assert) {
+		for (let [url, destination] of [
+			["https://api.example.com/v1/chat/completions", "https://api.example.com/v1/chat/"],
+			["https://api.example.com/v1/models/", "https://api.example.com/v1/models/"],
+			["https://api.example.com", "https://api.example.com/"],
+			["https://api.example.com/items?page=2#top", "https://api.example.com/"],
+			["https://api.example.com//evil.net/x", "https://api.example.com//evil.net/"],
+			["http://localhost:4519/echo", "http://localhost:4519/"]
+		]) {
+			let result = await lowerRequest({ url });
+			assert.deepEqual(codes(result), [], url);
+			assert.strictEqual(result.operations.fetch.callApi?.destination, destination, url);
+		}
+		let laterParameter = await lowerRequest({
+			url: "https://api.example.com/repos/{owner}/issues/{n}",
+			path: {
+				owner: "o",
+				n: "1"
+			}
+		});
+		assert.strictEqual(laterParameter.operations.fetch.callApi?.destination, "https://api.example.com/repos/", "the first `{name}` segment ends it, whatever follows");
+	});
+	(0, import_qunit.test)("a wildcard host is refused", async function(assert) {
+		for (let url of [
+			"https://*.example.com/items",
+			"https://%2A.example.com/items",
+			"https://api.*/items"
+		]) {
+			let result = await lowerRequest({ url });
+			assert.deepEqual(codes(result), ["invalid-request"], url);
+			assert.strictEqual(result.operations.fetch.callApi, void 0, url);
+		}
+	});
+	(0, import_qunit.test)("a URL's own text that reads like lowering's stand-in for a segment stays where it is written", async function(assert) {
+		for (let literal of ["boxel-path-parameter-0-", "%62oxel-path-parameter-0-"]) {
+			let result = await lowerRequest({
+				url: `https://api.example.com/${literal}/{id}`,
+				path: { id: "7" }
+			});
+			assert.deepEqual(codes(result), [], literal);
+			assert.strictEqual(result.operations.fetch.callApi?.url, `https://api.example.com/${literal}/{id}`, literal);
+			assert.strictEqual(result.operations.fetch.callApi?.destination, `https://api.example.com/${literal}/`, literal);
+		}
+	});
+	(0, import_qunit.test)("a host with a trailing dot is refused", async function(assert) {
+		let result = await lowerRequest({
+			url: "https://api.example.com./v1/{id}",
+			path: { id: "7" }
+		});
+		assert.deepEqual(codes(result), ["invalid-request"]);
+		assert.strictEqual(result.operations.fetch.callApi, void 0);
+	});
+	(0, import_qunit.test)("an http URL lowers, for the outbound guard to judge when it is sent", async function(assert) {
+		let result = await lowerRequest({ url: "http://api.example.com/items" });
+		assert.deepEqual(codes(result), []);
+		assert.strictEqual(result.operations.fetch.callApi?.destination, "http://api.example.com/");
+	});
+	(0, import_qunit.test)("a request with a body defaults to POST, and a GraphQL document travels with its variables", async function(assert) {
+		let result = await lowerRequest({
+			url: "https://api.example.com/graphql",
+			graphql: {
+				document: "query($owner: String!) { repo(owner: $owner) { id } }",
+				variables: { owner: ownerParam }
+			}
+		}, { params: { owner: StringField } });
+		assert.deepEqual(codes(result), []);
+		assert.strictEqual(result.operations.fetch.callApi?.method, "POST");
+		assert.deepEqual(result.operations.fetch.callApi?.body, {
+			kind: "graphql",
+			document: "query($owner: String!) { repo(owner: $owner) { id } }",
+			variables: { owner: ownerParam }
+		});
+	});
+	(0, import_qunit.test)("each slot is indexed with its key, its name, its transform and where it is sent", async function(assert) {
+		let result = await lowerRequest({
+			url: "https://api.example.com/hooks/{secret}",
+			path: { secret: "{{apiKey:hook}}" },
+			headers: { authorization: "Basic {{userKey|basic}}" },
+			query: { key: "{{apiKey}}" },
+			json: { auth: { token: "tok {{ apiKey : body }}" } }
+		});
+		assert.deepEqual(codes(result), []);
+		assert.deepEqual(result.operations.fetch.callApi?.slots, [
+			{
+				name: "hook",
+				key: "apiKey",
+				placement: "path",
+				at: "path.secret"
+			},
+			{
+				name: "userKey",
+				key: "userKey",
+				transform: "basic",
+				placement: "header",
+				at: "headers.authorization"
+			},
+			{
+				name: "apiKey",
+				key: "apiKey",
+				placement: "query",
+				at: "query.key"
+			},
+			{
+				name: "body",
+				key: "apiKey",
+				placement: "body",
+				at: "json.auth.token"
+			}
+		]);
+		assert.strictEqual(result.operations.fetch.callApi?.headers?.authorization, "Basic {{userKey|basic}}", "the slot stays where it was written, for the sender to fill");
+	});
+	(0, import_qunit.test)("a slot placed twice is refused", async function(assert) {
+		let result = await lowerRequest({
+			url: "https://api.example.com/items",
+			headers: { authorization: "Bearer {{apiKey}}" },
+			query: { key: "{{apiKey|basic}}" }
+		});
+		assert.deepEqual(codes(result), ["slot-placed-twice"]);
+		assert.true(result.operations.fetch.invalid, "stored invalid");
+		assert.strictEqual(result.operations.fetch.callApi, void 0);
+	});
+	(0, import_qunit.test)("a slot name reused for a different key is refused", async function(assert) {
+		let result = await lowerRequest({
+			url: "https://api.example.com/items",
+			headers: {
+				authorization: "Bearer {{apiKey:token}}",
+				"x-user": "{{userKey:token}}"
+			}
+		});
+		assert.deepEqual(codes(result), ["slot-name-reused"]);
+	});
+	(0, import_qunit.test)("a path parameter that is not filled through `path` is refused", async function(assert) {
+		let unfilled = await lowerRequest({ url: "https://api.example.com/repos/{owner}" });
+		assert.deepEqual(codes(unfilled), ["unencoded-path-parameter"]);
+		let partial = await lowerRequest({
+			url: "https://api.example.com/v{version}/items",
+			path: { version: "2" }
+		});
+		assert.deepEqual(codes(partial), ["unencoded-path-parameter", "invalid-request"], "part of a segment is not a segment the request fills, so `path` has nothing to fill");
+		let inHost = await lowerRequest({
+			url: "https://{tenant}.example.com/items",
+			path: { tenant: "acme" }
+		});
+		assert.deepEqual(codes(inHost), ["unencoded-path-parameter", "invalid-request"], "a parameter in the host is refused");
+		let spliced = await lowerRequest({ url: `https://api.example.com/repos/${String({})}` });
+		assert.deepEqual(codes(spliced), ["unencoded-path-parameter"], "a reference spliced into the URL text is refused");
+		let splicedValue = await lowerRequest({
+			url: "https://api.example.com/repos/{owner}",
+			path: { owner: `team-${String({})}` }
+		});
+		assert.deepEqual(codes(splicedValue), ["unencoded-path-parameter"]);
+	});
+	for (let value of [
+		"org/name",
+		"org\\name",
+		"{{apiKey}}/v2",
+		"",
+		".",
+		"..",
+		"a\ud800"
+	]) (0, import_qunit.test)(`a path value written as ${JSON.stringify(value)}, which no request can send, is refused`, async function(assert) {
+		let result = await lowerRequest({
+			url: "https://api.example.com/models/{model}",
+			path: { model: value }
+		});
+		assert.deepEqual(codes(result), ["invalid-request"]);
+		assert.strictEqual(result.issues[0].path, "path.model");
+		assert.true(result.issues[0].message.includes("`url`"), "the message points the author to the URL");
+		assert.true(result.operations.fetch.invalid, "stored invalid");
+	});
+	(0, import_qunit.test)("a path value written as text that fills one segment lowers", async function(assert) {
+		let result = await lowerRequest({
+			url: "https://api.example.com/models/{model}",
+			path: { model: "gpt-4.1" }
+		});
+		assert.deepEqual(codes(result), []);
+		assert.deepEqual(result.operations.fetch.callApi?.path, { model: "gpt-4.1" });
+		let paired = await lowerRequest({
+			url: "https://api.example.com/tags/{tag}",
+			path: { tag: "party-🎉" }
+		});
+		assert.deepEqual(codes(paired), [], "a surrogate pair is valid Unicode");
+	});
+	(0, import_qunit.test)("a slot outside a header value, a query value, a path value and the body is refused", async function(assert) {
+		let inURL = await lowerRequest({ url: "https://api.example.com/items?key={{apiKey}}" });
+		assert.deepEqual(codes(inURL), ["slot-out-of-place"]);
+		let inHeaderName = await lowerRequest({
+			url: "https://api.example.com/items",
+			headers: { "{{apiKey}}": "x" }
+		});
+		assert.true(codes(inHeaderName).includes("slot-out-of-place"));
+		let inQueryName = await lowerRequest({
+			url: "https://api.example.com/items",
+			query: { "{{apiKey}}": "x" }
+		});
+		assert.deepEqual(codes(inQueryName), ["slot-out-of-place"]);
+		let inBodyKey = await lowerRequest({
+			url: "https://api.example.com/items",
+			json: { auth: { "{{apiKey}}": "x" } }
+		});
+		assert.deepEqual(codes(inBodyKey), ["slot-out-of-place"], "a member's name is sent as written");
+		let inVariableName = await lowerRequest({
+			url: "https://api.example.com/graphql",
+			graphql: {
+				document: "query { viewer { id } }",
+				variables: { "{{apiKey}}": "x" }
+			}
+		});
+		assert.deepEqual(codes(inVariableName), ["slot-out-of-place"]);
+		let inDocument = await lowerRequest({
+			url: "https://api.example.com/graphql",
+			graphql: { document: "query { viewer(token: \"{{apiKey}}\") { id } }" }
+		});
+		assert.deepEqual(codes(inDocument), ["slot-out-of-place"]);
+	});
+	(0, import_qunit.test)("a GraphQL document built from values is refused", async function(assert) {
+		let computed = await lowerRequest({
+			url: "https://api.example.com/graphql",
+			graphql: { document: ownerParam }
+		}, { params: { owner: StringField } });
+		assert.deepEqual(codes(computed), ["string-built-graphql"]);
+		let spliced = await lowerRequest({
+			url: "https://api.example.com/graphql",
+			graphql: { document: `query { repo(owner: "${String({})}") { id } }` }
+		});
+		assert.deepEqual(codes(spliced), ["string-built-graphql"]);
+	});
+	(0, import_qunit.test)("a malformed slot is refused rather than sent as text", async function(assert) {
+		let result = await lowerRequest({
+			url: "https://api.example.com/items",
+			headers: { authorization: "Bearer {{apiKey|rot13}}" }
+		});
+		assert.deepEqual(codes(result), ["invalid-slot"]);
+		let foreign = await lowerRequest({
+			url: "https://api.example.com/items",
+			json: { template: "Hello {{name}}" }
+		});
+		assert.deepEqual(codes(foreign), [], "a vendor's own template text is not a slot");
+	});
+	(0, import_qunit.test)("a callApi runs no program", async function(assert) {
+		let result = await lowerRequest({ url: "https://api.example.com/items" }, { transformations: { $bxl: ".x=1;" } });
+		assert.deepEqual(codes(result), ["unrunnable-program"]);
+	});
+	(0, import_qunit.test)("a callApi is built on a card, not on a file", async function(assert) {
+		let { FileDef } = api;
+		class Notes extends FileDef {
+			static displayName = "Notes";
+		}
+		shim({ Notes });
+		let result = await lowerOperationDeclarations({ fetch: {
+			base: "callApi",
+			url: "https://api.example.com/items"
+		} }, {
+			definition: buildDefinition(Notes),
+			lookupDefinition,
+			identifyCard: (target) => identifyCard(target)
+		});
+		assert.deepEqual(codes(result), ["base-not-carried"]);
+	});
+});
+//#endregion