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

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

@@ -1,2957 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
-import { Br as testRealmURL, 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-B02-sD_L.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-Dd8k0DNa.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