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

package/bundled-test-harness/assets/search-BkQYpQDY.js

@@ -0,0 +1,605 @@
+import { r as __exportAll } from "./chunk-Rp0pCe6z.js";
+import { n as decorateMethodV2, r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Da as isFileDefCodeRef, G as makeInstanceComparator, K as matchInstanceAgainstFilter, Ro as isFileDefInstance, W as isClientEvaluable, Xr as canonicalizeFilterRefs, Z as canonicalQuerySignature, bo as parseSearchURL, h as subscribeToRealm, ia as wireFilterTypeAnchors, jo as identifyCard, ms as logger, na as searchEntryWireQueryFromQuery, rs as isResolvedCodeRef, zs as runtimeDependencyContextWithSource } from "./runtime-common-ClpqhbwG.js";
+import { a as RealmPaths, v as ri, y as rri } from "./paths-BYHDgqsT.js";
+import { F as difference, S as isEqual } from "./lodash-DnaZ_rzx.js";
+import { r as setOwner } from "./owner-CP0__uFm.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, t as cached } 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 LiveSearchTypeGate, t as searchErrorEntry } from "./search-error-entry-DWpD-8HE.js";
+import { t as canonicalRealmIdentifier } from "./realm-utils-K-gQ_i6s.js";
+//#region app/resources/search.ts
+var search_exports = /* @__PURE__ */ __exportAll({
+	SearchResource: () => SearchResource,
+	getSearch: () => getSearch
+});
+var waiter = buildWaiter("search-resource:search-waiter");
+var CandidateReferenceRetainer = class {
+	#held = /* @__PURE__ */ new Set();
+	#desired = /* @__PURE__ */ new Set();
+	#flushScheduled = false;
+	#torn = false;
+	constructor(getStore, parent) {
+		this.getStore = getStore;
+		registerDestructor(parent, () => {
+			this.#torn = true;
+			this.#desired = /* @__PURE__ */ new Set();
+			this.#reconcile();
+		});
+	}
+	retain(ids) {
+		if (this.#torn) return;
+		this.#desired = new Set(ids);
+		if (this.#flushScheduled) return;
+		this.#flushScheduled = true;
+		queueMicrotask(() => {
+			this.#flushScheduled = false;
+			if (!this.#torn) this.#reconcile();
+		});
+	}
+	#reconcile() {
+		if (this.#held.size === 0 && this.#desired.size === 0) return;
+		let store = this.getStore();
+		for (let id of this.#held) if (!this.#desired.has(id)) store.dropReference(id);
+		for (let id of this.#desired) if (!this.#held.has(id)) store.addReference(id);
+		this.#held = new Set(this.#desired);
+	}
+};
+var SearchResource = class extends Resource {
+	static {
+		decorateFieldV2(this.prototype, "network", [service]);
+	}
+	#network = (initializeDeferredDecorator(this, "network"), 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);
+	static {
+		decorateFieldV2(this.prototype, "loaderService", [service]);
+	}
+	#loaderService = (initializeDeferredDecorator(this, "loaderService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "realm", [service]);
+	}
+	#realm = (initializeDeferredDecorator(this, "realm"), void 0);
+	#storeServiceOverride;
+	static {
+		decorateFieldV2(this.prototype, "realmsToSearch", [tracked], function() {
+			return [];
+		});
+	}
+	#realmsToSearch = (initializeDeferredDecorator(this, "realmsToSearch"), void 0);
+	loaded;
+	subscriptions = [];
+	_instances = new TrackedArray();
+	static {
+		decorateFieldV2(this.prototype, "_meta", [tracked], function() {
+			return { page: { total: 0 } };
+		});
+	}
+	#_meta = (initializeDeferredDecorator(this, "_meta"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "answeredRealms", [tracked], function() {
+			return [];
+		});
+	}
+	#answeredRealms = (initializeDeferredDecorator(this, "answeredRealms"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "_errors", [tracked]);
+	}
+	#_errors = (initializeDeferredDecorator(this, "_errors"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "matchAPI", [tracked]);
+	}
+	#matchAPI = (initializeDeferredDecorator(this, "matchAPI"), void 0);
+	#matchAPILoading = false;
+	static {
+		decorateFieldV2(this.prototype, "canonicalizedFilter", [tracked]);
+	}
+	#canonicalizedFilter = (initializeDeferredDecorator(this, "canonicalizedFilter"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "activeQuery", [tracked]);
+	}
+	#activeQuery = (initializeDeferredDecorator(this, "activeQuery"), void 0);
+	#isLive = false;
+	#cardInitiated = false;
+	#throttled = false;
+	#searchEpoch = 0;
+	#getDefaultRealm;
+	#seedApplied = false;
+	#appliedSeedIdentity;
+	#resultGenerations = /* @__PURE__ */ new Map();
+	#pendingRefreshFloors = /* @__PURE__ */ new Map();
+	#refreshScheduler = new LiveSearchRefreshScheduler(() => this.#flushLiveRefresh());
+	#typeGate = new LiveSearchTypeGate({
+		anchors: () => this.#previousQuery === void 0 ? void 0 : wireFilterTypeAnchors(searchEntryWireQueryFromQuery(this.#previousQuery).filter),
+		loader: () => this.loaderService.loader,
+		virtualNetwork: () => this.network.virtualNetwork,
+		isDestroyed: () => isDestroyed(this),
+		correlatePrerenderHtml: true
+	});
+	static {
+		decorateFieldV2(this.prototype, "seedTotalUnknown", [tracked], function() {
+			return true;
+		});
+	}
+	#seedTotalUnknown = (initializeDeferredDecorator(this, "seedTotalUnknown"), void 0);
+	#doWhileRefreshing;
+	#previousQuery;
+	#previousQueryString;
+	#previousRealms;
+	#dependencyTracking;
+	#log = logger("search-resource");
+	#trackedLoadCount = 0;
+	#candidateRefs = new CandidateReferenceRetainer(() => this.runtimeStore, this);
+	get runtimeStore() {
+		return this.#storeServiceOverride ?? this.store;
+	}
+	loadMatchAPI() {
+		if (this.matchAPI || this.#matchAPILoading) return;
+		this.#matchAPILoading = true;
+		let token = waiter.beginAsync();
+		this.runtimeStore.getMatchAPI().then((api) => {
+			if (isDestroyed(this) || isDestroying(this)) return;
+			this.matchAPI = api;
+		}).catch((error) => {
+			this.#log.error("failed to load card-api for client-side filtering", error);
+		}).finally(() => {
+			this.#matchAPILoading = false;
+			waiter.endAsync(token);
+		});
+	}
+	loadCanonicalizedFilter(filter) {
+		if (!filter) {
+			this.canonicalizedFilter = void 0;
+			return;
+		}
+		if (this.canonicalizedFilter?.source === filter) return;
+		let token = waiter.beginAsync();
+		canonicalizeFilterRefs(filter, async (ref) => {
+			try {
+				let canonical = identifyCard((await this.loaderService.loader.import(ref.module))[ref.name]);
+				return canonical && isResolvedCodeRef(canonical) ? canonical : void 0;
+			} catch (error) {
+				this.#log.warn(`could not canonicalize filter ref ${ref.module}/${ref.name}: ${error}`);
+				return;
+			}
+		}).then(({ filter: canonical, incomplete }) => {
+			if (isDestroyed(this) || isDestroying(this)) return;
+			if (this.activeQuery?.filter !== filter) return;
+			this.canonicalizedFilter = {
+				source: filter,
+				filter: canonical,
+				incomplete
+			};
+		}).finally(() => {
+			waiter.endAsync(token);
+		});
+	}
+	trackStoreLoad(load, source) {
+		if (!load) return;
+		this.loaded = load;
+		let loadNumber = ++this.#trackedLoadCount;
+		this.#log.info(`trackStoreLoad start #${loadNumber} source=${source} query=${this.#previousQueryString ?? "(unknown)"}`);
+		this.runtimeStore.trackLoad(load);
+		let queryFieldName;
+		let consumerId;
+		let trackingSource;
+		let tracking = this.#dependencyTracking;
+		if (tracking && typeof tracking === "object") {
+			queryFieldName = typeof tracking.queryField === "string" ? tracking.queryField : void 0;
+			consumerId = typeof tracking.consumer === "string" ? tracking.consumer : void 0;
+			trackingSource = typeof tracking.source === "string" ? tracking.source : void 0;
+		}
+		this.runtimeStore.trackQueryLoad?.(load, {
+			source: `search-resource:${source}${trackingSource ? `:${trackingSource}` : ""}`,
+			query: this.#previousQuery,
+			realms: this.#previousRealms ?? this.realmsToSearch,
+			...consumerId ? { cardId: consumerId } : {},
+			...queryFieldName ? { fieldName: queryFieldName } : {}
+		});
+		load.finally(() => {
+			if (this.loaded !== load) return;
+			this.#log.info(`trackStoreLoad settled #${loadNumber} source=${source}`);
+		}).catch((error) => {
+			if (didCancel(error)) {
+				this.#log.debug(`trackStoreLoad canceled #${loadNumber} source=${source}`);
+				return;
+			}
+			this.#log.error(`trackStoreLoad rejected #${loadNumber} source=${source}`, error);
+		});
+	}
+	constructor(owner) {
+		super(owner);
+		registerDestructor(this, () => {
+			this.#refreshScheduler.cancel();
+			this.#typeGate.forget();
+			for (let instance of this._instances) this.runtimeStore.dropReference(instance.id);
+			for (let subscription of this.subscriptions) subscription.unsubscribe();
+		});
+	}
+	modify(_positional, named) {
+		let { query, realms, isLive, doWhileRefreshing, seed, owner, storeService, cardInitiated, throttled, getDefaultRealm } = named;
+		setOwner(this, owner);
+		if (storeService !== void 0) this.#storeServiceOverride = storeService;
+		if (cardInitiated !== void 0) this.#cardInitiated = cardInitiated;
+		if (throttled !== void 0) this.#throttled = throttled;
+		if (getDefaultRealm !== void 0) this.#getDefaultRealm = getDefaultRealm;
+		if (query === void 0) return;
+		this.#log.info(`modify: query present; isLive=${isLive}; realms=${realms?.join(",") ?? "(default)"}`);
+		this.#isLive = isLive;
+		if (isLive) {
+			this.loadMatchAPI();
+			this.loadCanonicalizedFilter(query.filter);
+		}
+		this.activeQuery = query;
+		this.#doWhileRefreshing = doWhileRefreshing;
+		this.#dependencyTracking = named.dependencyTracking;
+		this.realmsToSearch = realms !== void 0 && realms.length > 0 ? realms.map(ri) : this.#cardInitiated ? this.#currentRealmList() : this.realmServer.availableRealmIdentifiers;
+		this.#log.info(`modify: prepared realms for subscription=${this.realmsToSearch.join(",")}`);
+		if (seed && !this.#seedApplied) {
+			this.#appliedSeedIdentity = seed.identity;
+			this.#raiseResultGeneration(seed.realm, seed.generation);
+			this.trackStoreLoad(this.applySeed.perform(seed), "seed");
+			this.#seedApplied = true;
+			let hasQueryErrors = seed.queryErrors && seed.queryErrors.length > 0;
+			if (seed.searchURL && !hasQueryErrors) {
+				let { query: seedQuery } = parseSearchURL(seed.searchURL);
+				this.#previousQueryString = this.querySignature(seedQuery);
+			}
+			this.#adoptQuery(query);
+			if (seed.realms) this.#previousRealms = seed.realms;
+			this.#log.info(`apply seed for search resource (one-time); count=${seed.cards.length}; searchURL=${seed.searchURL}`);
+			let seedIsAuthoritative = seed.cards.length > 0 || seed.cardURLs !== void 0 || Boolean(seed.searchURL);
+			if (!isLive && seedIsAuthoritative) {
+				this.#previousRealms = realms;
+				this.#adoptQuery(query);
+				this.#previousQueryString = this.querySignature(query);
+				return;
+			}
+		}
+		if (isLive && (this.subscriptions.length === 0 || !isEqual(realms, this.#previousRealms))) {
+			this.#log.info(`subscribing to realms for search resource; realms=${this.realmsToSearch.join(",")}`);
+			for (let subscription of this.subscriptions) subscription.unsubscribe();
+			this.subscriptions = this.realmsToSearch.map((realm) => {
+				this.#log.info(`search-resource calling subscribeToRealm for ${realm}`);
+				return {
+					url: `${realm}_message`,
+					unsubscribe: subscribeToRealm(realm, (event) => {
+						this.#log.info(`search-resource received realm event on ${realm}: ${JSON.stringify(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;
+						let generation = "generation" in event && typeof event.generation === "number" ? event.generation : void 0;
+						if (generation !== void 0) {
+							let current = this.#pendingRefreshFloors.get(realm);
+							if (current === void 0 || generation > current) this.#pendingRefreshFloors.set(realm, generation);
+						}
+						if (isIncrementalIndex) {
+							if (this.#typeGate.indexEventCannotMatch(event)) {
+								this.#log.info(`incremental index event on ${realm} touched no type this query is anchored on; skipping refresh`);
+								return;
+							}
+						} else if (this.#typeGate.prerenderEventCannotMatch(event)) {
+							this.#log.info(`prerender_html event on ${realm} re-rendered no row of a type this query is anchored on; skipping refresh`);
+							return;
+						}
+						this.#refreshScheduler.schedule();
+					})
+				};
+			});
+		}
+		let queryString = this.querySignature(query);
+		if (isEqual(queryString, this.#previousQueryString) && isEqual(realms, this.#previousRealms)) {
+			this.#log.info(`skip search perform as query and realms have not changed; query=${queryString}; realms=${this.realmsToSearch.join(",")}`);
+			return;
+		}
+		this.#previousRealms = realms;
+		this.#adoptQuery(query);
+		this.#previousQueryString = queryString;
+		this.#refreshScheduler.cancel();
+		let floors = new Map([...this.#pendingRefreshFloors].filter(([realm]) => this.realmsToSearch.includes(realm)));
+		this.#pendingRefreshFloors = /* @__PURE__ */ new Map();
+		this.trackStoreLoad(this.search.perform(query, floors), "search");
+	}
+	#adoptQuery(query) {
+		this.#previousQuery = structuredClone(query);
+		this.#typeGate.forget();
+	}
+	querySignature(query) {
+		return canonicalQuerySignature(query, this.network.virtualNetwork);
+	}
+	reseed(seed) {
+		if (seed.identity && seed.identity === this.#appliedSeedIdentity) return;
+		let seedFloor = seed.realm != null ? this.#resultGenerations.get(this.#generationKey(seed.realm)) : void 0;
+		if (seed.generation != null && seedFloor != null && seed.generation < seedFloor) {
+			this.#log.info(`decline seed from generation ${seed.generation}; holding generation ${seedFloor} for realm ${seed.realm}`);
+			return;
+		}
+		this.#appliedSeedIdentity = seed.identity;
+		this.#raiseResultGeneration(seed.realm, seed.generation);
+		this.trackStoreLoad(this.applySeed.perform(seed), "seed");
+		let hasQueryErrors = seed.queryErrors && seed.queryErrors.length > 0;
+		if (seed.searchURL && !hasQueryErrors) {
+			let { query: seedQuery } = parseSearchURL(seed.searchURL);
+			this.#previousQueryString = this.querySignature(seedQuery);
+		}
+		if (seed.realms) this.#previousRealms = seed.realms;
+		if (this.#isLive && hasQueryErrors && this.#previousQuery) this.trackStoreLoad(this.search.perform(this.#previousQuery), "search");
+	}
+	get appliedSeedIdentity() {
+		return this.#appliedSeedIdentity;
+	}
+	#raiseResultGeneration(realm, generation) {
+		if (realm == null || generation == null) return;
+		let key = this.#generationKey(realm);
+		let current = this.#resultGenerations.get(key);
+		if (current == null || generation > current) this.#resultGenerations.set(key, generation);
+	}
+	#generationKey(realm) {
+		return canonicalRealmIdentifier(this.network.virtualNetwork, realm);
+	}
+	get isLoading() {
+		return this.search.isRunning || this.applySeed.isRunning;
+	}
+	get isLive() {
+		return this.#isLive;
+	}
+	get instances() {
+		return this.displayedInstances;
+	}
+	get displayedInstances() {
+		let serverInstances = this._instances;
+		if (!this.isClientFilterEligible) {
+			this.#candidateRefs.retain([]);
+			return serverInstances;
+		}
+		let api = this.matchAPI;
+		let filter = this.canonicalizedFilter?.filter ?? this.activeQuery?.filter;
+		this.runtimeStore.instanceMutationVersion;
+		let localMatch = (instance) => filter ? matchInstanceAgainstFilter(instance, filter, api) : "match";
+		let serverResults = serverInstances;
+		let kept = serverResults.filter((instance) => localMatch(instance) !== "no-match");
+		let serverIds = new Set(serverResults.map((instance) => instance.id).filter(Boolean));
+		let filterRef = filter;
+		let candidatePool = (isFileDefCodeRef(filterRef?.on ?? filterRef?.type, api.virtualNetwork) ? true : serverResults.length > 0 && isFileDefInstance(serverResults[0])) ? this.runtimeStore.allFileMetaInstances() : this.runtimeStore.allCardInstances();
+		let { virtualNetwork } = this.network;
+		let added = candidatePool.filter((instance) => {
+			if (instance.id == null || serverIds.has(instance.id)) return false;
+			let id = rri(virtualNetwork.unresolveURL(instance.id));
+			return this.isInTargetRealm(id) && this.mayWidenInto(id) && localMatch(instance) === "match";
+		});
+		this.#candidateRefs.retain(added.map((instance) => instance.id).filter(Boolean));
+		let seenIds = /* @__PURE__ */ new Set();
+		let merged = [];
+		for (let instance of [...kept, ...added]) {
+			let id = instance.id;
+			if (id != null) {
+				if (seenIds.has(id)) continue;
+				seenIds.add(id);
+			}
+			merged.push(instance);
+		}
+		let comparator = makeInstanceComparator(this.activeQuery?.sort, api);
+		merged.sort((a, b) => comparator(a, b));
+		return merged;
+	}
+	static {
+		decorateMethodV2(this.prototype, "displayedInstances", [cached]);
+	}
+	get isClientFilterEligible() {
+		if (!this.#isLive) return false;
+		if (!this.matchAPI) return false;
+		let total = this._meta?.page?.total;
+		if (total == null || this._instances.length !== total) return false;
+		let filter = this.activeQuery?.filter;
+		if (filter && !isClientEvaluable(filter)) return false;
+		if (filter) {
+			let canonicalized = this.canonicalizedFilter;
+			if (!canonicalized || canonicalized.source !== filter || canonicalized.incomplete) return false;
+		}
+		return true;
+	}
+	mayWidenInto(id) {
+		if (this.answeredRealms.some((realm) => realm.inRealm(id))) return !this.policyScopedRealms.some((realm) => realm.inRealm(id));
+		let target = this.targetRealms.find(({ paths }) => paths.inRealm(id));
+		return target !== void 0 && this.realm.canRead(target.realm);
+	}
+	get targetRealms() {
+		let { virtualNetwork } = this.network;
+		return this.realmsToSearch.map((realm) => ({
+			realm,
+			paths: new RealmPaths(canonicalRealmIdentifier(virtualNetwork, realm))
+		}));
+	}
+	static {
+		decorateMethodV2(this.prototype, "targetRealms", [cached]);
+	}
+	get policyScopedRealms() {
+		let { virtualNetwork } = this.network;
+		return (this._meta?.policyScopedRealms ?? []).map((realm) => new RealmPaths(canonicalRealmIdentifier(virtualNetwork, realm)));
+	}
+	static {
+		decorateMethodV2(this.prototype, "policyScopedRealms", [cached]);
+	}
+	isInTargetRealm(id) {
+		return this.targetRealms.some(({ paths }) => paths.inRealm(id));
+	}
+	get instancesByRealm() {
+		let { virtualNetwork } = this.network;
+		let ids = this.instances.map((card) => card.id == null ? void 0 : rri(virtualNetwork.unresolveURL(card.id)));
+		return this.targetRealms.map(({ realm, paths }) => ({
+			realm,
+			cards: this.instances.filter((_card, i) => {
+				let id = ids[i];
+				return id !== void 0 && paths.inRealm(id);
+			})
+		})).filter((r) => r.cards.length > 0);
+	}
+	static {
+		decorateMethodV2(this.prototype, "instancesByRealm", [cached]);
+	}
+	get meta() {
+		return this._meta;
+	}
+	static {
+		decorateMethodV2(this.prototype, "meta", [cached]);
+	}
+	get errors() {
+		return this._errors;
+	}
+	static {
+		decorateMethodV2(this.prototype, "errors", [cached]);
+	}
+	get totalMatchCount() {
+		if (this.seedTotalUnknown) return;
+		let total = this._meta?.page?.total;
+		return typeof total === "number" ? total : void 0;
+	}
+	static {
+		decorateMethodV2(this.prototype, "totalMatchCount", [cached]);
+	}
+	get isPartial() {
+		let total = this.totalMatchCount;
+		return total != null && total > this._instances.length;
+	}
+	static {
+		decorateMethodV2(this.prototype, "isPartial", [cached]);
+	}
+	async updateInstances(newInstances, dependencyTrackingContext) {
+		let oldReferences = this._instances.map((i) => i.id);
+		this._instances.splice(0, this._instances.length, ...newInstances);
+		if (this.#doWhileRefreshing) this.#doWhileRefreshing();
+		let newReferences = this._instances.map((i) => i.id);
+		for (let card of this._instances) {
+			let isFileMeta = isFileDefInstance(card);
+			if (!(card?.id ? isFileMeta ? this.runtimeStore.peek(card.id, { type: "file-meta" }) : this.runtimeStore.peek(card.id) : void 0) && card?.type !== "not-loaded") if (isFileMeta) await this.runtimeStore.get(card.id, {
+				type: "file-meta",
+				dependencyTrackingContext
+			});
+			else await this.runtimeStore.addWithoutPersisting(card, { dependencyTrackingContext });
+		}
+		let referencesToDrop = difference(oldReferences, newReferences);
+		for (let id of referencesToDrop) this.runtimeStore.dropReference(id);
+		let referencesToAdd = difference(newReferences, oldReferences);
+		for (let id of referencesToAdd) this.runtimeStore.addReference(id);
+		return this.runtimeStore.flush();
+	}
+	dependencyTrackingContext(source) {
+		return runtimeDependencyContextWithSource(this.#dependencyTracking, source);
+	}
+	#currentRealmList() {
+		let current = this.#getDefaultRealm?.();
+		return current ? [ri(current)] : [];
+	}
+	applySeed = buildTask(() => ({
+		context: this,
+		generator: function* (seed) {
+			let dependencyTrackingContext = this.dependencyTrackingContext("search-resource:applySeed");
+			yield Promise.resolve();
+			let cards = seed.cards;
+			if (cards.length === 0 && seed.cardURLs && seed.cardURLs.length > 0) cards = (yield Promise.all(seed.cardURLs.map(async (url) => {
+				try {
+					return await this.runtimeStore.get(url, { dependencyTrackingContext });
+				} catch (err) {
+					console.warn(`SearchResource: failed to load seed cardURL ${url}`, err);
+					return;
+				}
+			}))).filter((r) => {
+				if (r == null) return false;
+				return r?.type !== "card-error";
+			});
+			if (seed.identity !== this.#appliedSeedIdentity) {
+				this.#log.info(`abandon seed superseded while resolving; searchURL=${seed.searchURL}`);
+				return;
+			}
+			this.seedTotalUnknown = Boolean(seed.totalUnknown);
+			this._meta = seed.meta ?? { page: { total: cards.length } };
+			this.answeredRealms = [];
+			this._errors = seed.errors;
+			yield this.updateInstances(cards, dependencyTrackingContext);
+		}
+	}), null, "applySeed", null);
+	#flushLiveRefresh() {
+		if (isDestroyed(this) || isDestroying(this) || this.#previousQuery === void 0) return;
+		let floors = this.#pendingRefreshFloors;
+		this.#pendingRefreshFloors = /* @__PURE__ */ new Map();
+		this.trackStoreLoad(this.search.perform(this.#previousQuery, floors), "live-refresh");
+	}
+	search = buildTask(() => ({
+		context: this,
+		generator: function* (query, refreshFloors) {
+			let epoch = ++this.#searchEpoch;
+			this.#log.info(`search task start; realms=${this.realmsToSearch.join(",")}; query=${JSON.stringify(query)}`);
+			let token = waiter.beginAsync();
+			try {
+				let dependencyTrackingContext = this.dependencyTrackingContext("search-resource:search");
+				try {
+					let realms = this.realmsToSearch;
+					let { instances, meta } = yield this.runtimeStore.searchWithMeta(query, realms, {
+						dependencyTrackingContext,
+						cardInitiated: this.#cardInitiated,
+						throttled: this.#throttled,
+						isObsolete: () => this.#searchEpoch !== epoch || isDestroyed(this) || isDestroying(this)
+					});
+					this.#log.info(`search task complete; total instances=${instances.length}; refs=${instances.map((r) => r.id).join(",")}`);
+					this.seedTotalUnknown = false;
+					this.#appliedSeedIdentity = void 0;
+					for (let [realm, generation] of refreshFloors ?? []) this.#raiseResultGeneration(realm, generation);
+					this._meta = meta;
+					let { virtualNetwork } = this.network;
+					this.answeredRealms = realms.map((realm) => new RealmPaths(canonicalRealmIdentifier(virtualNetwork, realm)));
+					this._errors = void 0;
+					yield this.updateInstances(instances, dependencyTrackingContext);
+				} catch (err) {
+					if (didCancel(err)) throw err;
+					this.#log.error(`search task failed`, err);
+					this._errors = [searchErrorEntry(err)];
+					this.seedTotalUnknown = true;
+					this._meta = {
+						page: { total: 0 },
+						incomplete: true
+					};
+					this.answeredRealms = [];
+					if (this._instances.length > 0) try {
+						yield this.updateInstances([], dependencyTrackingContext);
+					} catch (cleanupErr) {
+						if (didCancel(cleanupErr)) throw cleanupErr;
+						this.#log.error(`search cleanup failed`, cleanupErr);
+					}
+				}
+			} finally {
+				waiter.endAsync(token);
+			}
+		}
+	}), null, "search", "restartable");
+};
+function getSearch(parent, owner, getQuery, getRealms, opts) {
+	return SearchResource.from(parent, () => ({ named: {
+		query: getQuery(),
+		realms: getRealms ? getRealms() : void 0,
+		isLive: opts?.isLive != null ? opts.isLive : false,
+		storeService: opts?.storeService,
+		cardInitiated: opts?.cardInitiated,
+		throttled: opts?.throttled,
+		getDefaultRealm: opts?.getDefaultRealm,
+		doWhileRefreshing: opts?.doWhileRefreshing,
+		seed: opts?.seed,
+		dependencyTracking: opts?.dependencyTracking,
+		owner
+	} }));
+}
+//#endregion
+export { getSearch as n, search_exports as r, SearchResource as t };