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

package/bundled-test-harness/assets/search-adorn-test-CW92JPOk.js

@@ -0,0 +1,136 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import "./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 templateOnly } from "./template-only-6nVzLWF-.js";
+import { h as render } from "./dist-BOAdzfkP.js";
+import { t as SearchResultTile } from "./result-tile-BSg4mzbc.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { lt as setupRenderingTest } from "./mock-matrix-DPQ0j2MD.js";
+//#region tests/integration/components/search-adorn-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var StubComponent = setComponentTemplate(templateFactory({
+	"id": "hik/42xG",
+	"block": "[[[10,0],[14,\"data-test-stub-card\",\"\"],[12],[1,\"Authenticated Image Tester preview\"],[13]],[],[]]",
+	"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-adorn-test.gts",
+	"isStrictMode": true
+}), templateOnly());
+function entry(overrides = {}) {
+	return {
+		id: "http://test/Foo/1",
+		type: "card",
+		realmUrl: "http://test/",
+		name: "Foo/1",
+		isError: false,
+		component: StubComponent,
+		...overrides
+	};
+}
+var baseEntry = entry();
+var namedEntry = entry({ displayName: "Authenticated Image Tester" });
+var iconEntry = entry({
+	displayName: "Authenticated Image Tester",
+	iconHtml: "<svg data-test-type-icon></svg>"
+});
+var noop = () => {};
+var newCardItem = {
+	ref: {
+		module: rri("http://test/foo.gts"),
+		name: "Foo"
+	},
+	relativeTo: void 0,
+	realmURL: rri("http://test/")
+};
+(0, import_qunit.module)("Integration | search/result-tile (adorn)", function(hooks) {
+	setupRenderingTest(hooks);
+	(0, import_qunit.test)("passes through the adorn class when @adorn is true", async function(assert) {
+		await render(setComponentTemplate(templateFactory({
+			"id": "P3HfM1yx",
+			"block": "[[[8,[32,0],null,[[\"@newCard\",\"@isSelected\",\"@onSelect\",\"@adorn\"],[[32,1],false,[32,2],true]],null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-adorn-test.gts",
+			"scope": () => [
+				SearchResultTile,
+				newCardItem,
+				noop
+			],
+			"isStrictMode": true
+		}), templateOnly()));
+		assert.dom(".item-button.adorn").exists("the item-button carries the adorn class");
+	});
+	(0, import_qunit.test)("does not add the adorn class when @adorn is omitted", async function(assert) {
+		await render(setComponentTemplate(templateFactory({
+			"id": "re0YYPa9",
+			"block": "[[[8,[32,0],null,[[\"@newCard\",\"@isSelected\",\"@onSelect\"],[[32,1],false,[32,2]]],null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-adorn-test.gts",
+			"scope": () => [
+				SearchResultTile,
+				newCardItem,
+				noop
+			],
+			"isStrictMode": true
+		}), templateOnly()));
+		assert.dom(".item-button").exists();
+		assert.dom(".item-button.adorn").doesNotExist("the legacy treatment is unchanged without @adorn");
+	});
+	(0, import_qunit.test)("does not apply the Adorn stroke class when @adorn is false", async function(assert) {
+		await render(setComponentTemplate(templateFactory({
+			"id": "InPt65A6",
+			"block": "[[[8,[32,0],null,[[\"@newCard\",\"@isSelected\",\"@onSelect\",\"@adornStrokeClass\"],[[32,1],false,[32,2],\"adorn-stroke\"]],null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-adorn-test.gts",
+			"scope": () => [
+				SearchResultTile,
+				newCardItem,
+				noop
+			],
+			"isStrictMode": true
+		}), templateOnly()));
+		assert.dom(".item-button.adorn-stroke").doesNotExist("a non-adorn tile does not receive the Adorn outline class");
+	});
+	(0, import_qunit.test)("renders the teal adorn select chip when adorn + multi-select + selected", async function(assert) {
+		await render(setComponentTemplate(templateFactory({
+			"id": "9iTZhWNv",
+			"block": "[[[8,[32,0],null,[[\"@entry\",\"@isSelected\",\"@multiSelect\",\"@onSelect\",\"@adorn\"],[[32,1],true,true,[32,2],true]],null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-adorn-test.gts",
+			"scope": () => [
+				SearchResultTile,
+				baseEntry,
+				noop
+			],
+			"isStrictMode": true
+		}), templateOnly()));
+		assert.dom("[data-test-adorn-selected]").exists("the teal adorn selection chip is rendered");
+		assert.dom(".selection-indicator").doesNotExist("the legacy grey selection circle is suppressed");
+	});
+	(0, import_qunit.test)("hover type-label tab reflects the entry display name", async function(assert) {
+		await render(setComponentTemplate(templateFactory({
+			"id": "FOAaqTs2",
+			"block": "[[[8,[32,0],null,[[\"@entry\",\"@isSelected\",\"@onSelect\",\"@adorn\"],[[32,1],false,[32,2],true]],null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-adorn-test.gts",
+			"scope": () => [
+				SearchResultTile,
+				namedEntry,
+				noop
+			],
+			"isStrictMode": true
+		}), templateOnly()));
+		assert.dom("[data-test-adorn-label]").containsText("Authenticated Image Tester", "the type-label tab reflects the entry view-model displayName");
+	});
+	(0, import_qunit.test)("renders the type icon from the entry iconHtml", async function(assert) {
+		await render(setComponentTemplate(templateFactory({
+			"id": "FOAaqTs2",
+			"block": "[[[8,[32,0],null,[[\"@entry\",\"@isSelected\",\"@onSelect\",\"@adorn\"],[[32,1],false,[32,2],true]],null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-adorn-test.gts",
+			"scope": () => [
+				SearchResultTile,
+				iconEntry,
+				noop
+			],
+			"isStrictMode": true
+		}), templateOnly()));
+		assert.dom("[data-test-adorn-label] [data-test-type-icon]").exists("the type icon is rendered in the label icon slot");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/search-entries-BU4w6Ymc.js

@@ -0,0 +1,472 @@
+import { r as __exportAll } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { $o as isFileMetaResource, Qo as isCssResource, Sc as Deferred, Xo as isCardResource, Zi as htmlQueryRenderingSelection, bc as stringifyErrorForLog, es as isHtmlResource, h as subscribeToRealm, ia as wireFilterTypeAnchors, ms as logger, no as resourceIdentity, ra as wireFilterHasMatches, ts as isIconResource } from "./runtime-common-ClpqhbwG.js";
+import { a as RealmPaths, y as rri } from "./paths-BYHDgqsT.js";
+import { S as isEqual } from "./lodash-DnaZ_rzx.js";
+import { t as getOwner } from "./owner-BT6cj890.js";
+import { On as isDestroyed, kn as isDestroying } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { r as service } from "./service-LFpJ8EEP.js";
+import { n as registerDestructor } from "./destroyable-mdLYRn_o.js";
+import { l as didCancel, n as buildTask } from "./async-arrow-runtime-STsj7E8Y.js";
+import { n as Resource } from "./dist-B-fYvxfL.js";
+import { r as TrackedArray } from "./dist-B9tGPKZz.js";
+import { n as tracked } from "./tracking-800VJb8b.js";
+import "./dist-DEVZvbin.js";
+import { t as buildWaiter } from "./dist-CSQ-y1Ft.js";
+import { t as LiveSearchRefreshScheduler } from "./live-search-refresh-scheduler-C1Dy_zl0.js";
+import { n as knownFileMetaUrls } from "./known-file-meta-urls-BtSTkGnL.js";
+import { n as LiveSearchTypeGate, r as stripJsonSuffix, t as searchErrorEntry } from "./search-error-entry-DWpD-8HE.js";
+import { r as dedupeRealmsByIdentity, t as canonicalRealmIdentifier } from "./realm-utils-K-gQ_i6s.js";
+//#region app/resources/search-entries.ts
+var search_entries_exports = /* @__PURE__ */ __exportAll({
+	SearchEntriesResource: () => SearchEntriesResource,
+	getSearchEntriesResource: () => getSearchEntriesResource
+});
+var waiter = buildWaiter("search-entries-resource:search-waiter");
+var SearchEntriesResource = class extends Resource {
+	static {
+		decorateFieldV2(this.prototype, "loaderService", [service]);
+	}
+	#loaderService = (initializeDeferredDecorator(this, "loaderService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "network", [service]);
+	}
+	#network = (initializeDeferredDecorator(this, "network"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "realm", [service]);
+	}
+	#realm = (initializeDeferredDecorator(this, "realm"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "realmServer", [service]);
+	}
+	#realmServer = (initializeDeferredDecorator(this, "realmServer"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "store", [service]);
+	}
+	#store = (initializeDeferredDecorator(this, "store"), void 0);
+	realmsToSearch = [];
+	subscriptions = [];
+	_entries = new TrackedArray();
+	static {
+		decorateFieldV2(this.prototype, "_meta", [tracked], function() {
+			return { page: { total: 0 } };
+		});
+	}
+	#_meta = (initializeDeferredDecorator(this, "_meta"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "_errors", [tracked]);
+	}
+	#_errors = (initializeDeferredDecorator(this, "_errors"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "_entriesQuery", [tracked]);
+	}
+	#_entriesQuery = (initializeDeferredDecorator(this, "_entriesQuery"), void 0);
+	realmsNeedingRefresh = /* @__PURE__ */ new Set();
+	pendingSelectiveRefresh;
+	#typeGate = new LiveSearchTypeGate({
+		anchors: () => namesItsOperation(this.#previousQuery) ? void 0 : wireFilterTypeAnchors(this.#previousQuery?.filter),
+		loader: () => this.loaderService.loader,
+		virtualNetwork: () => this.network.virtualNetwork,
+		isDestroyed: () => isDestroyed(this)
+	});
+	#refreshEpoch = 0;
+	#refreshScheduler = new LiveSearchRefreshScheduler(() => this.#flushEventRefresh());
+	hasCompletedFullRun = false;
+	#hasSettled = false;
+	#previousQuery;
+	#previousRealms;
+	#cardInitiated = false;
+	#getDefaultRealm;
+	#idleClearScheduled = false;
+	#log = logger("search-entries-resource");
+	loaded;
+	constructor(owner) {
+		super(owner);
+		registerDestructor(this, () => {
+			this.search.cancelAll();
+			this.#refreshScheduler.cancel();
+			for (let subscription of this.subscriptions) subscription.unsubscribe();
+			this.subscriptions = [];
+			this.realmsNeedingRefresh.clear();
+			this.pendingSelectiveRefresh = void 0;
+			this.#refreshEpoch++;
+			this.#typeGate.forget();
+		});
+	}
+	get runtimeStore() {
+		if (globalThis.__boxelRenderContext === true) {
+			let renderStore = getOwner(this)?.lookup("service:render-store");
+			if (renderStore) return renderStore;
+		}
+		return this.store;
+	}
+	#trackSearchLoad(load) {
+		this.loaded = load;
+		this.runtimeStore.trackLoad(load);
+	}
+	modify(_positional, named) {
+		let { query, cardInitiated, getDefaultRealm } = named;
+		if (cardInitiated !== void 0) this.#cardInitiated = cardInitiated;
+		if (getDefaultRealm !== void 0) this.#getDefaultRealm = getDefaultRealm;
+		if (query === void 0) {
+			this.#previousQuery = void 0;
+			this.#previousRealms = void 0;
+			this.realmsNeedingRefresh.clear();
+			this.pendingSelectiveRefresh = void 0;
+			this.#typeGate.forget();
+			this.#refreshScheduler.cancel();
+			this.#refreshEpoch++;
+			this.hasCompletedFullRun = false;
+			this.#hasSettled = false;
+			this.search.cancelAll();
+			for (let subscription of this.subscriptions) subscription.unsubscribe();
+			this.subscriptions = [];
+			if (!this.#idleClearScheduled) {
+				this.#idleClearScheduled = true;
+				Promise.resolve().then(() => {
+					this.#idleClearScheduled = false;
+					if (this.#previousQuery !== void 0 || isDestroyed(this)) return;
+					if (this._entries.length > 0) this._entries.splice(0, this._entries.length);
+					if (this._meta.page.total !== 0 || this._meta.htmlQuery) this._meta = { page: { total: 0 } };
+					if (this._errors !== void 0) this._errors = void 0;
+					if (this._entriesQuery !== void 0) this._entriesQuery = void 0;
+				});
+			}
+			return;
+		}
+		let realms = dedupeRealmsByIdentity(this.network.virtualNetwork, query.realms && query.realms.length > 0 ? query.realms : this.#cardInitiated ? this.#currentRealmList() : this.realmServer.availableRealmIdentifiers);
+		this.realmsToSearch = realms;
+		let realmsChanged = !isEqual(realms, this.#previousRealms);
+		if (this.subscriptions.length === 0 || realmsChanged) {
+			for (let subscription of this.subscriptions) subscription.unsubscribe();
+			this.subscriptions = realms.map((realm) => ({
+				realm,
+				unsubscribe: subscribeToRealm(realm, (event) => {
+					if (this.#previousQuery === void 0) return;
+					let isIncrementalIndex = event.eventName === "index" && (!("indexType" in event) || event.indexType === "incremental");
+					if (!isIncrementalIndex && event.eventName !== "prerender_html") return;
+					if (isIncrementalIndex && this.#typeGate.indexEventCannotMatch(event)) {
+						this.#log.info(`incremental index event on ${realm} touched no type this query is anchored on; skipping refresh`);
+						return;
+					}
+					if (event.eventName === "prerender_html" && typeof event.generation === "number" && this.#canSelectivelyRefresh() && !this.#sessionCannotRead(realm)) {
+						this.#log.info(`prerender_html event on ${realm}; scheduling selective per-member refresh`);
+						this.#recordSelectiveRefresh(event);
+						this.#refreshScheduler.schedule();
+						return;
+					}
+					this.#log.info(`${event.eventName === "prerender_html" ? "prerender_html" : "incremental index"} event on ${realm}; scheduling partial refresh`);
+					this.realmsNeedingRefresh.add(realm);
+					this.#refreshScheduler.schedule();
+				})
+			}));
+		}
+		let queryChanged = !isEqual(query, this.#previousQuery);
+		if (!queryChanged && !realmsChanged) return;
+		this.#previousQuery = structuredClone(query);
+		this.#previousRealms = realms;
+		if (queryChanged) this.#typeGate.forget();
+		this.#refreshScheduler.cancel();
+		this.realmsNeedingRefresh.clear();
+		this.pendingSelectiveRefresh = void 0;
+		this.hasCompletedFullRun = false;
+		this.#hasSettled = false;
+		let loaded = new Deferred();
+		this.#trackSearchLoad(loaded.promise);
+		Promise.resolve().then(() => {
+			if (isDestroyed(this) || isDestroying(this)) {
+				loaded.fulfill();
+				return;
+			}
+			this.search.perform().then(() => loaded.fulfill(), () => loaded.fulfill());
+		});
+	}
+	#currentRealmList() {
+		let current = this.#getDefaultRealm?.();
+		return current ? [current] : [];
+	}
+	get isLoading() {
+		return this.search.isRunning || this.#previousQuery !== void 0 && !this.#hasSettled;
+	}
+	get entries() {
+		return this._entries;
+	}
+	get meta() {
+		return this._meta;
+	}
+	get errors() {
+		return this._errors;
+	}
+	get entriesQuery() {
+		return this._entriesQuery;
+	}
+	retry() {
+		if (isDestroyed(this) || isDestroying(this) || this.#previousQuery === void 0) return;
+		this.#hasSettled = false;
+		this.#trackSearchLoad(this.search.perform());
+	}
+	#flushEventRefresh() {
+		if (isDestroyed(this) || isDestroying(this) || this.#previousQuery === void 0) return;
+		this.#trackSearchLoad(this.search.perform());
+	}
+	search = buildTask(() => ({
+		context: this,
+		generator: function* () {
+			let query = this.#previousQuery;
+			if (query === void 0) return;
+			let token = waiter.beginAsync();
+			this.#refreshEpoch++;
+			try {
+				let selective = this.pendingSelectiveRefresh;
+				if (selective) {
+					if (this.realmsNeedingRefresh.size === 0 && this.#canSelectivelyRefresh()) {
+						let refresh = yield this.#computeSelectiveRefresh(selective, query);
+						if (refresh !== "fallback") {
+							if (refresh.size > 0) {
+								let next = this._entries.map((member) => {
+									let replacement = refresh.get(member.id);
+									return replacement === void 0 ? member : adoptFresh(member, replacement);
+								});
+								this._entries.splice(0, this._entries.length, ...next);
+								this._errors = void 0;
+							}
+							this.pendingSelectiveRefresh = void 0;
+							return;
+						}
+					}
+					this.pendingSelectiveRefresh = void 0;
+					this.#foldSelectiveRealmsIntoRefresh(selective);
+				}
+				let isPartialRefresh = this.hasCompletedFullRun && this.realmsNeedingRefresh.size > 0 && query.page === void 0 && !namesItsOperation(query);
+				let realmsToFetch = isPartialRefresh ? [...this.realmsNeedingRefresh] : this.realmsToSearch;
+				try {
+					let doc = yield this.runtimeStore.searchEntries(query, realmsToFetch, { cardInitiated: this.#cardInitiated });
+					yield this.loadStylesheets(doc);
+					let fresh = this.buildEntries(doc);
+					if (isPartialRefresh) {
+						let refreshedRealms = new Set(realmsToFetch);
+						let freshById = new Map(fresh.map((entry) => [entry.id, entry]));
+						let merged = [];
+						for (let entry of this._entries) {
+							if (!refreshedRealms.has(entry.realmUrl)) {
+								merged.push(entry);
+								continue;
+							}
+							let replacement = freshById.get(entry.id);
+							if (replacement !== void 0) {
+								merged.push(adoptFresh(entry, replacement));
+								freshById.delete(entry.id);
+							}
+						}
+						merged.push(...freshById.values());
+						this._entries.splice(0, this._entries.length, ...merged);
+						let refreshedTotals = this.realmTotalsFor(doc);
+						this._meta = {
+							...this._meta,
+							page: { total: this._entries.length },
+							...refreshedTotals ? { realmTotals: {
+								...this._meta.realmTotals,
+								...refreshedTotals
+							} } : {}
+						};
+					} else {
+						let previousById = new Map(this._entries.map((entry) => [entry.id, entry]));
+						let next = fresh.map((entry) => adoptFresh(previousById.get(entry.id), entry));
+						this._entries.splice(0, this._entries.length, ...next);
+						let realmTotals = this.realmTotalsFor(doc);
+						this._meta = realmTotals ? {
+							...doc.meta,
+							realmTotals
+						} : doc.meta;
+						this._entriesQuery = query;
+						this.hasCompletedFullRun = true;
+					}
+					this.realmsNeedingRefresh.clear();
+					this._errors = void 0;
+				} catch (err) {
+					if (didCancel(err)) throw err;
+					this.#log.error(`search-entries fetch failed`, err);
+					this._errors = [searchErrorEntry(err)];
+					if (!isPartialRefresh) {
+						this._entries.splice(0, this._entries.length);
+						this._meta = { page: { total: 0 } };
+						this._entriesQuery = void 0;
+					}
+				}
+			} finally {
+				this.#hasSettled = true;
+				waiter.endAsync(token);
+			}
+		}
+	}), null, "search", "restartable");
+	#canSelectivelyRefresh() {
+		let query = this.#previousQuery;
+		if (query === void 0 || !this.hasCompletedFullRun) return false;
+		if (query.page !== void 0 || namesItsOperation(query)) return false;
+		if (wireFilterHasMatches(query.filter)) return false;
+		if (this._meta.htmlQuery !== void 0 && htmlQueryRenderingSelection(this._meta.htmlQuery) === void 0) return false;
+		return this.#fieldsetIsRefreshable(query.fields?.entry);
+	}
+	#sessionCannotRead(realm) {
+		return this.realm.token(realm) !== void 0 && !this.realm.canRead(realm);
+	}
+	#fieldsetIsRefreshable(fields) {
+		return fields === void 0 || fields.includes("html") && fields.every((field) => field === "html" || field === "item");
+	}
+	#recordSelectiveRefresh(event) {
+		let pending = this.pendingSelectiveRefresh ??= /* @__PURE__ */ new Map();
+		for (let url of event.invalidations ?? []) pending.set(url, Math.max(pending.get(url) ?? 0, event.generation));
+	}
+	#foldSelectiveRealmsIntoRefresh(invalidations) {
+		for (let member of this._entries) if (invalidationGenerationFor(member, invalidations) !== void 0) this.realmsNeedingRefresh.add(member.realmUrl);
+	}
+	async #computeSelectiveRefresh(invalidations, query) {
+		let epoch = this.#refreshEpoch;
+		let selection = htmlQueryRenderingSelection(this._meta.htmlQuery);
+		let fieldsParam = this.#fieldsParam(query.fields?.entry);
+		let candidates = this._entries.filter((member) => {
+			let eventGeneration = invalidationGenerationFor(member, invalidations);
+			if (eventGeneration === void 0) return false;
+			return member.htmlGeneration === void 0 || member.htmlGeneration < eventGeneration;
+		});
+		let replacements = /* @__PURE__ */ new Map();
+		for (let member of candidates) {
+			if (epoch !== this.#refreshEpoch || isDestroyed(this)) return replacements;
+			try {
+				let result = await this.runtimeStore.fetchCardEntry(member.id, {
+					kind: memberKind(member),
+					format: selection?.format,
+					renderType: selection?.renderType,
+					fields: fieldsParam,
+					ifNoneMatch: memberValidator(member)
+				});
+				if (result.notModified) continue;
+				let collectionDoc = {
+					data: [result.doc.data],
+					included: result.doc.included,
+					meta: { page: { total: 1 } }
+				};
+				await this.loadStylesheets(collectionDoc);
+				let [refreshed] = this.buildEntries(collectionDoc);
+				if (refreshed === void 0) return "fallback";
+				if (member.html.length > 0 && refreshed.html.length === 0) return "fallback";
+				replacements.set(member.id, refreshed);
+			} catch (err) {
+				this.#log.warn(`selective refresh failed for ${member.id}; falling back to a full re-run`, err);
+				return "fallback";
+			}
+		}
+		return replacements;
+	}
+	#fieldsParam(fields) {
+		return fields === void 0 ? void 0 : fields.join(",");
+	}
+	async loadStylesheets(doc) {
+		let hrefs = (doc.included ?? []).filter(isCssResource).map((resource) => resource.attributes.href);
+		let results = await Promise.allSettled(hrefs.map((href) => this.loaderService.loader.import(href)));
+		for (let [i, result] of results.entries()) if (result.status === "rejected") this.#log.warn(`could not load scoped stylesheet ${hrefs[i]}; results render unstyled: ${stringifyErrorForLog(result.reason)}`);
+	}
+	realmUrlResolver() {
+		let { virtualNetwork } = this.network;
+		let targets = this.realmsToSearch.map((realm) => ({
+			realm,
+			paths: new RealmPaths(canonicalRealmIdentifier(virtualNetwork, realm))
+		}));
+		return (id) => {
+			let idRRI = rri(virtualNetwork.unresolveURL(id));
+			for (let { realm, paths } of targets) if (paths.inRealm(idRRI)) return realm;
+			return new RealmPaths(virtualNetwork.toURL(id)).url;
+		};
+	}
+	realmTotalsFor(doc) {
+		let totals = doc.meta?.realmTotals;
+		if (!totals) return;
+		let realmUrlFor = this.realmUrlResolver();
+		return Object.fromEntries(Object.entries(totals).map(([realm, total]) => [realmUrlFor(realm), total]));
+	}
+	buildEntries(doc) {
+		let htmlById = /* @__PURE__ */ new Map();
+		let cssHrefById = /* @__PURE__ */ new Map();
+		let iconById = /* @__PURE__ */ new Map();
+		let itemsByIdentity = /* @__PURE__ */ new Map();
+		for (let resource of doc.included ?? []) if (isHtmlResource(resource)) htmlById.set(resource.id, resource);
+		else if (isCssResource(resource)) cssHrefById.set(resource.id, resource.attributes.href);
+		else if (isIconResource(resource)) iconById.set(resource.id, resource.attributes);
+		else if (isCardResource(resource) || isFileMetaResource(resource)) itemsByIdentity.set(resourceIdentity(resource.type, resource.id), resource);
+		let realmUrlFor = this.realmUrlResolver();
+		return doc.data.map((entry) => {
+			let htmlResources = (entry.relationships.html?.data ?? []).map((ref) => htmlById.get(ref.id)).filter(Boolean);
+			let renderings = htmlResources.map((html) => buildRendering(html, cssHrefById));
+			let htmlGeneration = htmlResources[0]?.meta?.generation;
+			let itemRef = entry.relationships.item?.data;
+			let item = itemRef ? itemsByIdentity.get(resourceIdentity(itemRef.type, itemRef.id)) : void 0;
+			let iconRef = entry.relationships.icon?.data;
+			let icon = iconRef ? iconById.get(iconRef.id) : void 0;
+			if (itemRef?.type === "file-meta" || renderings.length > 0 && !renderings[0].renderType) knownFileMetaUrls.add(entry.id);
+			return {
+				id: entry.id,
+				realmUrl: realmUrlFor(entry.id),
+				html: renderings,
+				...item ? { item } : {},
+				...icon ? {
+					iconHtml: icon.iconHtml,
+					displayName: icon.displayName,
+					codeRef: icon.codeRef
+				} : {},
+				...entry.meta?.generation !== void 0 ? { indexGeneration: entry.meta.generation } : {},
+				...htmlGeneration !== void 0 ? { htmlGeneration } : {}
+			};
+		});
+	}
+};
+function namesItsOperation(query) {
+	return query?.operation !== void 0;
+}
+function buildRendering(html, cssHrefById) {
+	let { attributes, relationships } = html;
+	return {
+		id: html.id,
+		...attributes.html !== void 0 ? { html: attributes.html } : {},
+		cardType: attributes.cardType,
+		isError: Boolean(attributes.isError),
+		format: attributes.format,
+		...attributes.renderType ? { renderType: attributes.renderType } : {},
+		cssUrls: relationships.styles.data.map(({ id }) => cssHrefById.get(id)).filter((href) => Boolean(href))
+	};
+}
+function adoptFresh(previous, fresh) {
+	if (previous === void 0 || !contentEquals(previous, fresh)) return fresh;
+	if (fresh.indexGeneration !== void 0) previous.indexGeneration = fresh.indexGeneration;
+	else delete previous.indexGeneration;
+	if (fresh.htmlGeneration !== void 0) previous.htmlGeneration = fresh.htmlGeneration;
+	else delete previous.htmlGeneration;
+	return previous;
+}
+function contentEquals(a, b) {
+	let { indexGeneration: _aIndexGeneration, htmlGeneration: _aHtmlGeneration, ...aContent } = a;
+	let { indexGeneration: _bIndexGeneration, htmlGeneration: _bHtmlGeneration, ...bContent } = b;
+	return isEqual(aContent, bContent);
+}
+function invalidationGenerationFor(member, invalidations) {
+	let normalized = stripJsonSuffix(member.id);
+	let result;
+	for (let [url, generation] of invalidations) if (stripJsonSuffix(url) === normalized) result = result === void 0 ? generation : Math.max(result, generation);
+	return result;
+}
+function memberKind(member) {
+	if (member.item) return member.item.type === "file-meta" ? "file-meta" : "card";
+	if (member.html.length > 0 && !member.html[0].renderType) return "file-meta";
+	return "card";
+}
+function memberValidator(member) {
+	return `"${member.indexGeneration ?? 0}:${member.htmlGeneration !== void 0 ? String(member.htmlGeneration) : "none"}"`;
+}
+function getSearchEntriesResource(parent, getQuery, opts) {
+	return SearchEntriesResource.from(parent, () => ({ named: {
+		query: getQuery(),
+		cardInitiated: opts?.cardInitiated,
+		getDefaultRealm: opts?.getDefaultRealm
+	} }));
+}
+//#endregion
+export { getSearchEntriesResource as n, search_entries_exports as r, SearchEntriesResource as t };