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

package/bundled-test-harness/assets/searchable-search-doc-test-DrNLCF73.js

@@ -0,0 +1,1271 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Ar as testRealmURL } from "./runtime-common-ClpqhbwG.js";
+import { y as rri } from "./paths-BYHDgqsT.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as CardStoreWithGarbageCollection } from "./gc-card-store-eg5fHk_x.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, L as setupRealmCacheTeardown, M as setupCardLogs, P as setupIntegrationTestRealm, Z as withCachedRealmSetup, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-DPQ0j2MD.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { s as getDataBucket } from "./field-support-DdQ7XgyM.js";
+import { A as field, D as createFromSerialized, H as linksTo, T as containsMany, U as linksToMany, a as CardDef, l as FieldDef, s as Component, w as contains } from "./card-api-Dzje0smT.js";
+import { t as string_default } from "./string-BHZZwNlZ.js";
+import { t as NumberField } from "./number-DZa-fHpu.js";
+import { t as searchDocFromFields } from "./searchable-BXw4T11q.js";
+//#region tests/integration/searchable-search-doc-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var loader;
+var realm;
+(0, import_qunit.module)("Integration | searchable search doc", function(hooks) {
+	setupRenderingTest(hooks);
+	hooks.beforeEach(function() {
+		loader = getService("loader-service").loader;
+	});
+	setupLocalIndexing(hooks);
+	setupRealmCacheTeardown(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks);
+	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/card-api"));
+	hooks.beforeEach(async function() {
+		class Agent extends CardDef {
+			static displayName = "Agent";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		class Headquarters extends CardDef {
+			static displayName = "Headquarters";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		class Company extends CardDef {
+			static displayName = "Company";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "ceo", [field], function() {
+					return linksTo(Agent, { searchable: true });
+				});
+			}
+			#ceo = (initializeDeferredDecorator(this, "ceo"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "hq", [field], function() {
+					return linksTo(Headquarters, { searchable: true });
+				});
+			}
+			#hq = (initializeDeferredDecorator(this, "hq"), void 0);
+		}
+		class Author extends CardDef {
+			static displayName = "Author";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "agent", [field], function() {
+					return linksTo(Agent, { searchable: true });
+				});
+			}
+			#agent = (initializeDeferredDecorator(this, "agent"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "company", [field], function() {
+					return linksTo(Company);
+				});
+			}
+			#company = (initializeDeferredDecorator(this, "company"), void 0);
+		}
+		class ArticleSelf extends CardDef {
+			static displayName = "ArticleSelf";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "author", [field], function() {
+					return linksTo(Author, { searchable: true });
+				});
+			}
+			#author = (initializeDeferredDecorator(this, "author"), void 0);
+		}
+		class ArticleDeep extends CardDef {
+			static displayName = "ArticleDeep";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "author", [field], function() {
+					return linksTo(Author, { searchable: "agent" });
+				});
+			}
+			#author = (initializeDeferredDecorator(this, "author"), void 0);
+		}
+		class ArticleShallow extends CardDef {
+			static displayName = "ArticleShallow";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "author", [field], function() {
+					return linksTo(Author);
+				});
+			}
+			#author = (initializeDeferredDecorator(this, "author"), void 0);
+		}
+		class ArticleHop2 extends CardDef {
+			static displayName = "ArticleHop2";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "author", [field], function() {
+					return linksTo(Author, { searchable: "company" });
+				});
+			}
+			#author = (initializeDeferredDecorator(this, "author"), void 0);
+		}
+		class ArticleHop3 extends CardDef {
+			static displayName = "ArticleHop3";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "author", [field], function() {
+					return linksTo(Author, { searchable: "company.hq" });
+				});
+			}
+			#author = (initializeDeferredDecorator(this, "author"), void 0);
+		}
+		class ArticleShared extends CardDef {
+			static displayName = "ArticleShared";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "author", [field], function() {
+					return linksTo(Author, { searchable: ["company.ceo", "company.hq"] });
+				});
+			}
+			#author = (initializeDeferredDecorator(this, "author"), void 0);
+		}
+		class ArticleMulti extends CardDef {
+			static displayName = "ArticleMulti";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "author", [field], function() {
+					return linksTo(Author, { searchable: ["agent", "company.hq"] });
+				});
+			}
+			#author = (initializeDeferredDecorator(this, "author"), void 0);
+		}
+		class ArticleEmptyPath extends CardDef {
+			static displayName = "ArticleEmptyPath";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "author", [field], function() {
+					return linksTo(Author, { searchable: "" });
+				});
+			}
+			#author = (initializeDeferredDecorator(this, "author"), void 0);
+		}
+		class ArticleEmptyArray extends CardDef {
+			static displayName = "ArticleEmptyArray";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "author", [field], function() {
+					return linksTo(Author, { searchable: [] });
+				});
+			}
+			#author = (initializeDeferredDecorator(this, "author"), void 0);
+		}
+		class ArticleNullSearchable extends CardDef {
+			static displayName = "ArticleNullSearchable";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "author", [field], function() {
+					return linksTo(Author, { searchable: null });
+				});
+			}
+			#author = (initializeDeferredDecorator(this, "author"), void 0);
+		}
+		class ArticleArrayWithNull extends CardDef {
+			static displayName = "ArticleArrayWithNull";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "author", [field], function() {
+					return linksTo(Author, { searchable: ["agent", null] });
+				});
+			}
+			#author = (initializeDeferredDecorator(this, "author"), void 0);
+		}
+		class ArticleImpossiblePath extends CardDef {
+			static displayName = "ArticleImpossiblePath";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "author", [field], function() {
+					return linksTo(Author, { searchable: "agent.deeper" });
+				});
+			}
+			#author = (initializeDeferredDecorator(this, "author"), void 0);
+		}
+		class ArticleFalse extends CardDef {
+			static displayName = "ArticleFalse";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "author", [field], function() {
+					return linksTo(Author, { searchable: false });
+				});
+			}
+			#author = (initializeDeferredDecorator(this, "author"), void 0);
+		}
+		class Person extends CardDef {
+			static displayName = "Person";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "friend", [field], function() {
+					return linksTo(() => Person, { searchable: true });
+				});
+			}
+			#friend = (initializeDeferredDecorator(this, "friend"), void 0);
+		}
+		class Ring extends CardDef {
+			static displayName = "Ring";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "next", [field], function() {
+					return linksTo(() => Ring, { searchable: "next.next" });
+				});
+			}
+			#next = (initializeDeferredDecorator(this, "next"), void 0);
+		}
+		class RingM extends CardDef {
+			static displayName = "RingM";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "nexts", [field], function() {
+					return linksToMany(() => RingM, { searchable: "nexts.nexts" });
+				});
+			}
+			#nexts = (initializeDeferredDecorator(this, "nexts"), void 0);
+		}
+		class Crew extends FieldDef {
+			static displayName = "Crew";
+			static {
+				decorateFieldV2(this.prototype, "label", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#label = (initializeDeferredDecorator(this, "label"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "lead", [field], function() {
+					return linksTo(Agent);
+				});
+			}
+			#lead = (initializeDeferredDecorator(this, "lead"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "roster", [field], function() {
+					return linksToMany(Agent);
+				});
+			}
+			#roster = (initializeDeferredDecorator(this, "roster"), void 0);
+		}
+		class ArticleContainsLead extends CardDef {
+			static displayName = "ArticleContainsLead";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "crew", [field], function() {
+					return contains(Crew, { searchable: "lead" });
+				});
+			}
+			#crew = (initializeDeferredDecorator(this, "crew"), void 0);
+		}
+		class ArticleContainsRoster extends CardDef {
+			static displayName = "ArticleContainsRoster";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "crew", [field], function() {
+					return contains(Crew, { searchable: "roster" });
+				});
+			}
+			#crew = (initializeDeferredDecorator(this, "crew"), void 0);
+		}
+		class ArticleManyLead extends CardDef {
+			static displayName = "ArticleManyLead";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "crews", [field], function() {
+					return containsMany(Crew, { searchable: "lead" });
+				});
+			}
+			#crews = (initializeDeferredDecorator(this, "crews"), void 0);
+		}
+		class ArticleManyRoster extends CardDef {
+			static displayName = "ArticleManyRoster";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "crews", [field], function() {
+					return containsMany(Crew, { searchable: "roster" });
+				});
+			}
+			#crews = (initializeDeferredDecorator(this, "crews"), void 0);
+		}
+		class ArticleLabels extends CardDef {
+			static displayName = "ArticleLabels";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "labels", [field], function() {
+					return containsMany(string_default);
+				});
+			}
+			#labels = (initializeDeferredDecorator(this, "labels"), void 0);
+		}
+		class Team extends CardDef {
+			static displayName = "Team";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "members", [field], function() {
+					return linksToMany(Author, { searchable: true });
+				});
+			}
+			#members = (initializeDeferredDecorator(this, "members"), void 0);
+		}
+		class TeamShallow extends CardDef {
+			static displayName = "TeamShallow";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "members", [field], function() {
+					return linksToMany(Agent);
+				});
+			}
+			#members = (initializeDeferredDecorator(this, "members"), void 0);
+		}
+		class TeamDeep extends CardDef {
+			static displayName = "TeamDeep";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "members", [field], function() {
+					return linksToMany(Author, { searchable: "agent" });
+				});
+			}
+			#members = (initializeDeferredDecorator(this, "members"), void 0);
+		}
+		class SimpleAuthor extends CardDef {
+			static displayName = "SimpleAuthor";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		class FancyAuthor extends SimpleAuthor {
+			static displayName = "FancyAuthor";
+			static {
+				decorateFieldV2(this.prototype, "penName", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#penName = (initializeDeferredDecorator(this, "penName"), void 0);
+		}
+		class ParityArticle extends CardDef {
+			static displayName = "ParityArticle";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "authors", [field], function() {
+					return linksToMany(SimpleAuthor, { searchable: true });
+				});
+			}
+			#authors = (initializeDeferredDecorator(this, "authors"), void 0);
+			static isolated = class extends Component {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "FhoKbSYp",
+						"block": "[[[8,[30,1,[\"authors\"]],null,null,null]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/searchable-search-doc-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class ArticleSubtype extends CardDef {
+			static displayName = "ArticleSubtype";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "author", [field], function() {
+					return linksTo(SimpleAuthor, { searchable: true });
+				});
+			}
+			#author = (initializeDeferredDecorator(this, "author"), void 0);
+		}
+		class TeamSubtype extends CardDef {
+			static displayName = "TeamSubtype";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "members", [field], function() {
+					return linksToMany(SimpleAuthor, { searchable: true });
+				});
+			}
+			#members = (initializeDeferredDecorator(this, "members"), void 0);
+		}
+		class Profile extends FieldDef {
+			static displayName = "Profile";
+			static {
+				decorateFieldV2(this.prototype, "bio", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#bio = (initializeDeferredDecorator(this, "bio"), void 0);
+		}
+		class FancyProfile extends Profile {
+			static displayName = "FancyProfile";
+			static {
+				decorateFieldV2(this.prototype, "tagline", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#tagline = (initializeDeferredDecorator(this, "tagline"), void 0);
+		}
+		class ArticleProfile extends CardDef {
+			static displayName = "ArticleProfile";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "profile", [field], function() {
+					return contains(Profile);
+				});
+			}
+			#profile = (initializeDeferredDecorator(this, "profile"), void 0);
+		}
+		class ArticleQuery extends CardDef {
+			static displayName = "ArticleQuery";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "related", [field], function() {
+					return linksToMany(() => Agent, {
+						searchable: true,
+						query: { filter: { eq: { name: "Agent Smith" } } }
+					});
+				});
+			}
+			#related = (initializeDeferredDecorator(this, "related"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "relatedCount", [field], function() {
+					return contains(NumberField, { computeVia: function() {
+						return this.related.length;
+					} });
+				});
+			}
+			#relatedCount = (initializeDeferredDecorator(this, "relatedCount"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "relatedSummary", [field], function() {
+					return contains(string_default, { computeVia: function() {
+						return `${this.relatedCount} related`;
+					} });
+				});
+			}
+			#relatedSummary = (initializeDeferredDecorator(this, "relatedSummary"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "shoutedTitle", [field], function() {
+					return contains(string_default, { computeVia: function() {
+						return this.title.toUpperCase();
+					} });
+				});
+			}
+			#shoutedTitle = (initializeDeferredDecorator(this, "shoutedTitle"), void 0);
+		}
+		class Boom extends CardDef {
+			static displayName = "Boom";
+			static {
+				decorateFieldV2(this.prototype, "other", [field], function() {
+					return linksTo(Author);
+				});
+			}
+			#other = (initializeDeferredDecorator(this, "other"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "boom", [field], function() {
+					return contains(string_default, { computeVia: function() {
+						return this.other.name;
+					} });
+				});
+			}
+			#boom = (initializeDeferredDecorator(this, "boom"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "agent", [field], function() {
+					return linksTo(Agent, { searchable: true });
+				});
+			}
+			#agent = (initializeDeferredDecorator(this, "agent"), void 0);
+		}
+		let agentRef = (id) => ({ links: { self: id } });
+		await withCachedRealmSetup(async () => {
+			({realm} = await setupIntegrationTestRealm({
+				mockMatrixUtils,
+				contents: {
+					"agent.gts": { Agent },
+					"headquarters.gts": { Headquarters },
+					"company.gts": { Company },
+					"author.gts": { Author },
+					"article.gts": {
+						ArticleSelf,
+						ArticleDeep,
+						ArticleShallow,
+						ArticleHop2,
+						ArticleHop3,
+						ArticleShared,
+						ArticleMulti,
+						ArticleEmptyPath,
+						ArticleEmptyArray,
+						ArticleNullSearchable,
+						ArticleArrayWithNull,
+						ArticleImpossiblePath,
+						ArticleFalse
+					},
+					"person.gts": { Person },
+					"ring.gts": { Ring },
+					"ring-m.gts": { RingM },
+					"crew.gts": {
+						Crew,
+						ArticleContainsLead,
+						ArticleContainsRoster,
+						ArticleManyLead,
+						ArticleManyRoster,
+						ArticleLabels
+					},
+					"team.gts": {
+						Team,
+						TeamShallow,
+						TeamDeep,
+						TeamSubtype
+					},
+					"parity.gts": {
+						SimpleAuthor,
+						FancyAuthor,
+						ParityArticle,
+						ArticleSubtype
+					},
+					"profile.gts": {
+						Profile,
+						FancyProfile,
+						ArticleProfile
+					},
+					"article-query.gts": { ArticleQuery },
+					"boom.gts": { Boom },
+					"Agent/a1.json": card("Agent Smith", "agent", "Agent"),
+					"Agent/a2.json": card("Agent Jones", "agent", "Agent"),
+					"Agent/a3.json": card("Agent Braun", "agent", "Agent"),
+					"Headquarters/h1.json": card("HQ One", "headquarters", "Headquarters"),
+					"Company/co1.json": { data: {
+						type: "card",
+						id: `${testRealmURL}Company/co1`,
+						attributes: { name: "Acme" },
+						relationships: {
+							ceo: agentRef(`${testRealmURL}Agent/a1`),
+							hq: agentRef(`${testRealmURL}Headquarters/h1`)
+						},
+						meta: adoptsFrom("company", "Company")
+					} },
+					"Author/au1.json": { data: {
+						type: "card",
+						id: `${testRealmURL}Author/au1`,
+						attributes: { name: "Jo" },
+						relationships: {
+							agent: agentRef(`${testRealmURL}Agent/a1`),
+							company: agentRef(`${testRealmURL}Company/co1`)
+						},
+						meta: adoptsFrom("author", "Author")
+					} },
+					"Author/au2.json": { data: {
+						type: "card",
+						id: `${testRealmURL}Author/au2`,
+						attributes: { name: "Mit" },
+						relationships: { agent: agentRef(`${testRealmURL}Agent/a2`) },
+						meta: adoptsFrom("author", "Author")
+					} },
+					"ArticleSelf/s1.json": article("Self", "ArticleSelf", { author: agentRef(`${testRealmURL}Author/au1`) }),
+					"ArticleSelf/rel.json": article("Relative", "ArticleSelf", { author: agentRef("../Author/au1") }),
+					"ArticleSelf/broken.json": article("Broken", "ArticleSelf", { author: agentRef(`${testRealmURL}Author/ghost`) }),
+					"ArticleSelf/nulllink.json": article("Null", "ArticleSelf", { author: { links: { self: null } } }),
+					"ArticleDeep/d1.json": article("Deep", "ArticleDeep", { author: agentRef(`${testRealmURL}Author/au1`) }),
+					"ArticleShallow/sh1.json": article("Shallow", "ArticleShallow", { author: agentRef(`${testRealmURL}Author/au1`) }),
+					"ArticleHop2/h2.json": article("Hop2", "ArticleHop2", { author: agentRef(`${testRealmURL}Author/au1`) }),
+					"ArticleHop3/h3.json": article("Hop3", "ArticleHop3", { author: agentRef(`${testRealmURL}Author/au1`) }),
+					"ArticleShared/shr1.json": article("Shared", "ArticleShared", { author: agentRef(`${testRealmURL}Author/au1`) }),
+					"ArticleMulti/m1.json": article("Multi", "ArticleMulti", { author: agentRef(`${testRealmURL}Author/au1`) }),
+					"ArticleEmptyPath/ep1.json": article("Empty", "ArticleEmptyPath", { author: agentRef(`${testRealmURL}Author/au1`) }),
+					"ArticleEmptyArray/ea1.json": article("EArr", "ArticleEmptyArray", { author: agentRef(`${testRealmURL}Author/au1`) }),
+					"ArticleNullSearchable/ns1.json": article("Nul", "ArticleNullSearchable", { author: agentRef(`${testRealmURL}Author/au1`) }),
+					"ArticleArrayWithNull/awn1.json": article("AwN", "ArticleArrayWithNull", { author: agentRef(`${testRealmURL}Author/au1`) }),
+					"ArticleImpossiblePath/ip1.json": article("Imp", "ArticleImpossiblePath", { author: agentRef(`${testRealmURL}Author/au1`) }),
+					"ArticleFalse/f1.json": article("Fls", "ArticleFalse", { author: agentRef(`${testRealmURL}Author/au1`) }),
+					"Person/p1.json": { data: {
+						type: "card",
+						id: `${testRealmURL}Person/p1`,
+						attributes: { name: "Solo" },
+						relationships: { friend: agentRef(`${testRealmURL}Person/p1`) },
+						meta: adoptsFrom("person", "Person")
+					} },
+					"Ring/r1.json": ring("R1", `${testRealmURL}Ring/r2`),
+					"Ring/r2.json": ring("R2", `${testRealmURL}Ring/r3`),
+					"Ring/r3.json": ring("R3", `${testRealmURL}Ring/r1`),
+					"RingM/rm1.json": ringM("R1m", `${testRealmURL}RingM/rm2`),
+					"RingM/rm2.json": ringM("R2m", `${testRealmURL}RingM/rm3`),
+					"RingM/rm3.json": ringM("R3m", `${testRealmURL}RingM/rm1`),
+					"ArticleContainsLead/cl1.json": { data: {
+						type: "card",
+						attributes: {
+							title: "CL",
+							crew: { label: "Alpha" }
+						},
+						relationships: {
+							"crew.lead": agentRef(`${testRealmURL}Agent/a1`),
+							"crew.roster.0": agentRef(`${testRealmURL}Agent/a1`),
+							"crew.roster.1": agentRef(`${testRealmURL}Agent/a2`)
+						},
+						meta: adoptsFrom("crew", "ArticleContainsLead")
+					} },
+					"ArticleContainsRoster/cr1.json": { data: {
+						type: "card",
+						attributes: {
+							title: "CR",
+							crew: { label: "Alpha" }
+						},
+						relationships: {
+							"crew.lead": agentRef(`${testRealmURL}Agent/a1`),
+							"crew.roster.0": agentRef(`${testRealmURL}Agent/a1`),
+							"crew.roster.1": agentRef(`${testRealmURL}Agent/a2`)
+						},
+						meta: adoptsFrom("crew", "ArticleContainsRoster")
+					} },
+					"ArticleManyLead/ml1.json": { data: {
+						type: "card",
+						attributes: {
+							title: "ML",
+							crews: [{ label: "C0" }, { label: "C1" }]
+						},
+						relationships: {
+							"crews.0.lead": agentRef(`${testRealmURL}Agent/a1`),
+							"crews.0.roster.0": agentRef(`${testRealmURL}Agent/a1`),
+							"crews.1.lead": agentRef(`${testRealmURL}Agent/a2`),
+							"crews.1.roster.0": agentRef(`${testRealmURL}Agent/a2`)
+						},
+						meta: adoptsFrom("crew", "ArticleManyLead")
+					} },
+					"ArticleManyRoster/mr1.json": { data: {
+						type: "card",
+						attributes: {
+							title: "MR",
+							crews: [{ label: "C0" }, { label: "C1" }]
+						},
+						relationships: {
+							"crews.0.lead": agentRef(`${testRealmURL}Agent/a1`),
+							"crews.0.roster.0": agentRef(`${testRealmURL}Agent/a1`),
+							"crews.1.lead": agentRef(`${testRealmURL}Agent/a2`),
+							"crews.1.roster.0": agentRef(`${testRealmURL}Agent/a2`)
+						},
+						meta: adoptsFrom("crew", "ArticleManyRoster")
+					} },
+					"ArticleLabels/l1.json": { data: {
+						type: "card",
+						id: `${testRealmURL}ArticleLabels/l1`,
+						attributes: {
+							title: "Labels",
+							labels: ["red", "blue"]
+						},
+						meta: adoptsFrom("crew", "ArticleLabels")
+					} },
+					"ArticleLabels/empty1.json": { data: {
+						type: "card",
+						id: `${testRealmURL}ArticleLabels/empty1`,
+						attributes: {
+							title: "Empty",
+							labels: []
+						},
+						meta: adoptsFrom("crew", "ArticleLabels")
+					} },
+					"Team/valid.json": team("Valid", "Team", [`${testRealmURL}Author/au1`, `${testRealmURL}Author/au2`]),
+					"Team/missone.json": team("MissOne", "Team", [`${testRealmURL}Author/au1`, `${testRealmURL}Author/ghost1`]),
+					"Team/missall.json": team("MissAll", "Team", [`${testRealmURL}Author/ghost1`, `${testRealmURL}Author/ghost2`]),
+					"Team/empty.json": team("EmptyTeam", "Team", []),
+					"TeamShallow/ts1.json": team("Shallow", "TeamShallow", [`${testRealmURL}Agent/a1`]),
+					"TeamDeep/td1.json": team("Deep", "TeamDeep", [`${testRealmURL}Author/au1`]),
+					"SimpleAuthor/sa1.json": card("Plain", "parity", "SimpleAuthor"),
+					"FancyAuthor/fa1.json": { data: {
+						type: "card",
+						id: `${testRealmURL}FancyAuthor/fa1`,
+						attributes: {
+							name: "Fancy",
+							penName: "Quill"
+						},
+						meta: adoptsFrom("parity", "FancyAuthor")
+					} },
+					"ParityArticle/pa1.json": { data: {
+						type: "card",
+						id: `${testRealmURL}ParityArticle/pa1`,
+						attributes: { title: "Parity" },
+						relationships: { "authors.0": agentRef(`${testRealmURL}SimpleAuthor/sa1`) },
+						meta: adoptsFrom("parity", "ParityArticle")
+					} },
+					"ArticleSubtype/sub1.json": { data: {
+						type: "card",
+						attributes: { title: "Subtype" },
+						relationships: { author: agentRef(`${testRealmURL}FancyAuthor/fa1`) },
+						meta: adoptsFrom("parity", "ArticleSubtype")
+					} },
+					"TeamSubtype/tsub1.json": team("SubtypeTeam", "TeamSubtype", [`${testRealmURL}FancyAuthor/fa1`]),
+					"ArticleProfile/prof1.json": { data: {
+						type: "card",
+						id: `${testRealmURL}ArticleProfile/prof1`,
+						attributes: {
+							title: "Profile",
+							profile: {
+								bio: "a bio",
+								tagline: "a tagline"
+							}
+						},
+						meta: {
+							adoptsFrom: {
+								module: `${testRealmURL}profile`,
+								name: "ArticleProfile"
+							},
+							fields: { profile: { adoptsFrom: {
+								module: `${testRealmURL}profile`,
+								name: "FancyProfile"
+							} } }
+						}
+					} },
+					"ArticleQuery/q1.json": { data: {
+						type: "card",
+						id: `${testRealmURL}ArticleQuery/q1`,
+						attributes: { title: "Query" },
+						meta: adoptsFrom("article-query", "ArticleQuery")
+					} },
+					"Boom/b1.json": { data: {
+						type: "card",
+						id: `${testRealmURL}Boom/b1`,
+						attributes: {},
+						relationships: {
+							other: agentRef(`${testRealmURL}Author/au1`),
+							agent: agentRef(`${testRealmURL}Agent/a3`)
+						},
+						meta: adoptsFrom("boom", "Boom")
+					} }
+				}
+			}));
+		});
+	});
+	function adoptsFrom(mod, name) {
+		return { adoptsFrom: {
+			module: `${testRealmURL}${mod}`,
+			name
+		} };
+	}
+	function card(name, mod, klass) {
+		return { data: {
+			type: "card",
+			attributes: { name },
+			meta: adoptsFrom(mod, klass)
+		} };
+	}
+	function article(title, klass, relationships) {
+		return { data: {
+			type: "card",
+			attributes: { title },
+			relationships,
+			meta: adoptsFrom("article", klass)
+		} };
+	}
+	function ring(name, next) {
+		return { data: {
+			type: "card",
+			attributes: { name },
+			relationships: { next: { links: { self: next } } },
+			meta: adoptsFrom("ring", "Ring")
+		} };
+	}
+	function ringM(name, next) {
+		return { data: {
+			type: "card",
+			attributes: { name },
+			relationships: { "nexts.0": { links: { self: next } } },
+			meta: adoptsFrom("ring-m", "RingM")
+		} };
+	}
+	function team(name, klass, members) {
+		let relationships = {};
+		members.forEach((m, i) => {
+			relationships[`members.${i}`] = { links: { self: m } };
+		});
+		return { data: {
+			type: "card",
+			attributes: { name },
+			relationships,
+			meta: adoptsFrom("team", klass)
+		} };
+	}
+	async function loadAndGenerate(id) {
+		return await searchDocFromFields(await getService("store").get(id));
+	}
+	async function indexedSearchDoc(id) {
+		let entry = await realm.realmIndexQueryEngine.instance(new URL(id));
+		if (!entry || entry.type === "instance-error") return;
+		let { _cardType, _title, ...rest } = entry.searchDoc ?? {};
+		return rest;
+	}
+	let agentUrl = `${testRealmURL}Agent/a1`;
+	let agent2Url = `${testRealmURL}Agent/a2`;
+	let authorUrl = `${testRealmURL}Author/au1`;
+	let hqUrl = `${testRealmURL}Headquarters/h1`;
+	(0, import_qunit.test)("routes come ONLY from the indexed card: a pulled-in target does not consult its own searchable", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleSelf/s1`);
+		assert.strictEqual(doc.author?.name, "Jo", "author is expanded");
+		assert.deepEqual(doc.author?.agent, { id: agentUrl }, "the pulled-in Author's own searchable agent link stays { id }");
+	});
+	(0, import_qunit.test)("the same card indexed directly DOES honor its own searchable", async function(assert) {
+		let doc = await loadAndGenerate(authorUrl);
+		assert.strictEqual(doc.agent?.name, "Agent Smith", "Author.agent expands when Author is the card being indexed");
+	});
+	(0, import_qunit.test)("a single dotted route on the indexed card expands the deeper link", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleDeep/d1`);
+		assert.strictEqual(doc.author?.agent?.name, "Agent Smith", "the route `author.agent` drives the depth");
+	});
+	(0, import_qunit.test)("an unannotated link stays { id }", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleShallow/sh1`);
+		assert.deepEqual(doc.author, { id: authorUrl }, "captured as { id } only");
+	});
+	(0, import_qunit.test)("an empty-string path ('') behaves as a self link", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleEmptyPath/ep1`);
+		assert.strictEqual(doc.author?.name, "Jo", "author is expanded");
+		assert.deepEqual(doc.author?.agent, { id: agentUrl }, "no deeper than the self link");
+	});
+	(0, import_qunit.test)("an empty searchable array leaves the link as { id }", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleEmptyArray/ea1`);
+		assert.deepEqual(doc.author, { id: authorUrl }, "no route → { id }");
+	});
+	(0, import_qunit.test)("a null searchable annotation is treated as unannotated", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleNullSearchable/ns1`);
+		assert.deepEqual(doc.author, { id: authorUrl }, "null → { id }");
+	});
+	(0, import_qunit.test)("a `false` searchable value (bad input) leaves the link as { id }", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleFalse/f1`);
+		assert.deepEqual(doc.author, { id: authorUrl }, "false → { id }");
+	});
+	(0, import_qunit.test)("a searchable array with a non-string entry ignores it and still expands the valid route", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleArrayWithNull/awn1`);
+		assert.strictEqual(doc.title, "AwN", "did not crash");
+		assert.strictEqual(doc.author?.agent?.name, "Agent Smith", "the valid `agent` route still expands");
+	});
+	(0, import_qunit.test)("a searchable path naming a non-existent field expands the reachable prefix only", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleImpossiblePath/ip1`);
+		assert.strictEqual(doc.author?.agent?.name, "Agent Smith", "the reachable prefix (agent) expands");
+		assert.notOk("deeper" in (doc.author?.agent ?? {}), "the unreachable tail is a no-op (no junk key)");
+	});
+	(0, import_qunit.test)("a two-hop route expands the intermediate but leaves its further links { id }", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleHop2/h2`);
+		assert.strictEqual(doc.author?.company?.name, "Acme", "company is expanded");
+		assert.deepEqual(doc.author?.company?.ceo, { id: agentUrl }, "the pulled-in Company's own searchable ceo stays { id } at depth 2");
+		assert.deepEqual(doc.author?.company?.hq, { id: hqUrl }, "the pulled-in Company's own searchable hq stays { id } at depth 2");
+	});
+	(0, import_qunit.test)("a three-segment route (a.b.c) expands all the way down", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleHop3/h3`);
+		assert.strictEqual(doc.author?.company?.hq?.name, "HQ One", "the route `author.company.hq` expands the third hop");
+		assert.deepEqual(doc.author?.company?.ceo, { id: agentUrl }, "a sibling of the routed link (ceo) stays { id }");
+	});
+	(0, import_qunit.test)("an array of routes sharing an ancestor collapses through that ancestor once", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleShared/shr1`);
+		assert.strictEqual(doc.author?.company?.name, "Acme", "the shared ancestor `company` is expanded");
+		assert.strictEqual(doc.author?.company?.ceo?.name, "Agent Smith", "the first divergent route (company.ceo) expands");
+		assert.strictEqual(doc.author?.company?.hq?.name, "HQ One", "the second divergent route (company.hq) expands under the same ancestor");
+	});
+	(0, import_qunit.test)("an array of routes with divergent heads expands each independently", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleMulti/m1`);
+		assert.strictEqual(doc.author?.agent?.name, "Agent Smith", "the self-link route (agent) expands");
+		assert.strictEqual(doc.author?.company?.hq?.name, "HQ One", "the deep route (company.hq) expands");
+		assert.deepEqual(doc.author?.company?.ceo, { id: agentUrl }, "an unrouted sibling (company.ceo) stays { id }");
+	});
+	(0, import_qunit.test)("a relative link reference is resolved before the targeted load", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleSelf/rel`);
+		assert.strictEqual(doc.author?.name, "Jo", "a relative links.self resolves");
+	});
+	(0, import_qunit.test)("a searchable link to a missing target degrades to { id }", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleSelf/broken`);
+		assert.deepEqual(doc.author, { id: `${testRealmURL}Author/ghost` }, "an unloadable link keeps its reference as { id }");
+	});
+	(0, import_qunit.test)("a null link is captured as null", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleSelf/nulllink`);
+		assert.strictEqual(doc.author, null, "a missing link slot is null");
+	});
+	(0, import_qunit.test)("contains → linksTo: routed link expands; contained scalar + unrouted plural still present", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleContainsLead/cl1`);
+		assert.strictEqual(doc.crew?.label, "Alpha", "the contained scalar is always included");
+		assert.strictEqual(doc.crew?.lead?.name, "Agent Smith", "the routed linksTo expands (target contained field present)");
+		assert.deepEqual(doc.crew?.roster, [{ id: agentUrl }, { id: agent2Url }], "the unrouted linksToMany inside is still present as [{ id }]");
+	});
+	(0, import_qunit.test)("contains → linksToMany: routed plural expands; unrouted linksTo stays { id }", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleContainsRoster/cr1`);
+		assert.strictEqual(doc.crew?.label, "Alpha", "the contained scalar is always included");
+		assert.deepEqual((doc.crew?.roster ?? []).map((m) => m.name), ["Agent Smith", "Agent Jones"], "the routed linksToMany expands every element");
+		assert.deepEqual(doc.crew?.lead, { id: agentUrl }, "the unrouted linksTo inside stays { id }");
+	});
+	(0, import_qunit.test)("containsMany → linksTo: each element routes its link; each element scalar present", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleManyLead/ml1`);
+		assert.deepEqual((doc.crews ?? []).map((c) => c.label), ["C0", "C1"], "every element scalar is always included");
+		assert.strictEqual(doc.crews?.[0]?.lead?.name, "Agent Smith", "the first element's link expands");
+		assert.strictEqual(doc.crews?.[1]?.lead?.name, "Agent Jones", "the second element's link expands");
+		assert.deepEqual(doc.crews?.[0]?.roster, [{ id: agentUrl }], "the unrouted plural in the element is [{ id }]");
+	});
+	(0, import_qunit.test)("containsMany → linksToMany: each element routes its plural", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleManyRoster/mr1`);
+		assert.strictEqual(doc.crews?.[0]?.roster?.[0]?.name, "Agent Smith", "the first element's plural expands");
+		assert.strictEqual(doc.crews?.[1]?.roster?.[0]?.name, "Agent Jones", "the second element's plural expands");
+		assert.deepEqual(doc.crews?.[0]?.lead, { id: agentUrl }, "the unrouted linksTo in the element stays { id }");
+		assert.strictEqual(doc.crews?.[0]?.label, "C0", "the element scalar is present");
+	});
+	(0, import_qunit.test)("a contained value is enumerated by its DECLARED type (subtype field dropped)", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleProfile/prof1`);
+		assert.strictEqual(doc.profile?.bio, "a bio", "the declared contained field is present (unannotated contains is always included)");
+		assert.notOk("tagline" in (doc.profile ?? {}), "the polymorphic subtype-only field is dropped");
+	});
+	(0, import_qunit.test)("containsMany of primitives is captured as an array", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleLabels/l1`);
+		assert.deepEqual(doc.labels, ["red", "blue"], "all primitive items captured");
+	});
+	(0, import_qunit.test)("an empty containsMany is null", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleLabels/empty1`);
+		assert.strictEqual(doc.labels, null, "empty containsMany is null");
+	});
+	(0, import_qunit.test)("contained scalar fields are always present regardless of searchable", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleShallow/sh1`);
+		assert.strictEqual(doc.title, "Shallow", "the unrouted contained scalar is present");
+		assert.deepEqual(doc.author, { id: authorUrl }, "while the unannotated link stays { id }");
+	});
+	(0, import_qunit.test)("a searchable linksToMany expands every element", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}Team/valid`);
+		assert.deepEqual((doc.members ?? []).map((m) => m.name), ["Jo", "Mit"], "both members are expanded in slot order");
+	});
+	(0, import_qunit.test)("linksToMany targets do NOT consult their own searchable", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}Team/valid`);
+		assert.deepEqual(doc.members?.[0]?.agent, { id: agentUrl }, "the pulled-in member's own searchable agent link stays { id }");
+	});
+	(0, import_qunit.test)("an unannotated linksToMany is an array of { id }", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}TeamShallow/ts1`);
+		assert.deepEqual(doc.members, [{ id: agentUrl }], "each slot is { id } only");
+	});
+	(0, import_qunit.test)("a deep route into a linksToMany expands each element along it", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}TeamDeep/td1`);
+		assert.strictEqual(doc.members?.[0]?.agent?.name, "Agent Smith", "the route `members.agent` drives the depth into each element");
+	});
+	(0, import_qunit.test)("a linksToMany with one missing slot expands the rest and keeps the missing one as { id }", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}Team/missone`);
+		assert.strictEqual(doc.members?.[0]?.name, "Jo", "the present member expands");
+		assert.deepEqual(doc.members?.[1], { id: `${testRealmURL}Author/ghost1` }, "the missing member is { id }");
+	});
+	(0, import_qunit.test)("a linksToMany with all slots missing is an array of { id }", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}Team/missall`);
+		assert.deepEqual(doc.members, [{ id: `${testRealmURL}Author/ghost1` }, { id: `${testRealmURL}Author/ghost2` }], "every missing slot keeps its reference as { id }");
+	});
+	(0, import_qunit.test)("an empty linksToMany is null", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}Team/empty`);
+		assert.strictEqual(doc.members, null, "empty linksToMany is null");
+	});
+	(0, import_qunit.test)("a self-referential link clips the cycle to { id }", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}Person/p1`);
+		assert.deepEqual(doc.friend, { id: `${testRealmURL}Person/p1` }, "a self link clips to { id }");
+	});
+	(0, import_qunit.test)("a three-card ring (linksTo) walks the ring then clips on re-entry", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}Ring/r1`);
+		assert.strictEqual(doc.next?.name, "R2", "first hop");
+		assert.strictEqual(doc.next?.next?.name, "R3", "second hop");
+		assert.deepEqual(doc.next?.next?.next, { id: `${testRealmURL}Ring/r1` }, "the fourth hop re-enters r1 and clips to { id }");
+	});
+	(0, import_qunit.test)("a three-card ring (linksToMany) walks the ring then clips on re-entry", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}RingM/rm1`);
+		assert.strictEqual(doc.nexts?.[0]?.name, "R2m", "first hop");
+		assert.strictEqual(doc.nexts?.[0]?.nexts?.[0]?.name, "R3m", "second hop");
+		assert.deepEqual(doc.nexts?.[0]?.nexts?.[0]?.nexts, [{ id: `${testRealmURL}RingM/rm1` }], "the fourth hop re-enters rm1 and clips to { id }");
+	});
+	(0, import_qunit.test)("a query-backed field never appears in the doc", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleQuery/q1`);
+		assert.strictEqual(doc.title, "Query", "plain fields are present");
+		assert.notOk("related" in doc, "the query-backed field is skipped");
+	});
+	(0, import_qunit.test)("a computed that reads a query-backed field never appears in the doc", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleQuery/q1`);
+		assert.notOk("relatedCount" in doc, "a computed reading the query field is skipped");
+		assert.notOk("relatedSummary" in doc, "a computed reading the query field through another computed is skipped");
+		assert.strictEqual(doc.shoutedTitle, "QUERY", "a computed that reads no query field is still indexed");
+	});
+	(0, import_qunit.test)("a throwing branch does not stop sibling link loads in the same walk", async function(assert) {
+		let network = getService("network");
+		let store = new CardStoreWithGarbageCollection(/* @__PURE__ */ new Map(), network.fetch, network.virtualNetwork);
+		let doc = { data: {
+			id: `${testRealmURL}Boom/b1`,
+			type: "card",
+			attributes: {},
+			relationships: {
+				other: { links: { self: `${testRealmURL}Author/au1` } },
+				agent: { links: { self: `${testRealmURL}Agent/a3` } }
+			},
+			meta: { adoptsFrom: {
+				module: rri(`${testRealmURL}boom`),
+				name: "Boom"
+			} }
+		} };
+		let instance = await createFromSerialized(doc.data, doc, new URL(doc.data.id), { store });
+		let thrown;
+		try {
+			await searchDocFromFields(instance);
+		} catch (e) {
+			thrown = e;
+		}
+		assert.notStrictEqual(thrown, void 0, "the failing branch rethrows to the caller");
+		assert.ok(store.getCard(`${testRealmURL}Agent/a3`), "the sibling searchable target loaded during the same walk");
+		await store.loaded();
+	});
+	(0, import_qunit.test)("a linksTo target is enumerated by its DECLARED type (subtype bloat dropped)", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}ArticleSubtype/sub1`);
+		assert.strictEqual(doc.author?.name, "Fancy", "the declared field is present");
+		assert.notOk("penName" in (doc.author ?? {}), "the subtype-only field is dropped");
+	});
+	(0, import_qunit.test)("a linksToMany target is enumerated by its DECLARED type (subtype bloat dropped)", async function(assert) {
+		let doc = await loadAndGenerate(`${testRealmURL}TeamSubtype/tsub1`);
+		assert.strictEqual(doc.members?.[0]?.name, "Fancy", "the declared field is present");
+		assert.notOk("penName" in (doc.members?.[0] ?? {}), "the subtype-only field is dropped");
+	});
+	(0, import_qunit.test)("the indexer persists the searchable-driven search doc", async function(assert) {
+		let id = `${testRealmURL}ParityArticle/pa1`;
+		let indexed = await indexedSearchDoc(id);
+		assert.deepEqual(indexed, {
+			authors: [{
+				cardInfo: {
+					cardThumbnail: null,
+					theme: null
+				},
+				cardTheme: null,
+				cardTitle: "Untitled SimpleAuthor",
+				id: `${testRealmURL}SimpleAuthor/sa1`,
+				name: "Plain"
+			}],
+			cardInfo: {
+				cardThumbnail: null,
+				theme: null
+			},
+			cardTheme: null,
+			cardTitle: "Untitled ParityArticle",
+			id: `${testRealmURL}ParityArticle/pa1`,
+			title: "Parity"
+		}, "the indexer persists the searchable-driven doc");
+		let entry = await realm.realmIndexQueryEngine.instance(new URL(id));
+		let deps = entry && entry.type !== "instance-error" ? entry.deps ?? [] : [];
+		assert.ok(deps.some((d) => d.includes("SimpleAuthor/sa1")), "the searchable-expanded target is recorded as a dependency");
+	});
+	async function loadInstance(id) {
+		return await getService("store").get(id);
+	}
+	function unloadLink(instance, fieldName, reference) {
+		getDataBucket(instance).set(fieldName, Array.isArray(reference) ? reference.map((r) => ({
+			type: "not-loaded",
+			reference: r
+		})) : {
+			type: "not-loaded",
+			reference
+		});
+	}
+	(0, import_qunit.test)("per-field timings are keyed by dotted path and include expanded link targets; link loads carry path + target", async function(assert) {
+		let instance = await loadInstance(`${testRealmURL}ArticleDeep/d1`);
+		let author = await loadInstance(authorUrl);
+		unloadLink(instance, "author", authorUrl);
+		unloadLink(author, "agent", agentUrl);
+		let timings = {
+			fieldsMs: {},
+			linkLoads: []
+		};
+		let doc = await searchDocFromFields(instance, void 0, timings);
+		let fieldsMs = timings.fieldsMs;
+		for (let path of [
+			"title",
+			"author",
+			"author.agent"
+		]) {
+			assert.strictEqual(typeof fieldsMs[path], "number", `fieldsMs['${path}'] is a number, got: ${fieldsMs[path]}`);
+			assert.ok(fieldsMs[path] >= 0, `fieldsMs['${path}'] is non-negative, got: ${fieldsMs[path]}`);
+		}
+		assert.ok(fieldsMs["author"] >= fieldsMs["author.agent"], "a parent field time is inclusive of its nested fields");
+		let loads = timings.linkLoads;
+		assert.ok(loads.some((l) => l.path === "author" && l.target === authorUrl), `the author load is recorded with its path and target, got: ${JSON.stringify(loads)}`);
+		assert.ok(loads.some((l) => l.path === "author.agent" && l.target === agentUrl), "the route-expanded deeper load is recorded under its dotted path");
+		assert.ok(loads.every((l) => typeof l.ms === "number" && l.ms >= 0), "every load entry carries a non-negative ms");
+		assert.deepEqual(doc, await searchDocFromFields(instance), "the instrumented walk produces the same doc as an uninstrumented one");
+	});
+	(0, import_qunit.test)("a plural field accumulates under one path key and records one load per slot", async function(assert) {
+		let instance = await loadInstance(`${testRealmURL}Team/valid`);
+		unloadLink(instance, "members", [`${testRealmURL}Author/au1`, `${testRealmURL}Author/au2`]);
+		let timings = {
+			fieldsMs: {},
+			linkLoads: []
+		};
+		await searchDocFromFields(instance, void 0, timings);
+		let memberKeys = Object.keys(timings.fieldsMs).filter((k) => k === "members" || k.startsWith("members."));
+		assert.ok(memberKeys.includes("members"), "the plural field has a single accumulated key");
+		assert.ok(memberKeys.includes("members.name"), "the expanded members' fields accumulate under the shared dotted path");
+		let memberLoads = timings.linkLoads.filter((l) => l.path === "members");
+		assert.deepEqual(memberLoads.map((l) => l.target).sort(), [`${testRealmURL}Author/au1`, `${testRealmURL}Author/au2`], "each slot records its own load, distinguished by target");
+	});
+	(0, import_qunit.test)("collector channels are opt-in", async function(assert) {
+		let instance = await loadInstance(`${testRealmURL}ArticleSelf/s1`);
+		unloadLink(instance, "author", authorUrl);
+		let fieldsOnly = { fieldsMs: {} };
+		await searchDocFromFields(instance, void 0, fieldsOnly);
+		assert.ok(Object.keys(fieldsOnly.fieldsMs).length > 0, "the supplied fields channel is filled");
+		assert.strictEqual(fieldsOnly.linkLoads, void 0, "the absent loads channel is not created");
+		let loadsOnly = { linkLoads: [] };
+		await searchDocFromFields(instance, void 0, loadsOnly);
+		assert.ok(loadsOnly.linkLoads.some((l) => l.path === "author" && l.target === authorUrl), "the supplied loads channel is filled");
+		assert.strictEqual(loadsOnly.fieldsMs, void 0, "the absent fields channel is not created");
+	});
+});
+//#endregion