@cardstack/boxel-cli 0.3.2-unstable.58 → 0.3.2-unstable.60

package/bundled-test-harness/assets/index-query-engine-test-DJnDqmfK.js

@@ -1,2548 +0,0 @@
-import { s as __toESM } from "./chunk-CGdGNDIi.js";
-import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime-CYyqkz5q-z3Y1hsJm.js";
-import { Fi as Loader, Jr as wrapper_default, Lr as getFieldDefinitions, X as IndexQueryEngine, Zn as testRealmURL, _t as fetcher, gt as maybeHandleScopedCSSRequest, o as internalKeyFor, ua as rri, v as VirtualNetwork, vi as baseRealm, vr as identifyCard, zr as FilterRefersToNonexistentTypeError } from "./runtime-common-C7uLt5dN.js";
-import { d as format } from "./esm-CCOu76Mh.js";
-import { t as config } from "./environment-DTzm0NP_.js";
-import { t as shimExternals } from "./externals-Do1fVZ4j.js";
-import { t as require_qunit } from "./qunit-2hoQyeAZ.js";
-import { $ as setupIndex, Q as serializeCard, Z as getTypes, v as getDbAdapter } from "./mock-matrix-DqDbNhEj.js";
-import { t as p } from "./helpers-D_JZYUOQ.js";
-//#region tests/unit/index-query-engine-test.ts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var cardApi;
-var string;
-var date;
-var number;
-var boolean;
-var codeRef;
-var { resolvedBaseRealmURL } = config;
-(0, import_qunit.module)("Unit | query", function(hooks) {
-	let dbAdapter;
-	let indexQueryEngine;
-	let loader;
-	let testCards = {};
-	let virtualNetwork;
-	hooks.before(async function() {
-		dbAdapter = await getDbAdapter();
-	});
-	hooks.beforeEach(async function() {
-		virtualNetwork = new VirtualNetwork();
-		virtualNetwork.addURLMapping(new URL(baseRealm.url), new URL(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 });
-		cardApi = await loader.import(`${baseRealm.url}card-api`);
-		string = await loader.import(`${baseRealm.url}string`);
-		date = await loader.import(`${baseRealm.url}date`);
-		number = await loader.import(`${baseRealm.url}number`);
-		boolean = await loader.import(`${baseRealm.url}boolean`);
-		codeRef = await loader.import(`${baseRealm.url}code-ref`);
-		let { field, contains, containsMany, linksToMany, linksTo, CardDef, FieldDef, setCardAsSavedForTest } = cardApi;
-		let { default: StringField } = string;
-		let { default: CodeRefField } = codeRef;
-		let { default: DateField } = date;
-		let { default: NumberField } = number;
-		let { default: BooleanField } = boolean;
-		class Address extends FieldDef {
-			static {
-				decorateFieldV2(this.prototype, "street", [field], function() {
-					return contains(StringField);
-				});
-			}
-			#street = (initializeDeferredDecorator(this, "street"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "city", [field], function() {
-					return contains(StringField);
-				});
-			}
-			#city = (initializeDeferredDecorator(this, "city"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "number", [field], function() {
-					return contains(NumberField);
-				});
-			}
-			#number = (initializeDeferredDecorator(this, "number"), void 0);
-		}
-		class Person extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "name", [field], function() {
-					return contains(StringField);
-				});
-			}
-			#name = (initializeDeferredDecorator(this, "name"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "nickNames", [field], function() {
-					return containsMany(StringField);
-				});
-			}
-			#nickNames = (initializeDeferredDecorator(this, "nickNames"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "address", [field], function() {
-					return contains(Address);
-				});
-			}
-			#address = (initializeDeferredDecorator(this, "address"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "bestFriend", [field], function() {
-					return linksTo(() => Person);
-				});
-			}
-			#bestFriend = (initializeDeferredDecorator(this, "bestFriend"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "friends", [field], function() {
-					return linksToMany(() => Person);
-				});
-			}
-			#friends = (initializeDeferredDecorator(this, "friends"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "age", [field], function() {
-					return contains(NumberField);
-				});
-			}
-			#age = (initializeDeferredDecorator(this, "age"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "isHairy", [field], function() {
-					return contains(BooleanField);
-				});
-			}
-			#isHairy = (initializeDeferredDecorator(this, "isHairy"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "lotteryNumbers", [field], function() {
-					return containsMany(NumberField);
-				});
-			}
-			#lotteryNumbers = (initializeDeferredDecorator(this, "lotteryNumbers"), void 0);
-		}
-		class FancyPerson extends Person {
-			static {
-				decorateFieldV2(this.prototype, "favoriteColor", [field], function() {
-					return contains(StringField);
-				});
-			}
-			#favoriteColor = (initializeDeferredDecorator(this, "favoriteColor"), void 0);
-		}
-		class Cat extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "name", [field], function() {
-					return contains(StringField);
-				});
-			}
-			#name = (initializeDeferredDecorator(this, "name"), void 0);
-		}
-		class SimpleSpec extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
-					return contains(StringField);
-				});
-			}
-			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "ref", [field], function() {
-					return contains(CodeRefField);
-				});
-			}
-			#ref = (initializeDeferredDecorator(this, "ref"), void 0);
-		}
-		class Event extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
-					return contains(StringField);
-				});
-			}
-			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "venue", [field], function() {
-					return contains(StringField);
-				});
-			}
-			#venue = (initializeDeferredDecorator(this, "venue"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "date", [field], function() {
-					return contains(DateField);
-				});
-			}
-			#date = (initializeDeferredDecorator(this, "date"), void 0);
-		}
-		loader.shimModule(`${testRealmURL}address`, { Address });
-		loader.shimModule(`${testRealmURL}person`, { Person });
-		loader.shimModule(`${testRealmURL}fancy-person`, { FancyPerson });
-		loader.shimModule(`${testRealmURL}cat`, { Cat });
-		loader.shimModule(`${testRealmURL}spec`, { SimpleSpec });
-		loader.shimModule(`${testRealmURL}event`, { Event });
-		let stringFieldEntry = new SimpleSpec({
-			cardTitle: "String Field",
-			ref: {
-				module: `${baseRealm.url}string`,
-				name: "default"
-			}
-		});
-		let numberFieldEntry = new SimpleSpec({
-			cardTitle: "Number Field",
-			ref: {
-				module: `${baseRealm.url}number`,
-				name: "default"
-			}
-		});
-		let ringo = new Person({
-			name: "Ringo",
-			address: new Address({
-				street: "100 Treat Street",
-				city: "Waggington"
-			})
-		});
-		let vangogh = new Person({
-			name: "Van Gogh",
-			address: new Address({
-				street: "456 Grand Blvd",
-				city: "Barksville"
-			}),
-			bestFriend: ringo,
-			friends: [ringo]
-		});
-		testCards = {
-			mango: new FancyPerson({
-				name: "Mango",
-				address: new Address({
-					street: "123 Main Street",
-					city: "Barksville"
-				}),
-				bestFriend: vangogh,
-				friends: [vangogh, ringo]
-			}),
-			vangogh,
-			ringo,
-			paper: new Cat({ name: "Paper" }),
-			mangoBirthday: new Event({
-				cardTitle: "Mango's Birthday",
-				venue: "Dog Park",
-				date: p("2024-10-30")
-			}),
-			vangoghBirthday: new Event({
-				cardTitle: "Van Gogh's Birthday",
-				venue: "Backyard",
-				date: p("2024-11-19")
-			}),
-			stringFieldEntry,
-			numberFieldEntry
-		};
-		for (let [name, card] of Object.entries(testCards)) {
-			card.id = rri(`${testRealmURL}${name}`);
-			setCardAsSavedForTest(card);
-		}
-		let api = await loader.import(`${baseRealm.url}card-api`);
-		async function buildDefinition(cardDef) {
-			let { fields, fieldDefs } = getFieldDefinitions(api, cardDef);
-			return {
-				codeRef: identifyCard(cardDef),
-				displayName: cardDef.displayName,
-				fields,
-				fieldDefs
-			};
-		}
-		await dbAdapter.reset();
-		indexQueryEngine = new IndexQueryEngine(dbAdapter, {
-			async lookupDefinition(codeRef) {
-				switch (internalKeyFor(codeRef, void 0, virtualNetwork)) {
-					case `${testRealmURL}address/Address`: return await buildDefinition(Address);
-					case `${testRealmURL}person/Person`: return await buildDefinition(Person);
-					case `${testRealmURL}fancy-person/FancyPerson`: return await buildDefinition(FancyPerson);
-					case `${testRealmURL}cat/Cat`: return await buildDefinition(Cat);
-					case `${testRealmURL}spec/SimpleSpec`: return await buildDefinition(SimpleSpec);
-					case `${testRealmURL}event/Event`: return await buildDefinition(Event);
-					default: throw new FilterRefersToNonexistentTypeError(codeRef, { cause: `Definition for ${wrapper_default(codeRef)} not found` });
-				}
-			},
-			async lookupCachedDefinition() {},
-			async invalidate(_realmURL) {
-				return [];
-			},
-			async clearRealmDefinitions(_realmURL) {},
-			async getCachedDefinitions() {},
-			async populateDefinitionCacheEntry() {},
-			async getCachedDefinitionsBatch() {
-				return {};
-			},
-			registerRealm() {},
-			async clearAllDefinitions() {},
-			forRealm() {
-				return this;
-			}
-		}, virtualNetwork);
-	});
-	(0, import_qunit.test)("can get all cards with empty filter", async function(assert) {
-		let { mango, vangogh, paper } = testCards;
-		await setupIndex(dbAdapter, [
-			mango,
-			vangogh,
-			paper
-		]);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), {});
-		assert.strictEqual(meta.page.total, 3, "the total results meta is correct");
-		assert.deepEqual(results, [
-			await serializeCard(mango),
-			await serializeCard(paper),
-			await serializeCard(vangogh)
-		], "results are correct");
-	});
-	(0, import_qunit.test)("deleted cards are not included in results", async function(assert) {
-		let { mango, vangogh, paper } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { is_deleted: false }
-			},
-			{
-				card: vangogh,
-				data: { is_deleted: null }
-			},
-			{
-				card: paper,
-				data: { is_deleted: true }
-			}
-		]);
-		let { meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), {});
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-	});
-	(0, import_qunit.test)("error docs are not included in results", async function(assert) {
-		let { mango, vangogh } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				url: `${testRealmURL}1.json`,
-				type: "instance",
-				has_error: true,
-				realm_version: 1,
-				realm_url: testRealmURL,
-				pristine_doc: void 0,
-				types: [],
-				error_doc: {
-					message: "test error",
-					status: 500,
-					additionalErrors: []
-				}
-			},
-			{
-				url: `${testRealmURL}mango.json`,
-				type: "instance",
-				realm_version: 1,
-				realm_url: testRealmURL,
-				pristine_doc: await serializeCard(mango),
-				types: await getTypes(mango),
-				error_doc: void 0
-			},
-			{
-				url: `${testRealmURL}vangogh.json`,
-				type: "instance",
-				realm_version: 1,
-				realm_url: testRealmURL,
-				pristine_doc: await serializeCard(vangogh),
-				types: await getTypes(vangogh),
-				error_doc: void 0
-			}
-		]);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), {});
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mango.id, vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)("can filter by type", async function(assert) {
-		let { mango, vangogh, paper } = testCards;
-		await setupIndex(dbAdapter, [
-			mango,
-			vangogh,
-			paper
-		]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: { type } });
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mango.id, vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can filter using 'eq'`, async function(assert) {
-		let { mango, vangogh, paper } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: { name: "Mango" } }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: { name: "Van Gogh" } }
-			},
-			{
-				card: paper,
-				data: { search_doc: { name: "Mango" } }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			eq: { name: "Mango" },
-			on: type
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mango.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can filter using 'eq' thru nested fields`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: {
-					name: "Mango",
-					address: {
-						street: "123 Main Street",
-						city: "Barksville"
-					}
-				} }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: {
-					name: "Van Gogh",
-					address: {
-						street: "456 Grand Blvd",
-						city: "Barksville"
-					}
-				} }
-			},
-			{
-				card: ringo,
-				data: { search_doc: {
-					name: "Ringo",
-					address: {
-						street: "100 Treat Street",
-						city: "Waggington"
-					}
-				} }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			eq: { "address.city": "Barksville" }
-		} });
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mango.id, vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can use 'eq' to match multiple fields`, async function(assert) {
-		let { mango, vangogh } = testCards;
-		await setupIndex(dbAdapter, [{
-			card: mango,
-			data: { search_doc: {
-				name: "Mango",
-				nickNames: ["Mang Mang", "Baby"]
-			} }
-		}, {
-			card: vangogh,
-			data: { search_doc: {
-				name: "Van Gogh",
-				nickNames: ["Big boy", "Farty"]
-			} }
-		}]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			eq: {
-				name: "Van Gogh",
-				nickNames: "Farty"
-			}
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can use 'eq' to find 'null' values`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: { name: "Mango" } }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: { name: "Van Gogh" } }
-			},
-			{
-				card: ringo,
-				data: { search_doc: { name: null } }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			eq: { name: null }
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [ringo.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can use 'eq' to match against number type`, async function(assert) {
-		let { mango, vangogh } = testCards;
-		await setupIndex(dbAdapter, [{
-			card: mango,
-			data: { search_doc: {
-				name: "Mango",
-				age: 4
-			} }
-		}, {
-			card: vangogh,
-			data: { search_doc: {
-				name: "Van Gogh",
-				age: 8
-			} }
-		}]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			eq: { age: 4 }
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mango.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can use 'eq' to match against boolean type`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: {
-					name: "Mango",
-					isHairy: false
-				} }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: {
-					name: "Van Gogh",
-					isHairy: true
-				} }
-			},
-			{
-				card: ringo,
-				data: { search_doc: {
-					name: "Van Gogh",
-					isHairy: null
-				} }
-			}
-		]);
-		let type = await personCardType(testCards);
-		{
-			let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-				on: type,
-				eq: { isHairy: false }
-			} });
-			assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-			assert.deepEqual(getIds(results), [mango.id], "results are correct");
-		}
-		{
-			let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-				on: type,
-				eq: { isHairy: true }
-			} });
-			assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-			assert.deepEqual(getIds(results), [vangogh.id], "results are correct");
-		}
-		{
-			let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-				on: type,
-				eq: { isHairy: null }
-			} });
-			assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-			assert.deepEqual(getIds(results), [ringo.id], "results are correct");
-		}
-	});
-	(0, import_qunit.test)("can filter eq from a code ref query value", async function(assert) {
-		let { stringFieldEntry, numberFieldEntry } = testCards;
-		await setupIndex(dbAdapter, [{
-			card: stringFieldEntry,
-			data: { search_doc: {
-				cardTitle: stringFieldEntry.cardTitle,
-				ref: internalKeyFor(stringFieldEntry.ref, void 0, virtualNetwork)
-			} }
-		}, {
-			card: numberFieldEntry,
-			data: { search_doc: {
-				cardTitle: numberFieldEntry.cardTitle,
-				ref: internalKeyFor(numberFieldEntry.ref, void 0, virtualNetwork)
-			} }
-		}]);
-		let type = await SimpleSpecType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			eq: { ref: {
-				module: `${baseRealm.url}string`,
-				name: "default"
-			} }
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [stringFieldEntry.id], "results are correct");
-	});
-	(0, import_qunit.test)("can filter eq from a date query value", async function(assert) {
-		let { mangoBirthday, vangoghBirthday } = testCards;
-		await setupIndex(dbAdapter, [{
-			card: mangoBirthday,
-			data: { search_doc: {
-				cardTitle: mangoBirthday.cardTitle,
-				venue: mangoBirthday.venue,
-				date: format(mangoBirthday.date, "yyyy-MM-dd")
-			} }
-		}, {
-			card: vangoghBirthday,
-			data: { search_doc: {
-				cardTitle: vangoghBirthday.cardTitle,
-				venue: vangoghBirthday.venue,
-				date: format(vangoghBirthday.date, "yyyy-MM-dd")
-			} }
-		}]);
-		let type = await eventType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			eq: { date: "2024-10-30" }
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mangoBirthday.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can filter using 'in'`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: { name: "Mango" } }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: { name: "Van Gogh" } }
-			},
-			{
-				card: ringo,
-				data: { search_doc: { name: "Ringo" } }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			in: { name: ["Mango", "Ringo"] },
-			on: type
-		} });
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mango.id, ringo.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can filter using 'in' with a single value`, async function(assert) {
-		let { mango, vangogh } = testCards;
-		await setupIndex(dbAdapter, [{
-			card: mango,
-			data: { search_doc: { name: "Mango" } }
-		}, {
-			card: vangogh,
-			data: { search_doc: { name: "Van Gogh" } }
-		}]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			in: { name: ["Mango"] },
-			on: type
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mango.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can filter using 'in' with an empty array`, async function(assert) {
-		let { mango, vangogh } = testCards;
-		await setupIndex(dbAdapter, [{
-			card: mango,
-			data: { search_doc: { name: "Mango" } }
-		}, {
-			card: vangogh,
-			data: { search_doc: { name: "Van Gogh" } }
-		}]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			in: { name: [] },
-			on: type
-		} });
-		assert.strictEqual(meta.page.total, 0, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [], "results are correct");
-	});
-	(0, import_qunit.test)(`can filter using 'in' with null values`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: { name: "Mango" } }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: { name: null } }
-			},
-			{
-				card: ringo,
-				data: { search_doc: { name: "Ringo" } }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			in: { name: ["Mango", null] },
-			on: type
-		} });
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mango.id, vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can filter using 'in' thru nested fields`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: {
-					name: "Mango",
-					address: { city: "Barksville" }
-				} }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: {
-					name: "Van Gogh",
-					address: { city: "Barksville" }
-				} }
-			},
-			{
-				card: ringo,
-				data: { search_doc: {
-					name: "Ringo",
-					address: { city: "Waggington" }
-				} }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			in: { "address.city": ["Waggington"] }
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [ringo.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can negate an 'in' filter with 'not'`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: { name: "Mango" } }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: { name: "Van Gogh" } }
-			},
-			{
-				card: ringo,
-				data: { search_doc: { name: "Ringo" } }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			not: { in: { name: ["Mango", "Ringo"] } }
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can filter using 'in' with the id field`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: {
-					id: mango.id,
-					name: "Mango"
-				} }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: {
-					id: vangogh.id,
-					name: "Van Gogh"
-				} }
-			},
-			{
-				card: ringo,
-				data: { search_doc: {
-					id: ringo.id,
-					name: "Ringo"
-				} }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			in: { id: [mango.id, ringo.id] }
-		} });
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mango.id, ringo.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can search with a 'not' filter`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: { name: "Mango" } }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: { name: "Van Gogh" } }
-			},
-			{
-				card: ringo,
-				data: { search_doc: { name: "Ringo" } }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			not: { eq: { name: "Mango" } }
-		} });
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [ringo.id, vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)("can handle a filter with double negatives", async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: { name: "Mango" } }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: { name: "Van Gogh" } }
-			},
-			{
-				card: ringo,
-				data: { search_doc: { name: "Ringo" } }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			not: { not: { not: { eq: { name: "Mango" } } } }
-		} });
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [ringo.id, vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can use a 'contains' filter`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: { name: "Mango" } }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: { name: "Van Gogh" } }
-			},
-			{
-				card: ringo,
-				data: { search_doc: { name: "Ringo" } }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			contains: { name: "ngo" }
-		} });
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mango.id, ringo.id], "results are correct");
-	});
-	(0, import_qunit.test)(`contains filter is case insensitive`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: { name: "Mango" } }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: { name: "Van Gogh" } }
-			},
-			{
-				card: ringo,
-				data: { search_doc: { name: "Ringo" } }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			contains: { name: "mang" }
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mango.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can use 'contains' to match multiple fields`, async function(assert) {
-		let { mango, vangogh } = testCards;
-		await setupIndex(dbAdapter, [{
-			card: mango,
-			data: { search_doc: {
-				name: "Mango",
-				nickNames: ["Mang Mang", "Pee Baby"]
-			} }
-		}, {
-			card: vangogh,
-			data: { search_doc: {
-				name: "Van Gogh",
-				nickNames: ["Big Baby", "Farty"]
-			} }
-		}]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			contains: {
-				name: "ngo",
-				nickNames: "Baby"
-			}
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mango.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can use a 'contains' filter to match 'null'`, async function(assert) {
-		let { mango, vangogh } = testCards;
-		await setupIndex(dbAdapter, [{
-			card: mango,
-			data: { search_doc: { name: "Mango" } }
-		}, {
-			card: vangogh,
-			data: { search_doc: { name: null } }
-		}]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			contains: { name: null }
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can use 'every' to combine multiple filters`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: {
-					name: "Mango",
-					address: {
-						street: "123 Main Street",
-						city: "Barksville"
-					}
-				} }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: {
-					name: "Van Gogh",
-					address: {
-						street: "456 Grand Blvd",
-						city: "Barksville"
-					}
-				} }
-			},
-			{
-				card: ringo,
-				data: { search_doc: {
-					name: "Ringo",
-					address: {
-						street: "100 Treat Street",
-						city: "Waggington"
-					}
-				} }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			every: [{ eq: { "address.city": "Barksville" } }, { not: { eq: { "address.street": "456 Grand Blvd" } } }]
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mango.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can use 'any' to combine multiple filters`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: { name: "Mango" } }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: { name: "Van Gogh" } }
-			},
-			{
-				card: ringo,
-				data: { search_doc: { name: "Ringo" } }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			any: [{ eq: { name: "Mango" } }, { eq: { name: "Van Gogh" } }]
-		} });
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mango.id, vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)(`returns empty results when query refers to missing card`, async function(assert) {
-		await setupIndex(dbAdapter, []);
-		let { cards, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: {
-				module: `${testRealmURL}nonexistent`,
-				name: "Nonexistent"
-			},
-			eq: { nonExistentField: "hello" }
-		} });
-		assert.strictEqual(cards.length, 0, "no cards are returned");
-		assert.strictEqual(meta.page.total, 0, "total count is zero");
-	});
-	(0, import_qunit.test)(`gives a good error when query refers to missing field`, async function(assert) {
-		await setupIndex(dbAdapter, []);
-		let type = await personCardType(testCards);
-		try {
-			await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-				on: type,
-				eq: {
-					name: "Cardy",
-					nonExistentField: "hello"
-				}
-			} });
-			throw new Error("failed to throw expected exception");
-		} catch (err) {
-			assert.strictEqual(err.message, `Your filter refers to a nonexistent field "nonExistentField" on type ${wrapper_default(type)}`);
-		}
-	});
-	(0, import_qunit.test)(`it can filter on a plural primitive field using 'eq'`, async function(assert) {
-		let { mango, vangogh } = testCards;
-		await setupIndex(dbAdapter, [{
-			card: mango,
-			data: { search_doc: {
-				name: "Mango",
-				nickNames: ["Mang Mang", "Baby"]
-			} }
-		}, {
-			card: vangogh,
-			data: { search_doc: {
-				name: "Van Gogh",
-				nickNames: ["Big boy", "Farty"]
-			} }
-		}]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			eq: { nickNames: "Farty" }
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)(`it can filter on a nested field within a plural composite field using 'eq'`, async function(assert) {
-		let { mango, vangogh } = testCards;
-		await setupIndex(dbAdapter, [{
-			card: mango,
-			data: { search_doc: {
-				name: "Mango",
-				friends: [{ name: "Van Gogh" }, { name: "Ringo" }]
-			} }
-		}, {
-			card: vangogh,
-			data: { search_doc: {
-				name: "Van Gogh",
-				friends: [{ name: "Ringo" }]
-			} }
-		}]);
-		let type = await personCardType(testCards);
-		{
-			let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-				on: type,
-				eq: { "friends.name": "Van Gogh" }
-			} });
-			assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-			assert.deepEqual(getIds(results), [mango.id], "results are correct");
-		}
-		{
-			let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-				on: type,
-				eq: { "friends.name": "Ringo" }
-			} });
-			assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-			assert.deepEqual(getIds(results), [mango.id, vangogh.id], "results are correct");
-		}
-	});
-	(0, import_qunit.test)("it can match a null in a plural field", async function(assert) {
-		let { mango, vangogh } = testCards;
-		await setupIndex(dbAdapter, [{
-			card: mango,
-			data: { search_doc: {
-				name: "Mango",
-				nickNames: ["Mang Mang", "Baby"]
-			} }
-		}, {
-			card: vangogh,
-			data: { search_doc: {
-				name: "Van Gogh",
-				nickNames: null
-			} }
-		}]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			eq: { nickNames: null }
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)("it can match a leaf plural field nested in a plural composite field", async function(assert) {
-		let { mango, vangogh } = testCards;
-		await setupIndex(dbAdapter, [{
-			card: mango,
-			data: { search_doc: {
-				name: "Mango",
-				friends: [{
-					name: "Van Gogh",
-					nickNames: ["Big Baby", "Farty"]
-				}, {
-					name: "Ringo",
-					nickNames: ["Mang Mang", "Baby"]
-				}]
-			} }
-		}, {
-			card: vangogh,
-			data: { search_doc: {
-				name: "Van Gogh",
-				friends: [{
-					name: "Ringo",
-					nickNames: ["Ring Ring"]
-				}]
-			} }
-		}]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			eq: { "friends.nickNames": "Baby" }
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mango.id], "results are correct");
-	});
-	(0, import_qunit.test)("it can match thru a plural nested composite field that is field of a singular composite field", async function(assert) {
-		let { mango, vangogh } = testCards;
-		await setupIndex(dbAdapter, [{
-			card: mango,
-			data: { search_doc: {
-				name: "Mango",
-				bestFriend: {
-					name: "Van Gogh",
-					friends: [{ name: "Ringo" }, { name: "Van Gogh" }]
-				}
-			} }
-		}, {
-			card: vangogh,
-			data: { search_doc: {
-				name: "Van Gogh",
-				bestFriend: {
-					name: "Ringo",
-					friends: [{ name: "Lucky" }]
-				}
-			} }
-		}]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			eq: { "bestFriend.friends.name": "Lucky" }
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can return a single result for a card when there are multiple matches within a result's search doc`, async function(assert) {
-		let { mango } = testCards;
-		await setupIndex(dbAdapter, [{
-			card: mango,
-			data: { search_doc: {
-				name: "Mango",
-				friends: [{
-					name: "Ringo",
-					bestFriend: { name: "Mango" }
-				}, {
-					name: "Van Gogh",
-					bestFriend: { name: "Mango" }
-				}]
-			} }
-		}]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			eq: { "friends.bestFriend.name": "Mango" }
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mango.id], "results are correct");
-	});
-	(0, import_qunit.test)("can perform query against WIP version of the index", async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [{
-			realm_url: testRealmURL,
-			current_version: 1
-		}], {
-			working: [
-				{
-					card: mango,
-					data: {
-						realm_version: 1,
-						search_doc: { name: "Mango" }
-					}
-				},
-				{
-					card: vangogh,
-					data: {
-						realm_version: 2,
-						search_doc: { name: "Mango" }
-					}
-				},
-				{
-					card: ringo,
-					data: {
-						realm_version: 2,
-						search_doc: { name: "Ringo" }
-					}
-				}
-			],
-			production: [
-				{
-					card: mango,
-					data: {
-						realm_version: 1,
-						search_doc: { name: "Mango" }
-					}
-				},
-				{
-					card: vangogh,
-					data: {
-						realm_version: 1,
-						search_doc: { name: "Van Gogh" }
-					}
-				},
-				{
-					card: ringo,
-					data: {
-						realm_version: 1,
-						search_doc: { name: "Mango" }
-					}
-				}
-			]
-		});
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			eq: { name: "Mango" }
-		} }, { useWorkInProgressIndex: true });
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mango.id, vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)("can perform query against \"production\" version of the index", async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [{
-			realm_url: testRealmURL,
-			current_version: 1
-		}], {
-			working: [
-				{
-					card: mango,
-					data: {
-						realm_version: 1,
-						search_doc: { name: "Mango" }
-					}
-				},
-				{
-					card: vangogh,
-					data: {
-						realm_version: 2,
-						search_doc: { name: "Mango" }
-					}
-				},
-				{
-					card: ringo,
-					data: {
-						realm_version: 1,
-						search_doc: { name: "Ringo" }
-					}
-				}
-			],
-			production: [
-				{
-					card: mango,
-					data: {
-						realm_version: 1,
-						search_doc: { name: "Mango" }
-					}
-				},
-				{
-					card: vangogh,
-					data: {
-						realm_version: 1,
-						search_doc: { name: "Van Gogh" }
-					}
-				},
-				{
-					card: ringo,
-					data: {
-						realm_version: 1,
-						search_doc: { name: "Ringo" }
-					}
-				}
-			]
-		});
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			eq: { name: "Mango" }
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [mango.id], "results are correct");
-	});
-	(0, import_qunit.test)("can sort search results", async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: { name: "Mango" } }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: { name: "Van Gogh" } }
-			},
-			{
-				card: ringo,
-				data: { search_doc: { name: "Ringo" } }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { sort: [{
-			on: type,
-			by: "name"
-		}] });
-		assert.strictEqual(meta.page.total, 3, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [
-			mango.id,
-			ringo.id,
-			vangogh.id
-		], "results are correct");
-	});
-	(0, import_qunit.test)("can sort descending", async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: { name: "Mango" } }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: { name: "Van Gogh" } }
-			},
-			{
-				card: ringo,
-				data: { search_doc: { name: "Ringo" } }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards: results, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { sort: [{
-			on: type,
-			by: "name",
-			direction: "desc"
-		}] });
-		assert.strictEqual(meta.page.total, 3, "the total results meta is correct");
-		assert.deepEqual(getIds(results), [
-			vangogh.id,
-			ringo.id,
-			mango.id
-		], "results are correct");
-	});
-	(0, import_qunit.test)("nulls are sorted to the end of search results", async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: { name: "Mango" } }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: { name: null } }
-			},
-			{
-				card: ringo,
-				data: { search_doc: { name: "Ringo" } }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards: results } = await indexQueryEngine.searchCards(new URL(testRealmURL), { sort: [{
-			on: type,
-			by: "name"
-		}] });
-		assert.deepEqual(getIds(results), [
-			mango.id,
-			ringo.id,
-			vangogh.id
-		], "results are correct");
-	});
-	(0, import_qunit.test)(`can filter using 'gt'`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: {
-					name: "Mango",
-					address: {
-						street: "123 Main Street",
-						city: "Barksville"
-					},
-					age: 35
-				} }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: {
-					name: "Van Gogh",
-					address: {
-						street: "456 Grand Blvd",
-						city: "Barksville"
-					},
-					age: 30
-				} }
-			},
-			{
-				card: ringo,
-				data: { search_doc: {
-					name: "Ringo",
-					address: {
-						street: "100 Treat Street",
-						city: "Waggington"
-					},
-					age: 25
-				} }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			range: { age: { gt: 25 } }
-		} });
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(cards), [mango.id, vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)(`range filter works when both 'type' and 'on' are provided`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: {
-					name: "Mango",
-					address: {
-						street: "123 Main Street",
-						city: "Barksville"
-					},
-					age: 35
-				} }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: {
-					name: "Van Gogh",
-					address: {
-						street: "456 Grand Blvd",
-						city: "Barksville"
-					},
-					age: 30
-				} }
-			},
-			{
-				card: ringo,
-				data: { search_doc: {
-					name: "Ringo",
-					address: {
-						street: "100 Treat Street",
-						city: "Waggington"
-					},
-					age: 25
-				} }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			type,
-			range: { age: { gt: 25 } }
-		} });
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(cards), [mango.id, vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)(`eq filter works when both 'type' and 'on' are provided`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: { name: "Mango" } }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: { name: "Van Gogh" } }
-			},
-			{
-				card: ringo,
-				data: { search_doc: { name: "Ringo" } }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			type,
-			eq: { name: "Mango" }
-		} });
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(cards), [mango.id], "results are correct");
-	});
-	(0, import_qunit.test)(`contains filter works when both 'type' and 'on' are provided`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: {
-					name: "Mango",
-					address: { city: "Barksville" }
-				} }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: {
-					name: "Van Gogh",
-					address: { city: "Barksville" }
-				} }
-			},
-			{
-				card: ringo,
-				data: { search_doc: {
-					name: "Ringo",
-					address: { city: "Waggington" }
-				} }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			type,
-			contains: { "address.city": "Barks" }
-		} });
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(cards), [mango.id, vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)(`not filter works when both 'type' and 'on' are provided`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: { name: "Mango" } }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: { name: "Van Gogh" } }
-			},
-			{
-				card: ringo,
-				data: { search_doc: { name: "Ringo" } }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), {
-			filter: {
-				on: type,
-				type,
-				not: { eq: { name: "Mango" } }
-			},
-			sort: [{
-				on: type,
-				by: "name",
-				direction: "asc"
-			}]
-		});
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(cards), [ringo.id, vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)(`'on' takes precedence over 'type' when they differ`, async function(assert) {
-		let { mango, vangogh, ringo, paper } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: {
-					name: "Mango",
-					address: {
-						street: "123 Main Street",
-						city: "Barksville"
-					},
-					age: 35
-				} }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: {
-					name: "Van Gogh",
-					address: {
-						street: "456 Grand Blvd",
-						city: "Barksville"
-					},
-					age: 30
-				} }
-			},
-			{
-				card: ringo,
-				data: { search_doc: {
-					name: "Ringo",
-					address: {
-						street: "100 Treat Street",
-						city: "Waggington"
-					},
-					age: 25
-				} }
-			},
-			{
-				card: paper,
-				data: { search_doc: {
-					name: "Paper",
-					age: 99
-				} }
-			}
-		]);
-		let personType = await personCardType(testCards);
-		let catType = internalKeyToCodeRef([...await getTypes(paper)].shift());
-		let { cards, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: personType,
-			type: catType,
-			range: { age: { gt: 25 } }
-		} });
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(cards), [mango.id, vangogh.id], "results are drawn from the on type and ignore conflicting type");
-	});
-	(0, import_qunit.test)(`can filter using 'gte'`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: {
-					name: "Mango",
-					address: {
-						street: "123 Main Street",
-						city: "Barksville"
-					},
-					age: 35
-				} }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: {
-					name: "Van Gogh",
-					address: {
-						street: "456 Grand Blvd",
-						city: "Barksville"
-					},
-					age: 30
-				} }
-			},
-			{
-				card: ringo,
-				data: { search_doc: {
-					name: "Ringo",
-					address: {
-						street: "100 Treat Street",
-						city: "Waggington"
-					},
-					age: 25
-				} }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), {
-			filter: {
-				on: type,
-				range: { age: { gte: 25 } }
-			},
-			sort: [{
-				on: type,
-				by: "age",
-				direction: "desc"
-			}]
-		});
-		assert.strictEqual(meta.page.total, 3, "the total results meta is correct");
-		assert.deepEqual(getIds(cards), [
-			mango.id,
-			vangogh.id,
-			ringo.id
-		], "results are correct");
-	});
-	(0, import_qunit.test)(`can filter using 'gt' thru nested fields`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: {
-					name: "Mango",
-					address: {
-						street: "123 Main Street",
-						city: "Barksville",
-						number: 123
-					}
-				} }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: {
-					name: "Van Gogh",
-					address: {
-						street: "456 Grand Blvd",
-						city: "Barksville",
-						number: 456
-					}
-				} }
-			},
-			{
-				card: ringo,
-				data: { search_doc: {
-					name: "Ringo",
-					address: {
-						street: "100 Treat Street",
-						city: "Waggington",
-						number: 100
-					}
-				} }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			range: { "address.number": { gt: 100 } }
-		} });
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(cards), [mango.id, vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can filter using 'gt' thru a plural primitive field`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: {
-					name: "Mango",
-					lotteryNumbers: [
-						20,
-						50,
-						70
-					]
-				} }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: {
-					name: "Van Gogh",
-					lotteryNumbers: [
-						40,
-						60,
-						80
-					]
-				} }
-			},
-			{
-				card: ringo,
-				data: { search_doc: {
-					name: "Ringo",
-					lotteryNumbers: [
-						10,
-						20,
-						30
-					]
-				} }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			range: { lotteryNumbers: { gt: 50 } }
-		} });
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(cards), [mango.id, vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can filter using 'gt' thru a plural composite field`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		let mangoDoc = {
-			name: "Mango",
-			age: 35
-		};
-		let vanGoghDoc = {
-			name: "Van Gogh",
-			age: 30
-		};
-		let ringoDoc = {
-			name: "Ringo",
-			age: 25
-		};
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: {
-					...mangoDoc,
-					friends: [{ ...vanGoghDoc }]
-				} }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: {
-					...vanGoghDoc,
-					friends: [{ ...ringoDoc }]
-				} }
-			},
-			{
-				card: ringo,
-				data: { search_doc: {
-					...ringoDoc,
-					friends: [{ ...mangoDoc }]
-				} }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			range: { "friends.age": { gt: 25 } }
-		} });
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(cards), [mango.id, ringo.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can filter using 'lt'`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: {
-					name: "Mango",
-					address: {
-						street: "123 Main Street",
-						city: "Barksville"
-					},
-					age: 35
-				} }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: {
-					name: "Van Gogh",
-					address: {
-						street: "456 Grand Blvd",
-						city: "Barksville"
-					},
-					age: 30
-				} }
-			},
-			{
-				card: ringo,
-				data: { search_doc: {
-					name: "Ringo",
-					address: {
-						street: "100 Treat Street",
-						city: "Waggington"
-					},
-					age: 25
-				} }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), {
-			filter: {
-				on: type,
-				range: { age: { lt: 35 } }
-			},
-			sort: [{
-				on: type,
-				by: "age",
-				direction: "desc"
-			}]
-		});
-		assert.strictEqual(meta.page.total, 2, "the total results meta is correct");
-		assert.deepEqual(getIds(cards), [vangogh.id, ringo.id], "results are correct");
-	});
-	(0, import_qunit.test)(`can filter using 'lte'`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: {
-					name: "Mango",
-					address: {
-						street: "123 Main Street",
-						city: "Barksville"
-					},
-					age: 35
-				} }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: {
-					name: "Van Gogh",
-					address: {
-						street: "456 Grand Blvd",
-						city: "Barksville"
-					},
-					age: 30
-				} }
-			},
-			{
-				card: ringo,
-				data: { search_doc: {
-					name: "Ringo",
-					address: {
-						street: "100 Treat Street",
-						city: "Waggington"
-					},
-					age: 25
-				} }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), {
-			filter: {
-				on: type,
-				range: { age: { lte: 35 } }
-			},
-			sort: [{
-				on: type,
-				by: "age",
-				direction: "desc"
-			}]
-		});
-		assert.strictEqual(meta.page.total, 3, "the total results meta is correct");
-		assert.deepEqual(getIds(cards), [
-			mango.id,
-			vangogh.id,
-			ringo.id
-		], "results are correct");
-	});
-	(0, import_qunit.test)(`can combine 'range' filter`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: {
-					name: "Mango",
-					address: {
-						street: "123 Main Street",
-						city: "Barksville"
-					},
-					age: 35
-				} }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: {
-					name: "Van Gogh",
-					address: {
-						street: "456 Grand Blvd",
-						city: "Barksville"
-					},
-					age: 30
-				} }
-			},
-			{
-				card: ringo,
-				data: { search_doc: {
-					name: "Ringo",
-					address: {
-						street: "100 Treat Street",
-						city: "Waggington"
-					},
-					age: 25
-				} }
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), {
-			filter: {
-				on: type,
-				range: { age: {
-					gt: 25,
-					lt: 35
-				} }
-			},
-			sort: [{
-				on: type,
-				by: "age",
-				direction: "desc"
-			}]
-		});
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.deepEqual(getIds(cards), [vangogh.id], "results are correct");
-	});
-	(0, import_qunit.test)(`cannot filter 'null' value using 'range'`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { search_doc: {
-					name: "Mango",
-					address: {
-						street: "123 Main Street",
-						city: "Barksville"
-					},
-					age: 35
-				} }
-			},
-			{
-				card: vangogh,
-				data: { search_doc: {
-					name: "Van Gogh",
-					address: {
-						street: "456 Grand Blvd",
-						city: "Barksville"
-					},
-					age: 30
-				} }
-			},
-			{
-				card: ringo,
-				data: { search_doc: {
-					name: "Ringo",
-					address: {
-						street: "100 Treat Street",
-						city: "Waggington"
-					},
-					age: 25
-				} }
-			}
-		]);
-		let type = await personCardType(testCards);
-		assert.rejects(indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			range: { age: { gt: null } }
-		} }), `'null' is not a permitted value in a 'range' filter`);
-	});
-	(0, import_qunit.test)(`'matches' filter returns rows whose markdown contains the query (case-insensitive)`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { markdown: "Mango is a friendly puppy who loves to play fetch in the park." }
-			},
-			{
-				card: vangogh,
-				data: { markdown: "Van Gogh is a calm dog with a painterly coat." }
-			},
-			{
-				card: ringo,
-				data: { markdown: "Ringo plays the drums and enjoys long naps." }
-			}
-		]);
-		let lower = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: { matches: "mango" } });
-		assert.strictEqual(lower.meta.page.total, 1, "one row matches \"mango\"");
-		assert.deepEqual(getIds(lower.cards), [mango.id]);
-		let upper = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: { matches: "MANGO" } });
-		assert.strictEqual(upper.meta.page.total, 1, "upper-case query still matches");
-		let none = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: { matches: "xylophone" } });
-		assert.strictEqual(none.meta.page.total, 0, "no rows match a missing term");
-	});
-	(0, import_qunit.test)(`'matches' escapes LIKE wildcards so user input matches literally`, async function(assert) {
-		let { mango, vangogh } = testCards;
-		await setupIndex(dbAdapter, [{
-			card: mango,
-			data: { markdown: "Summer sale: 50% off today only." }
-		}, {
-			card: vangogh,
-			data: { markdown: "Fifty kittens lined up on the fence." }
-		}]);
-		let percent = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: { matches: "50%" } });
-		assert.strictEqual(percent.meta.page.total, 1, "\"50%\" matches the literal \"50%\" row only");
-		assert.deepEqual(getIds(percent.cards), [mango.id]);
-		let underscore = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: { matches: "_nothing_" } });
-		assert.strictEqual(underscore.meta.page.total, 0, "underscore is treated literally, not as a single-char wildcard");
-	});
-	(0, import_qunit.test)(`'matches' does not match rows whose markdown is null`, async function(assert) {
-		let { mango, vangogh } = testCards;
-		await setupIndex(dbAdapter, [{
-			card: mango,
-			data: { markdown: "Mango likes fetch." }
-		}, {
-			card: vangogh,
-			data: { markdown: null }
-		}]);
-		let { meta, cards } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: { matches: "mango" } });
-		assert.strictEqual(meta.page.total, 1, "only the non-null row matching \"mango\" is returned");
-		assert.deepEqual(getIds(cards), [mango.id]);
-	});
-	(0, import_qunit.test)(`'matches' empty query matches nothing`, async function(assert) {
-		let { mango, ringo } = testCards;
-		await setupIndex(dbAdapter, [{
-			card: mango,
-			data: { markdown: "Mango likes fetch." }
-		}, {
-			card: ringo,
-			data: { markdown: "Ringo likes drums." }
-		}]);
-		let { meta: emptyMeta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: { matches: "" } });
-		assert.strictEqual(emptyMeta.page.total, 0, "empty query does not match every row");
-		let { meta: wsMeta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: { matches: "   " } });
-		assert.strictEqual(wsMeta.page.total, 0, "whitespace-only query does not match every row");
-	});
-	(0, import_qunit.test)(`'matches' parameterizes the query safely (injection attempt)`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: { markdown: "Mango likes fetch." }
-			},
-			{
-				card: vangogh,
-				data: { markdown: "Van Gogh likes naps." }
-			},
-			{
-				card: ringo,
-				data: { markdown: "Ringo likes drums." }
-			}
-		]);
-		let { meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: { matches: `'; DROP TABLE boxel_index; --` } });
-		assert.strictEqual(meta.page.total, 0, "malicious input is treated as literal LIKE text, not SQL");
-		let sanity = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: { matches: "mango" } });
-		assert.strictEqual(sanity.meta.page.total, 1, "boxel_index table is intact after injection attempt");
-	});
-	(0, import_qunit.test)(`'matches' tolerates unicode and special characters in the query`, async function(assert) {
-		let { mango } = testCards;
-		await setupIndex(dbAdapter, [{
-			card: mango,
-			data: { markdown: "Mango likes fetch." }
-		}]);
-		let { meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: { matches: "café 🦮 \"$1 $2\"" } });
-		assert.strictEqual(meta.page.total, 0, "special characters do not throw; no rows match");
-	});
-	(0, import_qunit.test)(`'matches' composes inside 'every' with eq/contains/range/cardType`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: {
-					search_doc: {
-						name: "Mango",
-						age: 35
-					},
-					markdown: "Mango is the name here."
-				}
-			},
-			{
-				card: vangogh,
-				data: {
-					search_doc: {
-						name: "Van Gogh",
-						age: 30
-					},
-					markdown: "Van Gogh is here."
-				}
-			},
-			{
-				card: ringo,
-				data: {
-					search_doc: {
-						name: "Ringo",
-						age: 25
-					},
-					markdown: "Ringo is here."
-				}
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			every: [
-				{ type },
-				{ matches: "mango" },
-				{ eq: { name: "Mango" } },
-				{ contains: { name: "Mang" } },
-				{ range: { age: { gt: 10 } } }
-			]
-		} });
-		assert.strictEqual(meta.page.total, 1, `every-composition narrows to the one row matching all predicates`);
-		assert.deepEqual(getIds(cards), [mango.id], "correct row returned");
-	});
-	(0, import_qunit.test)(`'matches' composes inside 'any' alongside other filters`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: {
-					search_doc: { name: "Mango" },
-					markdown: "Mango is here."
-				}
-			},
-			{
-				card: vangogh,
-				data: {
-					search_doc: { name: "Van Gogh" },
-					markdown: "Van Gogh is here."
-				}
-			},
-			{
-				card: ringo,
-				data: {
-					search_doc: { name: "Ringo" },
-					markdown: "Ringo is here."
-				}
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			any: [{ matches: "ringo" }, { eq: { name: "Mango" } }]
-		} });
-		assert.strictEqual(meta.page.total, 2, `union of the 'matches' branch and the 'eq' branch`);
-		assert.deepEqual(getIds(cards), [mango.id, ringo.id], "results are correct");
-	});
-	(0, import_qunit.test)(`'matches' composes inside 'not'`, async function(assert) {
-		let { mango, vangogh, ringo } = testCards;
-		await setupIndex(dbAdapter, [
-			{
-				card: mango,
-				data: {
-					search_doc: { name: "Mango" },
-					markdown: "Mango is here."
-				}
-			},
-			{
-				card: vangogh,
-				data: {
-					search_doc: { name: "Van Gogh" },
-					markdown: "Van Gogh is here."
-				}
-			},
-			{
-				card: ringo,
-				data: {
-					search_doc: { name: "Ringo" },
-					markdown: "Ringo is here."
-				}
-			}
-		]);
-		let type = await personCardType(testCards);
-		let { cards, meta } = await indexQueryEngine.searchCards(new URL(testRealmURL), { filter: {
-			on: type,
-			not: { matches: "mango" }
-		} });
-		assert.strictEqual(meta.page.total, 2, `'not' drops the one row that matched 'mango'`);
-		assert.deepEqual(getIds(cards), [ringo.id, vangogh.id], "non-mango person rows returned");
-	});
-	(0, import_qunit.test)("can sort using a general field that is not an attribute of a card", async function(assert) {
-		await setupIndex(dbAdapter, [
-			{
-				url: `${testRealmURL}vangogh.json`,
-				file_alias: `${testRealmURL}vangogh`,
-				type: "instance",
-				realm_version: 1,
-				realm_url: testRealmURL,
-				deps: [],
-				types: [`${testRealmURL}person/Person`, "https://cardstack.com/base/card-api/CardDef"],
-				last_modified: "1",
-				resource_created_at: "1"
-			},
-			{
-				url: `${testRealmURL}jimmy.json`,
-				file_alias: `${testRealmURL}jimmy`,
-				type: "instance",
-				realm_version: 1,
-				realm_url: testRealmURL,
-				deps: [],
-				types: [`${testRealmURL}person/Person`, "https://cardstack.com/base/card-api/CardDef"],
-				last_modified: "3",
-				resource_created_at: "3"
-			},
-			{
-				url: `${testRealmURL}donald.json`,
-				file_alias: `${testRealmURL}donald`,
-				type: "instance",
-				realm_version: 1,
-				realm_url: testRealmURL,
-				deps: [],
-				types: [`${testRealmURL}person/Person`, "https://cardstack.com/base/card-api/CardDef"],
-				last_modified: "2",
-				resource_created_at: "2"
-			}
-		]);
-		let { prerenderedCards: results } = await indexQueryEngine.searchPrerendered(new URL(testRealmURL), { sort: [{
-			by: "lastModified",
-			direction: "desc"
-		}] }, { htmlFormat: "embedded" });
-		assert.deepEqual(results.map((r) => r.url), [
-			`${testRealmURL}jimmy.json`,
-			`${testRealmURL}donald.json`,
-			`${testRealmURL}vangogh.json`
-		], "results are correct");
-		let { prerenderedCards: results2 } = await indexQueryEngine.searchPrerendered(new URL(testRealmURL), { sort: [{
-			by: "lastModified",
-			direction: "asc"
-		}] }, { htmlFormat: "embedded" });
-		assert.deepEqual(results2.map((r) => r.url), [
-			`${testRealmURL}vangogh.json`,
-			`${testRealmURL}donald.json`,
-			`${testRealmURL}jimmy.json`
-		], "results are correct");
-		let { prerenderedCards: results3 } = await indexQueryEngine.searchPrerendered(new URL(testRealmURL), { sort: [{
-			by: "createdAt",
-			direction: "desc"
-		}] }, { htmlFormat: "embedded" });
-		assert.deepEqual(results3.map((r) => r.url), [
-			`${testRealmURL}jimmy.json`,
-			`${testRealmURL}donald.json`,
-			`${testRealmURL}vangogh.json`
-		], "results are correct");
-	});
-	(0, import_qunit.test)("can get prerendered cards from the indexer", async function(assert) {
-		let personCard = await personCardType(testCards);
-		let personKey = internalKeyFor(personCard, void 0, virtualNetwork);
-		let fancyPersonCard = await fancyPersonCardType(testCards);
-		let fancyPersonKey = internalKeyFor(fancyPersonCard, void 0, virtualNetwork);
-		await setupIndex(dbAdapter, [
-			{
-				url: `${testRealmURL}vangogh.json`,
-				file_alias: `${testRealmURL}vangogh`,
-				type: "instance",
-				realm_version: 1,
-				realm_url: testRealmURL,
-				deps: [],
-				types: [personKey, "https://cardstack.com/base/card-api/CardDef"],
-				embedded_html: {
-					[personKey]: "<div>Van Gogh (Person embedded template)</div>",
-					"https://cardstack.com/base/card-api/CardDef": "<div>Van Gogh (CardDef embedded template)</div>"
-				},
-				fitted_html: {
-					[personKey]: "<div>Van Gogh (Person fitted template)</div>",
-					"https://cardstack.com/base/card-api/CardDef": "<div>Van Gogh (CardDef fitted template)</div>"
-				},
-				atom_html: "Van Gogh",
-				search_doc: { name: "Van Gogh" }
-			},
-			{
-				url: `${testRealmURL}jimmy.json`,
-				file_alias: `${testRealmURL}jimmy`,
-				type: "instance",
-				realm_version: 1,
-				realm_url: testRealmURL,
-				deps: [],
-				types: [personKey, "https://cardstack.com/base/card-api/CardDef"],
-				embedded_html: {
-					[personKey]: "<div>Jimmy (Person embedded template)</div>",
-					"https://cardstack.com/base/card-api/CardDef": "<div>Jimmy (CardDef embedded template)</div>"
-				},
-				fitted_html: {
-					[personKey]: "<div>Jimmy (Person fitted template)</div>",
-					"https://cardstack.com/base/card-api/CardDef": "<div>Jimmy (CardDef fitted template)</div>"
-				},
-				atom_html: "Jimmy",
-				head_html: "<title>Jimmy</title>",
-				search_doc: { name: "Jimmy" }
-			},
-			{
-				url: `${testRealmURL}donald.json`,
-				file_alias: `${testRealmURL}donald`,
-				type: "instance",
-				realm_version: 1,
-				realm_url: testRealmURL,
-				deps: [],
-				types: [
-					fancyPersonKey,
-					personKey,
-					"https://cardstack.com/base/card-api/CardDef"
-				],
-				embedded_html: {
-					[fancyPersonKey]: "<div>Donald (FancyPerson embedded template)</div>",
-					[personKey]: "<div>Donald (Person embedded template)</div>",
-					"https://cardstack.com/base/card-api/CardDef": "<div>Donald (CardDef embedded template)</div>"
-				},
-				fitted_html: {
-					[fancyPersonKey]: "<div>Donald (FancyPerson fitted template)</div>",
-					[personKey]: "<div>Donald (Person fitted template)</div>",
-					"https://cardstack.com/base/card-api/CardDef": "<div>Donald (CardDef fitted template)</div>"
-				},
-				atom_html: "Donald",
-				search_doc: { name: "Donald" }
-			}
-		]);
-		let { prerenderedCards, meta } = await indexQueryEngine.searchPrerendered(new URL(testRealmURL), {}, { htmlFormat: "embedded" });
-		assert.strictEqual(meta.page.total, 3, "meta total results meta is correct");
-		assert.strictEqual(prerenderedCards.length, 3, "the actual returned total results are correct");
-		assert.strictEqual(prerenderedCards[0].url, "http://test-realm/test/donald.json");
-		assert.strictEqual(prerenderedCards[0].html, "<div>Donald (FancyPerson embedded template)</div>");
-		assert.deepEqual(prerenderedCards[0].usedRenderType, fancyPersonCard);
-		assert.strictEqual(prerenderedCards[1].url, "http://test-realm/test/jimmy.json");
-		assert.strictEqual(prerenderedCards[1].html, "<div>Jimmy (Person embedded template)</div>");
-		assert.deepEqual(prerenderedCards[1].usedRenderType, personCard);
-		assert.strictEqual(prerenderedCards[2].url, "http://test-realm/test/vangogh.json");
-		assert.strictEqual(prerenderedCards[2].html, "<div>Van Gogh (Person embedded template)</div>");
-		assert.deepEqual(prerenderedCards[2].usedRenderType, personCard);
-		({prerenderedCards, meta} = await indexQueryEngine.searchPrerendered(new URL(testRealmURL), { filter: {
-			on: fancyPersonCard,
-			not: { eq: { name: "Richard" } }
-		} }, { htmlFormat: "embedded" }));
-		assert.strictEqual(prerenderedCards.length, 1, "the actual returned total results are correct (there is only one FancyPerson)");
-		assert.strictEqual(prerenderedCards[0].url, "http://test-realm/test/donald.json");
-		assert.strictEqual(prerenderedCards[0].html, "<div>Donald (FancyPerson embedded template)</div>");
-		assert.deepEqual(prerenderedCards[0].usedRenderType, fancyPersonCard);
-		({prerenderedCards, meta} = await indexQueryEngine.searchPrerendered(new URL(testRealmURL), { filter: {
-			on: fancyPersonCard,
-			eq: { name: "Donald" }
-		} }, { htmlFormat: "atom" }));
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.strictEqual(prerenderedCards[0].url, `${testRealmURL}donald.json`);
-		assert.strictEqual(prerenderedCards[0].html, "Donald");
-		assert.deepEqual(prerenderedCards[0].usedRenderType, fancyPersonCard);
-		({prerenderedCards, meta} = await indexQueryEngine.searchPrerendered(new URL(testRealmURL), { filter: {
-			on: personCard,
-			eq: { name: "Jimmy" }
-		} }, { htmlFormat: "head" }));
-		assert.strictEqual(meta.page.total, 1, "the total results meta is correct");
-		assert.strictEqual(prerenderedCards[0].url, `${testRealmURL}jimmy.json`);
-		assert.strictEqual(prerenderedCards[0].html, "<title>Jimmy</title>");
-		assert.deepEqual(prerenderedCards[0].usedRenderType, personCard);
-		({prerenderedCards, meta} = await indexQueryEngine.searchPrerendered(new URL(testRealmURL), { filter: {
-			on: fancyPersonCard,
-			not: { eq: { name: "Richard" } }
-		} }, {
-			htmlFormat: "embedded",
-			renderType: personCard
-		}));
-		assert.strictEqual(prerenderedCards.length, 1, "the actual returned total results are correct (there is only one FancyPerson)");
-		assert.strictEqual(prerenderedCards[0].url, "http://test-realm/test/donald.json");
-		assert.strictEqual(prerenderedCards[0].html, "<div>Donald (Person embedded template)</div>");
-		assert.deepEqual(prerenderedCards[0].usedRenderType, personCard);
-	});
-	(0, import_qunit.test)("can get prerendered cards in an error state from the indexer", async function(assert) {
-		let personKey = internalKeyFor(await personCardType(testCards), void 0, virtualNetwork);
-		let fancyPersonCard = await fancyPersonCardType(testCards);
-		let fancyPersonKey = internalKeyFor(fancyPersonCard, void 0, virtualNetwork);
-		await setupIndex(dbAdapter, [
-			{
-				url: `${testRealmURL}vangogh.json`,
-				file_alias: `${testRealmURL}vangogh`,
-				type: "instance",
-				realm_version: 1,
-				realm_url: testRealmURL,
-				deps: [],
-				types: [personKey, "https://cardstack.com/base/card-api/CardDef"],
-				embedded_html: {
-					[personKey]: "<div>Van Gogh (Person embedded template)</div>",
-					"https://cardstack.com/base/card-api/CardDef": "<div>Van Gogh (CardDef embedded template)</div>"
-				},
-				fitted_html: {
-					[personKey]: "<div>Van Gogh (Person fitted template)</div>",
-					"https://cardstack.com/base/card-api/CardDef": "<div>Van Gogh (CardDef fitted template)</div>"
-				},
-				atom_html: "Van Gogh",
-				search_doc: { name: "Van Gogh" }
-			},
-			{
-				url: `${testRealmURL}jimmy.json`,
-				file_alias: `${testRealmURL}jimmy`,
-				type: "instance",
-				realm_version: 1,
-				realm_url: testRealmURL,
-				deps: [],
-				types: [
-					fancyPersonKey,
-					personKey,
-					"https://cardstack.com/base/card-api/CardDef"
-				],
-				embedded_html: {
-					[fancyPersonKey]: "<div>Jimmy (FancyPerson embedded template)</div>",
-					[personKey]: "<div>Jimmy (Person embedded template)</div>",
-					"https://cardstack.com/base/card-api/CardDef": "<div>Jimmy (CardDef embedded template)</div>"
-				},
-				fitted_html: {
-					[fancyPersonKey]: "<div>Jimmy (FancyPerson fitted template)</div>",
-					[personKey]: "<div>Jimmy (Person fitted template)</div>",
-					"https://cardstack.com/base/card-api/CardDef": "<div>Jimmy (CardDef fitted template)</div>"
-				},
-				atom_html: "Jimmy",
-				search_doc: { name: "Jimmy" }
-			},
-			{
-				url: `${testRealmURL}donald.json`,
-				file_alias: `${testRealmURL}donald`,
-				type: "instance",
-				has_error: true,
-				realm_version: 1,
-				realm_url: testRealmURL,
-				deps: [],
-				types: [
-					fancyPersonKey,
-					personKey,
-					"https://cardstack.com/base/card-api/CardDef"
-				],
-				embedded_html: {
-					[fancyPersonKey]: "<div>Donald (FancyPerson embedded template)</div>",
-					[personKey]: "<div>Donald (Person embedded template)</div>",
-					"https://cardstack.com/base/card-api/CardDef": "<div>Donald (CardDef embedded template)</div>"
-				},
-				fitted_html: {
-					[fancyPersonKey]: "<div>Donald (FancyPerson fitted template)</div>",
-					[personKey]: "<div>Donald (Person fitted template)</div>",
-					"https://cardstack.com/base/card-api/CardDef": "<div>Donald (CardDef fitted template)</div>"
-				},
-				atom_html: "Donald",
-				search_doc: { name: "Donald" }
-			},
-			{
-				url: `${testRealmURL}paper.json`,
-				file_alias: `${testRealmURL}paper`,
-				type: "instance",
-				has_error: true,
-				realm_version: 1,
-				realm_url: testRealmURL,
-				deps: [],
-				types: null,
-				embedded_html: {
-					[fancyPersonKey]: "<div>Paper (FancyPerson embedded template)</div>",
-					[personKey]: "<div>Paper (Person embedded template)</div>",
-					"https://cardstack.com/base/card-api/CardDef": "<div>Paper (CardDef embedded template)</div>"
-				},
-				fitted_html: {
-					[fancyPersonKey]: "<div>Paper (FancyPerson fitted template)</div>",
-					[personKey]: "<div>Paper (Person fitted template)</div>",
-					"https://cardstack.com/base/card-api/CardDef": "<div>Paper (CardDef fitted template)</div>"
-				},
-				atom_html: "Paper",
-				search_doc: { name: "Paper" }
-			}
-		]);
-		let { prerenderedCards } = await indexQueryEngine.searchPrerendered(new URL(testRealmURL), { filter: {
-			on: fancyPersonCard,
-			not: { eq: { name: "Richard" } }
-		} }, {
-			htmlFormat: "embedded",
-			includeErrors: true
-		});
-		assert.strictEqual(prerenderedCards.length, 2, "the actual returned total results are correct");
-		assert.strictEqual(prerenderedCards[0].url, "http://test-realm/test/donald.json");
-		assert.strictEqual(prerenderedCards[0].html, "<div>Donald (FancyPerson embedded template)</div>");
-		assert.true(prerenderedCards[0].isError, "card is in error state");
-		assert.strictEqual(prerenderedCards[1].url, "http://test-realm/test/jimmy.json");
-		assert.strictEqual(prerenderedCards[1].html, "<div>Jimmy (FancyPerson embedded template)</div>");
-		assert.notOk(prerenderedCards[1].isError, "card is not in an error state");
-	});
-});
-function getIds(resources) {
-	return resources.map((r) => r.id);
-}
-function internalKeyToCodeRef(key) {
-	let parts = key.split("/");
-	let name = parts.pop();
-	return {
-		module: parts.join("/"),
-		name
-	};
-}
-async function personCardType(testCards) {
-	let { vangogh } = testCards;
-	if (!vangogh) throw new Error(`missing the 'vangogh' test card in the--this is the card we use to derive the Person type`);
-	return internalKeyToCodeRef([...await getTypes(vangogh)].shift());
-}
-async function fancyPersonCardType(testCards) {
-	let { mango } = testCards;
-	if (!mango) throw new Error(`missing the 'mango' test card in the--this is the card we use to derive the FancyPerson type`);
-	return internalKeyToCodeRef([...await getTypes(mango)].shift());
-}
-async function SimpleSpecType(testCards) {
-	let { stringFieldEntry } = testCards;
-	if (!stringFieldEntry) throw new Error(`missing the 'stringFieldEntry' test card in the--this is the card we use to derive the SimpleSpec type`);
-	return internalKeyToCodeRef([...await getTypes(stringFieldEntry)].shift());
-}
-async function eventType(testCards) {
-	let { mangoBirthday } = testCards;
-	if (!mangoBirthday) throw new Error(`missing the 'mangoBirthday' test card in the--this is the card we use to derive the Event type`);
-	return internalKeyToCodeRef([...await getTypes(mangoBirthday)].shift());
-}
-//#endregion