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

package/bundled-test-harness/assets/store-BV6WX8oV.js

@@ -0,0 +1,2205 @@
+import { r as __exportAll } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { $o as isFileMetaResource, Ao as humanReadable, Cn as X_BOXEL_CONSUMING_REALM_HEADER, En as X_BOXEL_LOGGING_CORRELATION_ID_HEADER, Jt as mergeRelationships, Po as isCardInstance, Qa as clearReplacedArrayFieldMeta, Ro as isFileDefInstance, Sc as Deferred, Sn as X_BOXEL_LINK_SHAPE_HEADER, Tn as X_BOXEL_JOB_PRIORITY_HEADER, Vr as delay, Wo as loadCardDef, Yo as hasWithheldRelationships, _i as isEntrySingleDocument, ai as SEARCH_CONCURRENCY_CAP, as as isSparseItemResource, bc as stringifyErrorForLog, ci as assertRealmsBound, d as isLocalId, do as isJsonContentType, fc as formattedError, gi as isEntryCollectionDocument, ii as QUERY_FIELD_SEARCH_CONCURRENCY_CAP, in as formatDistanceToNow, is as isSingleCardDocument, ka as resolveFileDefCodeRef, l as hasExecutableExtension, mc as isCardError, ms as logger, na as searchEntryWireQueryFromQuery, si as applySearchPageBound, st as DURING_PRERENDER_HEADER, uc as CardError, uo as SupportedMimeType, ut as SKIP_INDEX_WAIT_HEADER, vi as isSingleFileMetaDocument, wn as X_BOXEL_JOB_ID_HEADER, yt as getTypeRefsFromFilter } from "./runtime-common-ClpqhbwG.js";
+import { a as RealmPaths, v as ri, y as rri } from "./paths-BYHDgqsT.js";
+import { B as cloneDeep, I as mergeWith, S as isEqual, _ as merge } from "./lodash-DnaZ_rzx.js";
+import { K as realmURL, T as baseFileRef, U as meta, V as localId, k as baseRef } from "./constants-CqKWhRfY.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, t as Service } from "./service-LFpJ8EEP.js";
+import { n as registerDestructor } from "./destroyable-mdLYRn_o.js";
+import { t as isTesting } from "./runtime-9O0mNd7j.js";
+import { l as didCancel, n as buildTask } from "./async-arrow-runtime-STsj7E8Y.js";
+import { a as TrackedMap, i as TrackedSet, n as TrackedObject } from "./dist-B9tGPKZz.js";
+import { n as tracked } from "./tracking-800VJb8b.js";
+import { r as timeout } from "./dist-DEVZvbin.js";
+import { t as buildWaiter } from "./dist-CSQ-y1Ft.js";
+import { n as canonicalRealmIdentifiers, r as dedupeRealmsByIdentity, t as canonicalRealmIdentifier } from "./realm-utils-K-gQ_i6s.js";
+import { n as getSearch } from "./search-BkQYpQDY.js";
+import { r as enableRenderTimerStub, s as withTimersBlocked } from "./render-timer-stub-CMPEUlSe.js";
+import { n as currentRenderScope, r as getDeps, t as CardStoreWithGarbageCollection } from "./gc-card-store-eg5fHk_x.js";
+import { t as searchCacheKey } from "./search-cache-key-DEGjyFzB.js";
+import { t as searchInFlightKey } from "./search-in-flight-key-B6C50Coa.js";
+import { t as errorJsonApiToErrorEntry } from "./window-error-handler-DV_GtWRW.js";
+import { t as FileDefAttributesExtractor } from "./file-def-attributes-extractor-B3vn2V7A.js";
+//#region app/lib/prerender-fetch-headers.ts
+function duringPrerenderHeaders() {
+	return globalThis.__boxelRenderContext === true ? { [DURING_PRERENDER_HEADER]: "1" } : {};
+}
+function headlessCommandWriteHeaders() {
+	return globalThis.__boxelHeadlessCommand === true ? { [DURING_PRERENDER_HEADER]: "1" } : {};
+}
+function consumingRealmHeader() {
+	let r = globalThis.__boxelConsumingRealm;
+	return r ? { [X_BOXEL_CONSUMING_REALM_HEADER]: r } : {};
+}
+function jobIdHeader() {
+	let j = globalThis.__boxelJobId;
+	return j ? { [X_BOXEL_JOB_ID_HEADER]: j } : {};
+}
+function loggingCorrelationIdHeader() {
+	if (globalThis.__boxelRenderContext !== true) return {};
+	return { [X_BOXEL_LOGGING_CORRELATION_ID_HEADER]: newCorrelationId() };
+}
+function newCorrelationId() {
+	let c = globalThis.crypto;
+	if (c?.randomUUID) return c.randomUUID();
+	return `r-${Date.now().toString(36)}-${Math.floor(Math.random() * 1e9).toString(36)}`;
+}
+//#endregion
+//#region app/services/store.ts
+var store_exports = /* @__PURE__ */ __exportAll({
+	asURL: () => asURL,
+	default: () => StoreService,
+	resolveOutboundJobPriority: () => resolveOutboundJobPriority
+});
+var waiter = buildWaiter("store-service");
+var realmEventsLogger = logger("realm:events");
+var storeLogger = logger("store");
+function resolveOutboundJobPriority({ duringPrerender, jobPriority }) {
+	let valid = typeof jobPriority === "number" && Number.isSafeInteger(jobPriority) && jobPriority >= 0 ? jobPriority : void 0;
+	if (duringPrerender === true) return valid ?? 0;
+	return valid ?? 10;
+}
+function isInstanceWriteRequestId(clientRequestId) {
+	return clientRequestId.startsWith("instance:") || clientRequestId.startsWith("editor-with-instance");
+}
+function jobPriorityHeader() {
+	let g = globalThis;
+	return { [X_BOXEL_JOB_PRIORITY_HEADER]: String(resolveOutboundJobPriority({
+		duringPrerender: g.__boxelRenderContext,
+		jobPriority: g.__boxelJobPriority
+	})) };
+}
+var queryFieldSeedFromSearchSymbol = Symbol.for("cardstack-query-field-seed-from-search");
+var KEEPALIVE_BODY_LIMIT = 64 * 1024;
+var MAX_SHED_SEARCH_RETRIES = 3;
+var MAX_SHED_RETRY_AFTER_SECONDS = 5;
+var CARD_FACING_STORE_METHODS = new Set([
+	"save",
+	"create",
+	"add",
+	"addWithoutPersisting",
+	"addWithoutWaiting",
+	"peek",
+	"peekError",
+	"get",
+	"delete",
+	"patch",
+	"search",
+	"getSaveState"
+]);
+function shedRetryDelayMs(retryAfter) {
+	let seconds = Number(retryAfter);
+	if (!Number.isFinite(seconds) || seconds < 0) seconds = 1;
+	seconds = Math.min(seconds, MAX_SHED_RETRY_AFTER_SECONDS);
+	return seconds * 1e3 + Math.random() * 250;
+}
+var StoreService = class extends Service {
+	static {
+		decorateFieldV2(this.prototype, "realm", [service]);
+	}
+	#realm = (initializeDeferredDecorator(this, "realm"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "loaderService", [service]);
+	}
+	#loaderService = (initializeDeferredDecorator(this, "loaderService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "messageService", [service]);
+	}
+	#messageService = (initializeDeferredDecorator(this, "messageService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "cardService", [service]);
+	}
+	#cardService = (initializeDeferredDecorator(this, "cardService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "toolService", [service]);
+	}
+	#toolService = (initializeDeferredDecorator(this, "toolService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "hostModeService", [service]);
+	}
+	#hostModeService = (initializeDeferredDecorator(this, "hostModeService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "network", [service]);
+	}
+	#network = (initializeDeferredDecorator(this, "network"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "environmentService", [service]);
+	}
+	#environmentService = (initializeDeferredDecorator(this, "environmentService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "session", [service]);
+	}
+	#session = (initializeDeferredDecorator(this, "session"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "operatorModeStateService", [service]);
+	}
+	#operatorModeStateService = (initializeDeferredDecorator(this, "operatorModeStateService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "realmServer", [service]);
+	}
+	#realmServer = (initializeDeferredDecorator(this, "realmServer"), void 0);
+	subscriptions = /* @__PURE__ */ new Map();
+	cardInvalidationSubscribers = /* @__PURE__ */ new Map();
+	cardReloadSubscribers = /* @__PURE__ */ new Set();
+	referenceCount = /* @__PURE__ */ new Map();
+	newReferencePromises = [];
+	autoSaveStates = new TrackedMap();
+	fileReadIds = new TrackedSet();
+	static {
+		decorateFieldV2(this.prototype, "_instanceMutationVersion", [tracked], function() {
+			return 0;
+		});
+	}
+	#_instanceMutationVersion = (initializeDeferredDecorator(this, "_instanceMutationVersion"), void 0);
+	cardApiCache;
+	gcInterval;
+	ready;
+	inflightGetCards = /* @__PURE__ */ new Map();
+	inflightGetFileMeta = /* @__PURE__ */ new Map();
+	inflightCardMutations = /* @__PURE__ */ new Map();
+	inflightCardCreates = /* @__PURE__ */ new Map();
+	inflightCardLoads = /* @__PURE__ */ new Map();
+	#reloadTargets = /* @__PURE__ */ new Map();
+	#localEdits = /* @__PURE__ */ new WeakMap();
+	#localEditSeq = 0;
+	#optimisticFields = /* @__PURE__ */ new Map();
+	inflightSearch = /* @__PURE__ */ new Map();
+	searchCache = /* @__PURE__ */ new Map();
+	searchCacheScope = void 0;
+	searchCacheGeneration = 0;
+	store;
+	#identityEpoch = 0;
+	isRenderStore = false;
+	onSaveSubscriber;
+	#pendingAutoSaves = /* @__PURE__ */ new Map();
+	autoSavePromises = /* @__PURE__ */ new Map();
+	#autoSaveHolds = /* @__PURE__ */ new Map();
+	#teardownAfterSave = /* @__PURE__ */ new Set();
+	#sessionEpoch = 0;
+	#keepaliveBytesInFlight = 0;
+	constructor(owner) {
+		super(owner);
+		this.store = this.createCardStore();
+		this.session.register(this);
+		this.ready = this.setup();
+		let removePageListeners = this.#listenForLeavingThePage();
+		registerDestructor(this, () => {
+			clearInterval(this.gcInterval);
+			removePageListeners();
+			this.#dropPendingAutoSaves();
+		});
+	}
+	#listenForLeavingThePage() {
+		if (typeof document === "undefined" || typeof window === "undefined") return () => {};
+		let onFocusOut = () => this.#sendPendingAutoSaves();
+		let onVisibilityChange = () => {
+			if (document.visibilityState === "hidden") this.#sendPendingAutoSaves({ keepalive: true });
+		};
+		let onPageHide = () => this.#sendPendingAutoSaves({ keepalive: true });
+		document.addEventListener("focusout", onFocusOut);
+		document.addEventListener("visibilitychange", onVisibilityChange);
+		window.addEventListener("pagehide", onPageHide);
+		return () => {
+			document.removeEventListener("focusout", onFocusOut);
+			document.removeEventListener("visibilitychange", onVisibilityChange);
+			window.removeEventListener("pagehide", onPageHide);
+		};
+	}
+	renderContextBlocksPersistence() {
+		if (globalThis.__boxelPrerenderApp) return true;
+		return this.isRenderStore && Boolean(globalThis.__boxelRenderContext);
+	}
+	_onSave(subscriber) {
+		this.onSaveSubscriber = subscriber;
+		this.cardService._onSave(subscriber);
+	}
+	_unregisterSaveSubscriber() {
+		this.onSaveSubscriber = void 0;
+		this.cardService._unregisterSaveSubscriber();
+	}
+	resetState() {
+		this.#sessionEpoch++;
+		this.#dropPendingAutoSaves();
+		clearInterval(this.gcInterval);
+		this.subscriptions = /* @__PURE__ */ new Map();
+		this.cardInvalidationSubscribers = /* @__PURE__ */ new Map();
+		this.cardReloadSubscribers = /* @__PURE__ */ new Set();
+		this.onSaveSubscriber = void 0;
+		this.referenceCount = /* @__PURE__ */ new Map();
+		this.#autoSaveHolds = /* @__PURE__ */ new Map();
+		this.#teardownAfterSave = /* @__PURE__ */ new Set();
+		this.newReferencePromises = [];
+		this.autoSaveStates = new TrackedMap();
+		this.fileReadIds.clear();
+		this.inflightGetCards = /* @__PURE__ */ new Map();
+		this.inflightGetFileMeta = /* @__PURE__ */ new Map();
+		this.inflightCardMutations = /* @__PURE__ */ new Map();
+		this.inflightCardCreates = /* @__PURE__ */ new Map();
+		this.inflightCardLoads = /* @__PURE__ */ new Map();
+		this.#reloadTargets = /* @__PURE__ */ new Map();
+		this.inflightSearch = /* @__PURE__ */ new Map();
+		this.searchCache = /* @__PURE__ */ new Map();
+		this.searchCacheScope = void 0;
+		this.searchCacheGeneration++;
+		this.store = this.createCardStore();
+		this.ready = this.setup();
+	}
+	async ensureSetupComplete() {
+		await this.ready;
+	}
+	clearInFlightSearch() {
+		this.inflightSearch.clear();
+	}
+	observeIndexingJob() {
+		if (!this.store.observeIndexingJob()) return;
+		this.inflightGetCards = /* @__PURE__ */ new Map();
+		this.inflightGetFileMeta = /* @__PURE__ */ new Map();
+		this.inflightCardLoads = /* @__PURE__ */ new Map();
+		this.#reloadTargets = /* @__PURE__ */ new Map();
+		this.inflightSearch = /* @__PURE__ */ new Map();
+	}
+	clearSearchCache() {
+		this.searchCache.clear();
+		this.searchCacheScope = void 0;
+		this.searchCacheGeneration++;
+	}
+	resetCache(opts) {
+		storeLogger.info(`resetting store cache; leaving identity epoch #${this.#identityEpoch}`);
+		this.#sendPendingAutoSaves();
+		if (!opts?.preserveReferences) {
+			this.referenceCount = /* @__PURE__ */ new Map();
+			this.#autoSaveHolds = /* @__PURE__ */ new Map();
+			this.#teardownAfterSave = /* @__PURE__ */ new Set();
+		}
+		this.cardApiCache = void 0;
+		this.autoSaveStates = new TrackedMap();
+		this.fileReadIds.clear();
+		this.newReferencePromises = [];
+		this.inflightGetCards = /* @__PURE__ */ new Map();
+		this.inflightGetFileMeta = /* @__PURE__ */ new Map();
+		this.inflightCardMutations = /* @__PURE__ */ new Map();
+		this.inflightCardCreates = /* @__PURE__ */ new Map();
+		this.inflightCardLoads = /* @__PURE__ */ new Map();
+		this.#reloadTargets = /* @__PURE__ */ new Map();
+		this.inflightSearch = /* @__PURE__ */ new Map();
+		this.searchCache = /* @__PURE__ */ new Map();
+		this.searchCacheScope = void 0;
+		this.searchCacheGeneration++;
+		this.store = this.createCardStore();
+	}
+	#resetIdentityInPlace() {
+		this.#identityEpoch++;
+		this.store.reset();
+	}
+	refreshReferencesForCodeChange(reason, opts) {
+		let reasonSuffix = reason ? ` (${reason})` : "";
+		storeLogger.debug(`resetting store for code change${reasonSuffix}`);
+		let telemetry = this.#clientTelemetry();
+		let start = telemetry?.isEnabled ? performance.now() : void 0;
+		this.#resetIdentityInPlace();
+		let refetch = this.reestablishReferences.perform();
+		if (telemetry?.isEnabled && start !== void 0) {
+			let triggerModules = opts?.triggerModule ? [opts.triggerModule] : [];
+			let report = (cardsReloaded) => telemetry.recordEvent({
+				event_type: "rebuild",
+				rebuild_source: "write",
+				realm: opts?.realm ?? null,
+				duration_ms: Math.round(performance.now() - start),
+				trigger_modules: triggerModules,
+				trigger_module: triggerModules[0] ?? "",
+				modules_refetched: 0,
+				cards_reloaded: cardsReloaded,
+				coalesced_events: 0
+			});
+			refetch.then((cardsReloaded) => report(cardsReloaded ?? 0), (e) => {
+				if (didCancel(e)) return;
+				report(0);
+				throw e;
+			});
+		}
+	}
+	subscribeToCardInvalidation(id, cb) {
+		let normalizedId = asURL(id, this.network.virtualNetwork);
+		let subscribers = this.cardInvalidationSubscribers.get(normalizedId);
+		if (!subscribers) {
+			subscribers = /* @__PURE__ */ new Set();
+			this.cardInvalidationSubscribers.set(normalizedId, subscribers);
+		}
+		subscribers.add(cb);
+		return () => {
+			let current = this.cardInvalidationSubscribers.get(normalizedId);
+			if (!current) return;
+			current.delete(cb);
+			if (current.size === 0) this.cardInvalidationSubscribers.delete(normalizedId);
+		};
+	}
+	notifyCardInvalidationSubscribers(id) {
+		let normalizedId = asURL(id, this.network.virtualNetwork);
+		let subscribers = this.cardInvalidationSubscribers.get(normalizedId);
+		if (!subscribers) return;
+		for (let cb of [...subscribers]) try {
+			let maybePromise = cb();
+			if (maybePromise && typeof maybePromise.then === "function") maybePromise.catch((err) => console.error(`card invalidation subscriber for ${normalizedId} rejected`, err));
+		} catch (err) {
+			console.error(`card invalidation subscriber for ${normalizedId} threw`, err);
+		}
+	}
+	dropReference(id) {
+		if (!id) return;
+		id = asURL(id, this.network.virtualNetwork);
+		let currentReferenceCount = this.referenceCount.get(id) ?? 0;
+		currentReferenceCount -= 1;
+		this.referenceCount.set(id, currentReferenceCount);
+		storeLogger.debug(`dropping reference to ${id}, current reference count: ${this.referenceCount.get(id)}`);
+		let autoSaveHolds = this.#autoSaveHolds.get(id) ?? 0;
+		if (autoSaveHolds > 0 && currentReferenceCount <= autoSaveHolds) {
+			this.#teardownAfterSave.add(id);
+			for (let [localId, pending] of this.#pendingAutoSaves) if (pending.holdKey === id) this.#sendAutoSave(localId);
+		}
+		if (currentReferenceCount <= 0) {
+			if (currentReferenceCount < 0) {
+				let message = `current reference count for ${id} is negative: ${this.referenceCount.get(id)}`;
+				storeLogger.error(message);
+				console.trace(message);
+			}
+			this.referenceCount.delete(id);
+			this.autoSaveStates.delete(id);
+			this.unsubscribeFromInstance(id);
+		}
+	}
+	addReference(id, opts) {
+		if (!id) return;
+		id = asURL(id, this.network.virtualNetwork);
+		let readType = opts?.type ?? "card";
+		let currentReferenceCount = this.referenceCount.get(id) ?? 0;
+		currentReferenceCount += 1;
+		this.referenceCount.set(id, currentReferenceCount);
+		storeLogger.debug(`adding reference to ${id}, current reference count: ${this.referenceCount.get(id)}`);
+		if (isLocalId(id)) {
+			let instanceOrError = this.peek(id);
+			if (instanceOrError) {
+				let realmURL$1 = isCardInstance(instanceOrError) ? instanceOrError[realmURL]?.href : instanceOrError.realm;
+				if (realmURL$1) this.subscribeToRealm(new URL(realmURL$1));
+			}
+		} else {
+			this.subscribeToRealm(rri(id));
+			this.wireUpNewReference(id, readType);
+		}
+	}
+	loaded() {
+		return this.store.loaded();
+	}
+	get loadGeneration() {
+		return this.store.loadGeneration;
+	}
+	trackLoad(load) {
+		this.store.trackLoad(load);
+	}
+	trackQueryLoad(load, meta) {
+		return this.store.trackQueryLoad?.(load, meta);
+	}
+	queryLoadsInFlight() {
+		return this.store.queryLoadsInFlight?.() ?? [];
+	}
+	cardDocLoadsInFlight() {
+		return this.store.cardDocLoadsInFlight?.() ?? [];
+	}
+	fileMetaDocLoadsInFlight() {
+		return this.store.fileMetaDocLoadsInFlight?.() ?? [];
+	}
+	recentCardDocLoads() {
+		return this.store.recentCardDocLoads?.() ?? [];
+	}
+	recentFileMetaLoads() {
+		return this.store.recentFileMetaLoads?.() ?? [];
+	}
+	recentQueryLoads() {
+		return this.store.recentQueryLoads?.() ?? [];
+	}
+	get cardDocsInFlight() {
+		return this.store.cardDocsInFlight;
+	}
+	get fileMetaDocsInFlight() {
+		return this.store.fileMetaDocsInFlight;
+	}
+	async create(doc, opts) {
+		let adoptsFrom = doc.data.meta?.adoptsFrom;
+		let waiterLabel = `create ${adoptsFrom ? humanReadable(adoptsFrom) : "<unknown type>"} in ${opts?.realm ?? "<default realm>"}`;
+		return await this.withTestWaiters(waiterLabel, async () => {
+			if (opts?.realm) doc.data.meta = {
+				...doc.data.meta ?? {},
+				realmURL: opts.realm
+			};
+			let cardOrError = await this.getCardInstance({
+				idOrDoc: doc,
+				relativeTo: opts?.relativeTo,
+				realm: opts?.realm,
+				opts: {
+					localDir: opts?.localDir,
+					dependencyTrackingContext: opts?.dependencyTrackingContext
+				}
+			});
+			if (isCardInstance(cardOrError)) return cardOrError.id;
+			return cardOrError;
+		});
+	}
+	save(id) {
+		this.doAutoSave(id, { isImmediate: true });
+	}
+	async add(instanceOrDoc, opts) {
+		return await this.addInternal(instanceOrDoc, opts);
+	}
+	async addWithoutPersisting(instanceOrDoc, opts) {
+		return await this.addInternal(instanceOrDoc, {
+			...opts,
+			doNotPersist: true
+		});
+	}
+	async addWithoutPersistingFromSerialized(instance, doc) {
+		await (await this.cardService.getAPI()).updateFromSerialized(instance, doc, this.store);
+		return await this.addWithoutPersisting(instance);
+	}
+	async addWithoutWaiting(instanceOrDoc, opts) {
+		return await this.addInternal(instanceOrDoc, {
+			...opts,
+			doNotWaitForPersist: true
+		});
+	}
+	async addInternal(instanceOrDoc, opts) {
+		let instance;
+		if (!isCardInstance(instanceOrDoc)) instance = await this.createFromSerialized(instanceOrDoc.data, instanceOrDoc, opts?.relativeTo, opts?.dependencyTrackingContext, opts?.hydrateFieldsMs);
+		else {
+			instance = instanceOrDoc;
+			let deps = getDeps(await this.cardService.getAPI(), instance);
+			for (let dep of deps) {
+				if (isCardInstance(dep)) {
+					if (!this.store.getCard(dep[localId])) this.store.setCard(dep.id ?? dep[localId], dep);
+					continue;
+				}
+				if (isFileDefInstance(dep) && dep.id) {
+					if (!this.store.getFileMeta(dep.id)) this.store.setFileMeta(dep.id, dep);
+				}
+			}
+		}
+		if (opts?.realm) instance[meta] = {
+			...instance[meta],
+			realmURL: opts.realm
+		};
+		if (!opts?.doNotPersist && globalThis.__boxelPrerenderApp && globalThis.__boxelHeadlessCommand) throw new Error(`cannot persist instance ${instance.id ?? instance[localId]}: a headless command is running with the prerender app's persistence block still raised`);
+		let maybeOldInstance = instance.id ? this.store.getCard(instance.id) : void 0;
+		if (maybeOldInstance) await this.stopAutoSaving(maybeOldInstance);
+		this.setIdentityContext(instance);
+		await this.startAutoSaving(instance);
+		if (this.renderContextBlocksPersistence()) return instance;
+		if (opts?.doNotWaitForPersist) this.persistAndUpdate(instance, {
+			realm: opts?.realm,
+			localDir: opts?.localDir,
+			skipIndexWait: opts?.skipIndexWait
+		});
+		else if (!opts?.doNotPersist) {
+			if (instance.id && this.useEphemeralState(instance)) return instance;
+			let stateKey = instance.id ?? instance[localId];
+			return await this.trackingSaveState(instance, stateKey, () => this.persistAndUpdate(instance, {
+				realm: opts?.realm,
+				localDir: opts?.localDir,
+				skipIndexWait: opts?.skipIndexWait
+			}));
+		}
+		return instance;
+	}
+	peek(id, opts) {
+		id = asURL(id, this.network.virtualNetwork);
+		return (opts?.type ?? "card") === "file-meta" ? this.store.getFileMetaInstanceOrError(id) : this.store.getCardInstanceOrError(id);
+	}
+	allCardInstances() {
+		return this.store.allCardInstances();
+	}
+	allFileMetaInstances() {
+		return this.store.allFileMetaInstances();
+	}
+	get instanceMutationVersion() {
+		return this._instanceMutationVersion;
+	}
+	async getMatchAPI() {
+		let api = await this.cardService.getAPI();
+		return {
+			getQueryableValue: api.getQueryableValue,
+			formatQueryValue: api.formatQueryValue,
+			peekAtField: api.peekAtField,
+			isQueryTaintedField: api.isQueryTaintedField,
+			isNonPresentLink: api.isNonPresentLink,
+			getCardMeta: api.getCardMeta,
+			primitive: api.primitive,
+			virtualNetwork: this.network.virtualNetwork
+		};
+	}
+	readTypeFor(id) {
+		let url = asURL(id, this.network.virtualNetwork);
+		return url && this.fileReadIds.has(url) ? "file-meta" : "card";
+	}
+	peekError(id, opts) {
+		id = asURL(id, this.network.virtualNetwork);
+		if ((opts?.type ?? "card") === "file-meta") return this.store.getFileMetaError(id);
+		return this.store.getCardError(id);
+	}
+	async get(id, opts) {
+		return (opts?.type ?? "card") === "file-meta" ? await this.getFileMetaInstance({
+			idOrDoc: id,
+			opts: { dependencyTrackingContext: opts?.dependencyTrackingContext }
+		}) : await this.getCardInstance({
+			idOrDoc: id,
+			opts: { dependencyTrackingContext: opts?.dependencyTrackingContext }
+		});
+	}
+	async getWithoutCache(id, opts) {
+		return (opts?.type ?? "card") === "file-meta" ? await this.getFileMetaInstance({
+			idOrDoc: id,
+			opts: { noCache: true }
+		}) : await this.getCardInstance({
+			idOrDoc: id,
+			opts: { noCache: true }
+		});
+	}
+	async serializeFileDefAsDocument(fileDef) {
+		return (await this.cardService.getAPI()).serializeFileDef(fileDef, {});
+	}
+	async delete(id, opts) {
+		id = asURL(id, this.network.virtualNetwork);
+		if (!id) return;
+		if (opts?.type === "file-meta") {
+			this.store.delete(id);
+			await this.cardService.deleteSource(new URL(id));
+			this.notifyCardInvalidationSubscribers(id);
+			return;
+		}
+		let instance = this.store.getCard(id);
+		let api = instance ? await this.cardService.getAPI() : void 0;
+		let consumers = api && instance ? this.store.consumersOf(api, instance) : [];
+		this.unsubscribeFromInstance(id);
+		this.store.delete(id);
+		if (api) for (let consumer of consumers) api.notifyLinksToTargetDeleted(consumer, id);
+		await this.cardService.fetchJSON(id, {
+			method: "DELETE",
+			...opts?.skipIndexWait ? { headers: { [SKIP_INDEX_WAIT_HEADER]: "1" } } : {}
+		});
+		this.notifyCardInvalidationSubscribers(id);
+	}
+	async patch(id, patch, opts) {
+		if (this.renderContextBlocksPersistence()) return;
+		let instance = await this.get(id);
+		if (!instance || !isCardInstance(instance)) return;
+		if (opts?.doNotPersist) await this.stopAutoSaving(instance);
+		let linkedCards = await this.loadPatchedInstances(patch, instance.id);
+		for (let [field, value] of Object.entries(linkedCards)) if (field.includes(".")) {
+			let parts = field.split(".");
+			let leaf = parts.pop();
+			if (!leaf) throw new Error(`bug: error in field name "${field}"`);
+			let inner = instance;
+			for (let part of parts) inner = inner[part];
+			inner[leaf.match(/^\d+$/) ? Number(leaf) : leaf] = value;
+		} else instance[field] = value;
+		let api = await this.cardService.getAPI();
+		let doc = await this.cardService.serializeCard(instance, { omitQueryFields: true });
+		if (patch.attributes) {
+			doc.data.attributes = mergeWith(doc.data.attributes, patch.attributes, (_dest, src) => Array.isArray(src) ? src : void 0);
+			if (doc.data.attributes) replacePrimitiveValues(api, doc.data.attributes, patch.attributes, instance);
+			clearReplacedArrayFieldMeta(doc.data.meta, patch.attributes);
+		}
+		if (patch.relationships) {
+			let mergedRel = mergeRelationships(doc.data.relationships, patch.relationships);
+			if (mergedRel && Object.keys(mergedRel).length !== 0) doc.data.relationships = mergedRel;
+		}
+		if (patch.meta) doc.data.meta = merge(doc.data.meta, patch.meta);
+		await api.updateFromSerialized(instance, doc, this.store);
+		let shouldPersist = !opts?.doNotPersist;
+		let shouldAwaitPersist = shouldPersist && !opts?.doNotWaitForPersist;
+		let persistedResult = instance;
+		if (opts?.doNotPersist) await this.startAutoSaving(instance);
+		else if (shouldPersist) {
+			let persistPromise = this.persistAndUpdate(instance, { clientRequestId: opts?.clientRequestId });
+			if (shouldAwaitPersist) persistedResult = await persistPromise;
+		}
+		return persistedResult;
+	}
+	async search(query, realms, opts) {
+		let { instances } = await this.searchInternal(query, realms, opts);
+		return instances;
+	}
+	async searchWithMeta(query, realms, opts) {
+		return await this.searchInternal(query, realms, opts);
+	}
+	async searchInternal(query, realms, opts) {
+		if ("asData" in query && query.asData) throw new Error(`store.search returns instances only — use store.searchEntries for the raw entry wire format`);
+		let searchRealms = opts?.cardInitiated ? this.normalizeRealmPaths(realms) : this.normalizeSearchRealms(realms);
+		if (searchRealms.length === 0) return {
+			instances: [],
+			meta: { page: { total: 0 } }
+		};
+		if (opts?.cardInitiated) {
+			assertRealmsBound(searchRealms);
+			query = applySearchPageBound(query);
+		}
+		let run = () => this.fetchAndHydrateSearchResults(query, searchRealms, opts?.dependencyTrackingContext, opts?.scope);
+		let lane = opts?.cardInitiated ? "card" : opts?.throttled ? "query-field" : void 0;
+		return lane ? await this.performThrottledSearch(async () => {
+			if (opts?.isObsolete?.()) return {
+				instances: [],
+				meta: { page: { total: 0 } }
+			};
+			return await run();
+		}, lane) : await run();
+	}
+	async searchEntries(query, realms, opts) {
+		let searchRealms = opts?.cardInitiated ? this.normalizeRealmPaths(realms) : this.normalizeSearchRealms(realms);
+		if (searchRealms.length === 0) return {
+			data: [],
+			meta: { page: { total: 0 } }
+		};
+		return await this.fetchSearchEntryDoc(query, searchRealms, { linksOnly: opts?.linksOnly });
+	}
+	async inflateSearchEntryItem(resource) {
+		if (resource.meta.error != null || hasWithheldRelationships(resource) || isSparseItemResource(resource)) return;
+		await this.addResourceFromSearchData(resource);
+	}
+	normalizeRealmPaths(realms) {
+		return dedupeRealmsByIdentity(this.network.virtualNetwork, realms ?? []);
+	}
+	normalizeSearchRealms(realms) {
+		let normalizedRealms = this.normalizeRealmPaths(realms);
+		return normalizedRealms.length > 0 ? normalizedRealms : this.realmServer.availableRealmIdentifiers;
+	}
+	cardSearchThrottle = buildTask(() => ({
+		context: this,
+		generator: function* (run) {
+			return yield run();
+		}
+	}), {
+		maxConcurrency: SEARCH_CONCURRENCY_CAP,
+		enqueue: true
+	}, "cardSearchThrottle", null);
+	queryFieldSearchThrottle = buildTask(() => ({
+		context: this,
+		generator: function* (run) {
+			return yield run();
+		}
+	}), {
+		maxConcurrency: QUERY_FIELD_SEARCH_CONCURRENCY_CAP,
+		enqueue: true
+	}, "queryFieldSearchThrottle", null);
+	performThrottledSearch(run, lane) {
+		return (lane === "card" ? this.cardSearchThrottle : this.queryFieldSearchThrottle).perform(run);
+	}
+	cardFacingStore(getCurrentRealm) {
+		let store = this;
+		return new Proxy(store, {
+			get(target, prop) {
+				if (prop === "search") return (query, realmURLs, opts) => {
+					let current = getCurrentRealm();
+					let realms = realmURLs ?? (current ? [current] : []);
+					return target.search(query, realms, {
+						cardInitiated: true,
+						scope: opts?.scope
+					});
+				};
+				if (typeof prop === "string" && !CARD_FACING_STORE_METHODS.has(prop)) return prop in Object.prototype ? Reflect.get(Object.prototype, prop) : void 0;
+				let value = Reflect.get(target, prop, target);
+				return typeof value === "function" ? value.bind(target) : value;
+			},
+			set: () => false,
+			defineProperty: () => false,
+			deleteProperty: () => false
+		});
+	}
+	async fetchAndHydrateSearchResults(query, realms, dependencyTrackingContext, scope) {
+		let collectionDoc = await this.fetchSearchDoc(query, realms, scope);
+		let items = this.itemResourcesFromSearchEntries(collectionDoc);
+		return {
+			instances: (await Promise.all(items.map(async (resource) => {
+				try {
+					if (hasWithheldRelationships(resource)) return await this.loadWithheldSearchItem(resource, dependencyTrackingContext);
+					return await this.addResourceFromSearchData(resource, dependencyTrackingContext);
+				} catch (error) {
+					storeLogger.warn(`Failed to hydrate resource from search results (id: ${"id" in resource ? resource.id : "unknown"})`, error);
+					return;
+				}
+			}))).filter(Boolean),
+			meta: collectionDoc.meta
+		};
+	}
+	async loadWithheldSearchItem(resource, dependencyTrackingContext) {
+		if (!resource.id) throw new Error("resource must have an id");
+		let loaded = isFileMetaResource(resource) ? await this.getFileMetaInstance({
+			idOrDoc: resource.id,
+			opts: { dependencyTrackingContext }
+		}) : await this.getCardInstance({
+			idOrDoc: resource.id,
+			opts: { dependencyTrackingContext }
+		});
+		if (isCardInstance(loaded) || isFileDefInstance(loaded)) return loaded;
+		storeLogger.warn(`Failed to load search result whose relationships were withheld (id: ${resource.id})`, loaded);
+	}
+	async fetchSearchDoc(query, realms, scope) {
+		let inPrerender = Boolean(globalThis.__boxelRenderContext);
+		let renderScope = inPrerender ? currentRenderScope() : void 0;
+		let consumingRealm = inPrerender ? globalThis.__boxelConsumingRealm : void 0;
+		if (typeof renderScope === "string" && renderScope !== this.searchCacheScope) {
+			this.searchCache.clear();
+			this.searchCacheScope = renderScope;
+			this.searchCacheGeneration++;
+		}
+		let wireScope = this.resolveWireScope(query, scope);
+		let cacheKey;
+		if (inPrerender && typeof renderScope === "string" && typeof consumingRealm === "string" && realms.length === 1 && canonicalRealmIdentifier(this.network.virtualNetwork, realms[0]) === canonicalRealmIdentifier(this.network.virtualNetwork, consumingRealm)) {
+			cacheKey = searchCacheKey(renderScope, consumingRealm, query, wireScope);
+			if (cacheKey !== void 0) {
+				let cached = this.searchCache.get(cacheKey);
+				if (cached !== void 0) return cached;
+			}
+		}
+		let captureGeneration = this.searchCacheGeneration;
+		let inflightKey = inPrerender ? searchInFlightKey(canonicalRealmIdentifiers(this.network.virtualNetwork, realms), query, wireScope) : void 0;
+		let doc;
+		if (inflightKey !== void 0) {
+			let existing = this.inflightSearch.get(inflightKey);
+			if (existing) doc = await existing;
+			else {
+				let pending = this.fetchSearchDocUncoalesced(query, realms, wireScope).finally(() => {
+					if (this.inflightSearch.get(inflightKey) === pending) this.inflightSearch.delete(inflightKey);
+				});
+				this.inflightSearch.set(inflightKey, pending);
+				doc = await pending;
+			}
+		} else doc = await this.fetchSearchDocUncoalesced(query, realms, wireScope);
+		if (cacheKey !== void 0 && this.searchCacheGeneration === captureGeneration) this.searchCache.set(cacheKey, doc);
+		return doc;
+	}
+	resolveWireScope(query, explicitScope) {
+		let hasPositiveType = (query.filter ? getTypeRefsFromFilter(query.filter) : void 0)?.some((r) => !r.negated && !isEqual(r.ref, baseRef)) ?? false;
+		return explicitScope !== void 0 ? explicitScope === "all" ? void 0 : explicitScope : hasPositiveType ? void 0 : "cards";
+	}
+	async fetchSearchDocUncoalesced(query, realms, wireScope) {
+		return await this.fetchSearchEntryDoc(searchEntryWireQueryFromQuery(query, {
+			fields: ["item"],
+			...wireScope ? { scope: wireScope } : {}
+		}), realms);
+	}
+	itemResourcesFromSearchEntries(doc) {
+		let byKey = /* @__PURE__ */ new Map();
+		for (let included of doc.included ?? []) if (included.type === "card" || included.type === "file-meta") byKey.set(`${included.type}:${included.id}`, included);
+		let items = [];
+		for (let entry of doc.data) {
+			let ref = entry.relationships.item?.data;
+			if (!ref) continue;
+			let item = byKey.get(`${ref.type}:${ref.id}`);
+			if (item) items.push(item);
+		}
+		return items;
+	}
+	async fetchSearchEntryDoc(query, realms, opts) {
+		let realmServerURLs = this.realmServer.getRealmServersForRealms(realms);
+		this.realmServer.assertOwnRealmServer(realmServerURLs);
+		let [realmServerURL] = realmServerURLs;
+		let searchURL = new URL("_federated-search", realmServerURL);
+		let response;
+		for (let attempt = 0;; attempt++) {
+			response = await this.realmServer.maybeAuthedFetchForRealms(searchURL.href, realms, {
+				method: "QUERY",
+				headers: {
+					Accept: SupportedMimeType.CardJson,
+					"Content-Type": "application/json",
+					...duringPrerenderHeaders(),
+					...consumingRealmHeader(),
+					...jobIdHeader(),
+					...jobPriorityHeader(),
+					...loggingCorrelationIdHeader(),
+					...opts?.linksOnly ? { [X_BOXEL_LINK_SHAPE_HEADER]: "links-only" } : {}
+				},
+				body: JSON.stringify({
+					...query,
+					realms
+				})
+			});
+			if (response.status !== 429 || attempt >= MAX_SHED_SEARCH_RETRIES) break;
+			await timeout(shedRetryDelayMs(response.headers.get("Retry-After")));
+		}
+		if (!response.ok) {
+			let responseText = await response.text();
+			let err = /* @__PURE__ */ new Error(`status: ${response.status} - ${response.statusText}. ${responseText}`);
+			err.status = response.status;
+			err.responseText = responseText;
+			err.responseHeaders = response.headers;
+			throw err;
+		}
+		let json = await response.json();
+		if (!isEntryCollectionDocument(json)) throw new Error(`The realm search response was not a valid entry collection document:
+        ${JSON.stringify(json, null, 2)}`);
+		return json;
+	}
+	async fetchCardEntry(url, opts) {
+		let requestURL = new URL(url);
+		if (opts.format) requestURL.searchParams.set("format", opts.format);
+		if (opts.renderType) requestURL.searchParams.set("renderType", `${opts.renderType.module}/${opts.renderType.name}`);
+		if (opts.fields) requestURL.searchParams.set("fields", opts.fields);
+		let headers = {
+			Accept: opts.kind === "file-meta" ? SupportedMimeType.FileMetaHtml : SupportedMimeType.CardHtml,
+			...duringPrerenderHeaders(),
+			...consumingRealmHeader(),
+			...jobIdHeader(),
+			...jobPriorityHeader(),
+			...loggingCorrelationIdHeader()
+		};
+		if (opts.ifNoneMatch) headers["If-None-Match"] = opts.ifNoneMatch;
+		let response = await this.network.authedFetch(requestURL.href, {
+			method: "GET",
+			headers
+		});
+		if (response.status === 304) return { notModified: true };
+		if (!response.ok) {
+			let responseText = await response.text();
+			let err = /* @__PURE__ */ new Error(`status: ${response.status} - ${response.statusText}. ${responseText}`);
+			err.status = response.status;
+			err.responseText = responseText;
+			err.responseHeaders = response.headers;
+			throw err;
+		}
+		let json = JSON.parse(await response.text());
+		if (!isEntrySingleDocument(json)) throw new Error(`The card+html response was not a valid entry single document:
+        ${JSON.stringify(json, null, 2)}`);
+		return {
+			notModified: false,
+			doc: json
+		};
+	}
+	getSearchResource(parent, getQuery, getRealms, opts) {
+		if (this.isRenderStore && opts) {
+			opts.isLive = false;
+			opts.throttled = false;
+		}
+		return getSearch(parent, getOwner(this), getQuery, getRealms, {
+			...opts,
+			storeService: this
+		});
+	}
+	getSaveState(id) {
+		id = asURL(id, this.network.virtualNetwork);
+		return this.autoSaveStates.get(id);
+	}
+	async flush() {
+		await this.ready;
+		await Promise.allSettled(this.newReferencePromises);
+	}
+	async flushSaves(opts) {
+		let gaveUp = false;
+		let flush = async () => {
+			while (!gaveUp && (this.#pendingAutoSaves.size > 0 || this.autoSavePromises.size > 0)) {
+				this.#sendPendingAutoSaves();
+				await Promise.allSettled([...this.autoSavePromises.values()]);
+			}
+		};
+		if (opts?.timeoutMs === void 0) {
+			await flush();
+			return;
+		}
+		let timer;
+		await Promise.race([flush(), new Promise((resolve) => {
+			timer = setTimeout(resolve, opts.timeoutMs);
+		})]);
+		clearTimeout(timer);
+		gaveUp = true;
+	}
+	get hasUnsavedEdits() {
+		return this.#pendingAutoSaves.size > 0 || this.autoSavePromises.size > 0;
+	}
+	getReferenceCount(id) {
+		id = asURL(id, this.network.virtualNetwork);
+		return this.referenceCount.get(id) ?? 0;
+	}
+	isSameId(a, b) {
+		return a === b || this.peek(a) === this.peek(b);
+	}
+	async waitForCardLoad(cardId) {
+		let normalizedId = asURL(cardId, this.network.virtualNetwork);
+		if (!normalizedId) return;
+		let inflightLoad = this.inflightCardLoads.get(normalizedId);
+		if (inflightLoad) await inflightLoad.promise;
+	}
+	startTrackingCardLoad(cardId) {
+		if (!cardId) return;
+		let normalizedId = asURL(cardId, this.network.virtualNetwork);
+		if (!normalizedId) return;
+		let deferred = new Deferred();
+		this.inflightCardLoads.set(normalizedId, deferred);
+		return deferred;
+	}
+	finishTrackingCardLoad(cardId, deferred) {
+		if (!cardId || !deferred) return;
+		let normalizedId = asURL(cardId, this.network.virtualNetwork);
+		if (!normalizedId) return;
+		if (this.inflightCardLoads.get(normalizedId) === deferred) this.inflightCardLoads.delete(normalizedId);
+		deferred.fulfill();
+	}
+	async wireUpNewReference(url, readType = "card") {
+		let deferred = new Deferred();
+		let waiterLabel = `wireUpNewReference ${url}`;
+		await this.withTestWaiters(waiterLabel, async () => {
+			this.newReferencePromises.push(deferred.promise);
+			try {
+				await this.ready;
+				if (readType === "file-meta") {
+					let instanceOrError = await this.getFileMetaInstance({ idOrDoc: url });
+					this.setIdentityContext(instanceOrError, "file-meta");
+					deferred.fulfill();
+					return;
+				}
+				if (this.peekError(url, { type: "file-meta" }) ?? this.peek(url, { type: "file-meta" })) {
+					deferred.fulfill();
+					return;
+				}
+				let instanceOrError = this.peekError(url) ?? this.peek(url);
+				if (!instanceOrError) {
+					instanceOrError = await this.getCardInstance({ idOrDoc: url });
+					if (this.readTypeFor(url) === "file-meta") {
+						deferred.fulfill();
+						return;
+					}
+					this.setIdentityContext(instanceOrError);
+				}
+				await this.startAutoSaving(instanceOrError);
+				if (!instanceOrError.id) this.store.addCardInstanceOrError(url, instanceOrError);
+				deferred.fulfill();
+			} catch (e) {
+				console.error(`error encountered wiring up new reference for ${JSON.stringify(url)}`, e);
+				deferred.reject(e);
+			}
+		});
+	}
+	/**
+	* Low-level deserialization that throws on validation errors.
+	*
+	* Most callers should use `add()` or `create()` instead — those methods
+	* handle persistence, identity mapping, and auto-saving. This method
+	* bypasses all of that and calls `card-api.createFromSerialized` directly.
+	*
+	* `store.add()` relaxes serialization errors: `Field.validate()` failures
+	* during deserialization are caught internally and logged as console warnings
+	* rather than thrown. This is correct for the UI but not for validation use
+	* cases where errors must propagate. Use this method only when you need
+	* validation errors to throw (e.g., the software-factory's instantiate-card
+	* command which validates that a card instance can be deserialized).
+	*/
+	async __dangerousCreateFromSerialized(resource, doc, relativeTo, dependencyTrackingContext) {
+		return this.createFromSerialized(resource, doc, relativeTo, dependencyTrackingContext);
+	}
+	async createFromSerialized(resource, doc, relativeTo, dependencyTrackingContext, hydrateFieldsMs) {
+		let api = await this.cardService.getAPI();
+		let shouldStubTimers = this.renderContextBlocksPersistence() && !isTesting();
+		let performCreate = async () => await api.createFromSerialized(resource, doc, relativeTo, {
+			store: this.store,
+			dependencyTrackingContext,
+			...hydrateFieldsMs ? { hydrateFieldsMs } : {}
+		});
+		let telemetry = this.#clientTelemetry();
+		let deserializeStart = telemetry?.isEnabled ? performance.now() : void 0;
+		let card = shouldStubTimers ? await withStubbedRenderTimers(performCreate) : await performCreate();
+		if (telemetry?.isEnabled && deserializeStart !== void 0) telemetry.recordDeserialize({
+			durationMs: performance.now() - deserializeStart,
+			doc,
+			resource
+		});
+		return card;
+	}
+	#clientTelemetry() {
+		if (globalThis.__boxelRenderContext) return;
+		try {
+			return getOwner(this)?.lookup("service:client-telemetry");
+		} catch {
+			return;
+		}
+	}
+	async setup() {
+		let api = await this.cardService.getAPI();
+		if (isDestroyed(this) || isDestroying(this)) return;
+		this.gcInterval = setInterval(() => this.store.sweep(api), 2 * 6e4);
+	}
+	unsubscribeFromInstance(id) {
+		let instance = this.store.getCard(id);
+		if (instance && this.cardApiCache) this.cardApiCache.unsubscribeFromChanges(instance, this.onInstanceUpdated);
+		let realmHref = !isLocalId(id) ? [...this.subscriptions.keys()].find((realmURL) => id.startsWith(realmURL)) : void 0;
+		if (!realmHref) return;
+		let subscription = this.subscriptions.get(realmHref);
+		if (subscription && ![...this.referenceCount.entries()].find(([referenceId, count]) => !isLocalId(referenceId) && count > 0 && referenceId.startsWith(realmHref))) {
+			subscription.unsubscribe();
+			this.subscriptions.delete(realmHref);
+		}
+	}
+	createCardStore() {
+		this.#identityEpoch++;
+		return new CardStoreWithGarbageCollection(this.referenceCount, this.network.authedFetch, this.network.virtualNetwork, {
+			resolvesQueryFieldsEagerly: () => this.resolvesQueryFieldsEagerly(),
+			receivesIndexEventsFor: (id) => this.receivesIndexEventsFor(id),
+			getSearchResource: (parent, getQuery, getRealms, opts) => this.getSearchResource(parent, getQuery, getRealms, opts)
+		});
+	}
+	resolvesQueryFieldsEagerly() {
+		if (globalThis.__boxelPrerenderApp) return false;
+		return !this.isRenderStore;
+	}
+	receivesIndexEventsFor(id) {
+		if (this.isRenderStore) return false;
+		if (isLocalId(id)) return false;
+		let realmURL = this.realm.realmOf(rri(asURL(id, this.network.virtualNetwork)));
+		return realmURL != null && this.subscriptions.has(realmURL);
+	}
+	handleInvalidations = (event) => {
+		if (event.eventName !== "index") return;
+		let telemetry = this.#clientTelemetry();
+		let processingStart = telemetry?.isEnabled ? performance.now() : void 0;
+		let eventArgs = () => {
+			let { invalidations: _invalidations, ...rest } = event;
+			return rest;
+		};
+		if (event.indexType === "full") {
+			let reloadsTriggered = this.reloadAwaitingIndexInstances(event.realmURL);
+			telemetry?.recordEvent({
+				event_type: "realm-event",
+				realm: event.realmURL,
+				index_type: "full",
+				invalidations_count: 0,
+				invalidated_ids: [],
+				reloads_triggered: reloadsTriggered,
+				own_write: false,
+				processing_ms: 0,
+				event_args: eventArgs()
+			});
+			return;
+		}
+		if (event.indexType !== "incremental") return;
+		let invalidations = event.invalidations;
+		let ownWrite = [event.clientRequestId, ...(event.coalescedWrites ?? []).map((write) => write.clientRequestId)].some((id) => !!id && this.cardService.clientRequestIds.has(id));
+		let executableInvalidations = invalidations.filter(hasExecutableExtension);
+		let alreadyFlushed = new Set(executableInvalidations.filter((i) => this.loaderService.wasModuleFlushedForCodeChange(i)));
+		let needsRebuild = executableInvalidations.length > 0 && (this.rebuildForCodeChange.isRunning || alreadyFlushed.size > 0 || executableInvalidations.some((i) => this.loaderService.loader.isModuleLoaded(i)));
+		let reloadsTriggered = 0;
+		if (needsRebuild) {
+			if (telemetry?.isEnabled) this.#accumulatePendingRebuild(event.realmURL, executableInvalidations, alreadyFlushed);
+			this.rebuildForCodeChange.perform();
+		} else reloadsTriggered = this.#reloadInvalidatedInstances(event, invalidations);
+		if (telemetry?.isEnabled) telemetry.recordEvent({
+			event_type: "realm-event",
+			realm: event.realmURL,
+			index_type: "incremental",
+			invalidations_count: invalidations.length,
+			invalidated_ids: invalidations.slice(0, 50),
+			reloads_triggered: reloadsTriggered,
+			own_write: ownWrite,
+			processing_ms: processingStart !== void 0 ? Math.round(performance.now() - processingStart) : 0,
+			event_args: eventArgs()
+		});
+	};
+	#sharedPassNeedsReload(writes, invalidation) {
+		let changedBy = writes.filter((write) => write.changed === null || write.changed.includes(invalidation));
+		if (changedBy.length === 0) {
+			realmEventsLogger.debug(`reloading card ${invalidation} because no write in its shared pass changed it directly`);
+			return true;
+		}
+		let stranger = changedBy.find(({ clientRequestId, changed, clientAuthored }) => !clientRequestId || !this.cardService.clientRequestIds.has(clientRequestId) || !isInstanceWriteRequestId(clientRequestId) || !(clientAuthored ?? changed ?? []).includes(invalidation));
+		if (stranger) {
+			realmEventsLogger.debug(`reloading card ${invalidation} because request ${stranger.clientRequestId ?? "with no id"} in its shared pass changed it and did not carry our content for it`);
+			return true;
+		}
+		realmEventsLogger.debug(`ignoring invalidation for card ${invalidation} because every write in its shared pass that changed it is ours and carried its content`);
+		return false;
+	}
+	#reloadInvalidatedInstances(event, invalidations) {
+		let reloadsTriggered = 0;
+		for (let invalidation of invalidations) {
+			if (hasExecutableExtension(invalidation)) continue;
+			if (this.peekError(invalidation, { type: "file-meta" }) ?? this.peek(invalidation, { type: "file-meta" })) {
+				realmEventsLogger.debug(`reloading file-meta resource ${invalidation} because it was previously loaded`);
+				this.reloadFileMetaTask.perform(invalidation);
+				reloadsTriggered++;
+			}
+			let clientRequestId = event.clientRequestId ?? void 0;
+			let clientAuthored = event.clientAuthored;
+			let instance = this.peekError(invalidation) ?? this.peek(invalidation);
+			if (instance) if (isCardInstance(instance)) {
+				if (invalidation.split("/").pop() === instance[localId] && instance.id !== rri(invalidation)) instance.id = rri(invalidation);
+				let reloadFile = false;
+				if (event.coalescedWrites) reloadFile = this.#sharedPassNeedsReload(event.coalescedWrites, invalidation);
+				else if (!clientRequestId) {
+					reloadFile = true;
+					realmEventsLogger.debug(`reloading file resource ${invalidation} because event has no clientRequestId`);
+				} else if (this.cardService.clientRequestIds.has(clientRequestId)) if (isInstanceWriteRequestId(clientRequestId)) if (clientAuthored && !clientAuthored.includes(invalidation)) {
+					reloadFile = true;
+					realmEventsLogger.debug(`reloading card ${invalidation} because request id ${clientRequestId} is ours but did not carry this card's content`);
+				} else realmEventsLogger.debug(`ignoring invalidation for card ${invalidation} because request id ${clientRequestId} is ours and an instance type`);
+				else {
+					reloadFile = true;
+					realmEventsLogger.debug(`reloading file resource ${invalidation} because request id ${clientRequestId} is not instance type`);
+				}
+				else {
+					reloadFile = true;
+					realmEventsLogger.debug(`reloading file resource ${invalidation} because request id ${clientRequestId} is not contained within known clientRequestIds`, Array.from(this.cardService.clientRequestIds.values()));
+				}
+				let alreadyHeld;
+				if (reloadFile) {
+					alreadyHeld = this.#indexStateAlreadyHeld(event, invalidation, instance);
+					if (alreadyHeld) reloadFile = false;
+				}
+				if (reloadFile) {
+					let target;
+					if (typeof event.generation === "number" || event.versions?.[invalidation] !== void 0) {
+						target = {
+							generation: event.generation,
+							version: event.versions?.[invalidation]
+						};
+						this.#reloadTargets.set(instance[localId], target);
+					}
+					this.reloadTask.perform(instance, target);
+					reloadsTriggered++;
+				} else realmEventsLogger.debug(alreadyHeld ? `ignoring invalidation ${invalidation} because ${alreadyHeld}` : `ignoring invalidation ${invalidation} for request id ${clientRequestId}`);
+			} else {
+				realmEventsLogger.debug(`reloading file resource ${invalidation} because it is in an error state`);
+				this.loadInstanceTask.perform(invalidation);
+				reloadsTriggered++;
+			}
+			else if (this.hasInflightCardLoad(invalidation)) {
+				realmEventsLogger.debug(`deferring reload of ${invalidation} until its in-flight load settles`);
+				this.reloadAfterInflightLoad.perform(invalidation);
+			} else realmEventsLogger.debug(`ignoring invalidation ${invalidation} because we did not previously try to load it`);
+		}
+		let realmConfigCardId = `${event.realmURL}realm`;
+		if (invalidations.includes(realmConfigCardId)) {
+			let indexCardId = `${event.realmURL}index`;
+			let indexCard = this.peek(indexCardId);
+			if (indexCard && isCardInstance(indexCard)) {
+				realmEventsLogger.debug(`reloading index card ${indexCardId} because the realm config card was re-indexed`);
+				this.reloadTask.perform(indexCard);
+				reloadsTriggered++;
+			}
+		}
+		return reloadsTriggered;
+	}
+	#indexStateAlreadyHeld(event, invalidation, instance) {
+		let held = instance[meta];
+		let incoming = this.#reloadTargets.get(instance[localId]);
+		let generation = Math.max(typeof held?.generation === "number" ? held.generation : -Infinity, typeof incoming?.generation === "number" ? incoming.generation : -Infinity);
+		if (typeof event.generation === "number" && Number.isFinite(generation) && event.generation <= generation) return `the store is at index generation ${generation}, at or past this event's ${event.generation}`;
+		let version = event.versions?.[invalidation];
+		if (version !== void 0 && (version === held?.version || version === incoming?.version)) return `the store is at version ${version}`;
+	}
+	loadInstanceTask = buildTask(() => ({
+		context: this,
+		generator: function* (idOrDoc) {
+			let url = asURL(idOrDoc, this.network.virtualNetwork);
+			let token = waiter.beginAsync(void 0, `loadInstance ${url ?? "new card document"}`);
+			let reloadTracker = this.startTrackingCardLoad(url);
+			try {
+				let oldInstance = url ? this.store.getCard(url) : void 0;
+				let instanceOrError = yield this.getCardInstance({
+					idOrDoc,
+					opts: { noCache: true }
+				});
+				if (oldInstance) yield this.stopAutoSaving(oldInstance);
+				this.setIdentityContext(instanceOrError);
+				yield this.startAutoSaving(instanceOrError);
+				if (isTesting()) yield this.cardService.cardsSettled();
+			} finally {
+				this.finishTrackingCardLoad(url, reloadTracker);
+				waiter.endAsync(token);
+			}
+		}
+	}), null, "loadInstanceTask", null);
+	hasInflightCardLoad(id) {
+		let url = asURL(id, this.network.virtualNetwork);
+		if (url && this.inflightGetCards.has(url)) return true;
+		return this.#cardDocLoadInFlight(id) !== void 0;
+	}
+	#cardDocLoadInFlight(id) {
+		return this.store.cardDocLoadInFlight?.(id);
+	}
+	reloadAfterInflightLoad = buildTask(() => ({
+		context: this,
+		generator: function* (id) {
+			let url = asURL(id, this.network.virtualNetwork);
+			let inflight = url ? this.inflightGetCards.get(url) : void 0;
+			if (inflight) yield inflight;
+			let docLoad = this.#cardDocLoadInFlight(id);
+			if (docLoad) {
+				yield docLoad.catch(() => {});
+				yield Promise.resolve();
+			}
+			if (this.peekError(id)?.awaitingIndex) {
+				this.loadInstanceTask.perform(id);
+				return;
+			}
+			if (docLoad && this.peek(id)) {
+				storeLogger.debug(`reloading ${id} because its link resolution settled across an invalidation`);
+				this.loadInstanceTask.perform(id);
+			}
+		}
+	}), null, "reloadAfterInflightLoad", null);
+	reloadAwaitingIndexInstances(realmURL) {
+		let reloaded = 0;
+		for (let [id, error] of this.store.cardErrorEntries()) {
+			if (!error.awaitingIndex) continue;
+			if (this.realm.realmOf(rri(id)) !== realmURL) continue;
+			realmEventsLogger.debug(`reloading ${id} because a full index of ${realmURL} may have landed the row it is waiting for`);
+			this.loadInstanceTask.perform(id);
+			reloaded++;
+		}
+		for (let id of this.inflightGetCards.keys()) {
+			if (this.realm.realmOf(rri(id)) !== realmURL) continue;
+			realmEventsLogger.debug(`deferring reload of ${id} until its in-flight load settles, because a full index of ${realmURL} landed while it was reading`);
+			this.reloadAfterInflightLoad.perform(id);
+		}
+		return reloaded;
+	}
+	reestablishReferences = buildTask(() => ({
+		context: this,
+		generator: function* () {
+			let remoteIds = /* @__PURE__ */ new Set();
+			for (let [id, referenceCount] of this.referenceCount) {
+				if (referenceCount === 0) continue;
+				if (isLocalId(id)) {
+					let remoteIdsForLocal = this.store.getRemoteIds(id);
+					if (remoteIdsForLocal.length === 0) {
+						let error = this.store.getCardError(id);
+						if (error?.meta?.remoteId) remoteIdsForLocal = [error.meta.remoteId];
+					}
+					for (let remoteId of remoteIdsForLocal) remoteIds.add(remoteId);
+				} else remoteIds.add(id);
+			}
+			let shouldLog = remoteIds.size > 0;
+			let fields = `references=${remoteIds.size} epoch=${this.#identityEpoch}`;
+			let start = performance.now();
+			let outcome = "cancelled";
+			let errored = "";
+			if (shouldLog) storeLogger.info(`re-establishing ${fields} outcome=started`);
+			try {
+				let count = (yield Promise.all([...remoteIds].map((id) => this.getCardInstance({ idOrDoc: id })))).filter((result) => !isCardInstance(result) && !isFileDefInstance(result)).length;
+				outcome = "settled";
+				errored = ` errored=${count}`;
+			} catch (e) {
+				outcome = "failed";
+				throw e;
+			} finally {
+				if (shouldLog) storeLogger.info(`re-establishing ${fields} outcome=${outcome}${errored} durationMs=${Math.round(performance.now() - start)}`);
+			}
+			return remoteIds.size;
+		}
+	}), null, "reestablishReferences", null);
+	#pendingRebuild = void 0;
+	#accumulatePendingRebuild(realm, executableInvalidations, alreadyFlushed) {
+		let pending = this.#pendingRebuild ??= {
+			realm,
+			triggerModules: /* @__PURE__ */ new Set(),
+			modulesRefetched: /* @__PURE__ */ new Set(),
+			events: 0
+		};
+		pending.realm = realm;
+		pending.events++;
+		for (let module of executableInvalidations) {
+			pending.triggerModules.add(module);
+			if (alreadyFlushed.has(module) || this.loaderService.loader.isModuleLoaded(module)) pending.modulesRefetched.add(module);
+		}
+	}
+	rebuildForCodeChange = buildTask(() => ({
+		context: this,
+		generator: function* () {
+			let telemetry = this.#clientTelemetry();
+			let pending = this.#pendingRebuild;
+			this.#pendingRebuild = void 0;
+			let rebuildStart = telemetry?.isEnabled && pending ? performance.now() : void 0;
+			this.loaderService.resetLoader();
+			this.#resetIdentityInPlace();
+			let cardsReloaded;
+			try {
+				cardsReloaded = yield this.reestablishReferences.perform();
+			} finally {
+				if (telemetry?.isEnabled && pending && rebuildStart !== void 0) {
+					let triggerModules = [...pending.triggerModules].slice(0, 20);
+					telemetry.recordEvent({
+						event_type: "rebuild",
+						rebuild_source: "realm-event",
+						realm: pending.realm,
+						duration_ms: Math.round(performance.now() - rebuildStart),
+						trigger_modules: triggerModules,
+						trigger_module: triggerModules[0] ?? "",
+						modules_refetched: pending.modulesRefetched.size,
+						cards_reloaded: cardsReloaded ?? 0,
+						coalesced_events: pending.events
+					});
+				}
+			}
+		}
+	}), null, "rebuildForCodeChange", "keepLatest");
+	reloadTask = buildTask(() => ({
+		context: this,
+		generator: function* (instance, reloadTarget) {
+			let reloadTracker = this.startTrackingCardLoad(instance.id);
+			let maybeReloadedInstance;
+			let isDelete = false;
+			let identityMap = this.store;
+			let identityEpoch = this.#identityEpoch;
+			try {
+				try {
+					maybeReloadedInstance = yield this.reloadInstance(instance, identityMap, identityEpoch);
+				} catch (err) {
+					let cardError = processCardError(instance.id, err).errors[0];
+					if (cardError?.awaitingIndex) maybeReloadedInstance = instance;
+					else if (err.status === 404) isDelete = true;
+					else maybeReloadedInstance = cardError;
+				}
+				if (this.#identityEpoch !== identityEpoch) {
+					storeLogger.info(`dropping reload of ${instance.id}: it started in identity epoch #${identityEpoch}, which was superseded by #${this.#identityEpoch} while the reload was in flight`);
+					return;
+				}
+				if (!isCardInstance(maybeReloadedInstance) || maybeReloadedInstance !== instance) yield this.stopAutoSaving(instance);
+				if (maybeReloadedInstance) {
+					this.setIdentityContext(maybeReloadedInstance);
+					yield this.startAutoSaving(maybeReloadedInstance);
+				}
+				if (!isDelete && maybeReloadedInstance === instance) this.notifyCardReloadSubscribers(instance);
+				if (isDelete) {
+					yield this.stopAutoSaving(instance);
+					let api = yield this.cardService.getAPI();
+					let consumers = this.store.consumersOf(api, instance);
+					this.store.delete(instance.id);
+					for (let consumer of consumers) api.notifyLinksToTargetDeleted(consumer, instance.id);
+					this.notifyCardInvalidationSubscribers(instance.id);
+				}
+			} finally {
+				let localId$1 = instance[localId];
+				if (reloadTarget && this.#reloadTargets.get(localId$1) === reloadTarget) this.#reloadTargets.delete(localId$1);
+				this.finishTrackingCardLoad(instance.id, reloadTracker);
+			}
+		}
+	}), null, "reloadTask", null);
+	reloadFileMetaTask = buildTask(() => ({
+		context: this,
+		generator: function* (url) {
+			let waiterLabel = `reloadFileMeta ${url}`;
+			yield this.withTestWaiters(waiterLabel, async () => {
+				let instanceOrError = await this.getFileMetaInstance({
+					idOrDoc: url,
+					opts: { noCache: true }
+				});
+				this.setIdentityContext(instanceOrError, "file-meta");
+			});
+		}
+	}), null, "reloadFileMetaTask", null);
+	onInstanceUpdated = (instance, fieldName) => {
+		if (fieldName === "id") return;
+		if (isCardInstance(instance)) {
+			this._instanceMutationVersion++;
+			this.#recordLocalEdit(instance, fieldName);
+			let autoSaveState = this.initOrGetAutoSaveState(instance);
+			autoSaveState.hasUnsavedChanges = true;
+			this.doAutoSave(instance);
+		}
+	};
+	#recordLocalEdit(instance, fieldName) {
+		let edits = this.#localEdits.get(instance);
+		if (!edits) {
+			edits = /* @__PURE__ */ new Map();
+			this.#localEdits.set(instance, edits);
+		}
+		edits.set(fieldName.split(".")[0], ++this.#localEditSeq);
+	}
+	#acknowledgeLocalEdits(instance, sentSeq) {
+		let edits = this.#localEdits.get(instance);
+		if (!edits) return;
+		for (let [fieldName, seq] of edits) if (seq <= sentSeq) edits.delete(fieldName);
+	}
+	#pinnedFields(instance) {
+		let pinned = new Set(this.#localEdits.get(instance)?.keys() ?? []);
+		for (let field of this.#optimisticFields.get(instance[localId]) ?? []) pinned.delete(field);
+		return pinned;
+	}
+	#recordOptimisticFields(instance, basis, result) {
+		let changed = /* @__PURE__ */ new Set();
+		for (let member of ["attributes", "relationships"]) {
+			let before = basis[member] ?? {};
+			let after = result[member] ?? {};
+			for (let key of new Set([...Object.keys(before), ...Object.keys(after)])) if (!isEqual(before[key], after[key])) changed.add(key.split(".")[0]);
+		}
+		if (changed.size === 0) return;
+		let localId$2 = instance[localId];
+		let fields = this.#optimisticFields.get(localId$2);
+		if (!fields) {
+			fields = /* @__PURE__ */ new Set();
+			this.#optimisticFields.set(localId$2, fields);
+		}
+		for (let field of changed) fields.add(field);
+	}
+	releaseOptimisticFields(localId) {
+		this.#optimisticFields.delete(localId);
+	}
+	setIdentityContext(instanceOrError, readType = "card") {
+		if (readType === "file-meta") {
+			let id = instanceOrError.id;
+			if (!id) return;
+			this.store.addFileMetaInstanceOrError(id, instanceOrError);
+			return;
+		}
+		let instance = isCardInstance(instanceOrError) ? instanceOrError : void 0;
+		if (!instance && !instanceOrError.id) return;
+		if (!instance && instanceOrError.awaitingIndex && this.store.getCard(instanceOrError.id)) return;
+		this.store.addCardInstanceOrError(instance ? instance.id ?? instance[localId] : instanceOrError.id, instanceOrError);
+	}
+	async createFileMetaFromSerialized(resource, doc, relativeTo, dependencyTrackingContext) {
+		let instance = await (await this.cardService.getAPI()).createFromSerialized(resource, doc, relativeTo, {
+			store: this.store,
+			dependencyTrackingContext
+		});
+		this.setIdentityContext(instance, "file-meta");
+		return instance;
+	}
+	async addResourceFromSearchData(resource, dependencyTrackingContext) {
+		if (!resource.id) throw new Error("resource must have an id");
+		let canonicalId = this.network.virtualNetwork.unresolveURL(resource.id);
+		if (canonicalId !== resource.id) resource.id = canonicalId;
+		if (isFileMetaResource(resource)) {
+			let existingInstance = this.peek(resource.id, { type: "file-meta" });
+			if (existingInstance && isFileDefInstance(existingInstance)) return existingInstance;
+			let doc = { data: resource };
+			return this.createFileMetaFromSerialized(resource, doc, resource.id, dependencyTrackingContext);
+		}
+		let existingInstance = this.peek(resource.id);
+		if (existingInstance && isCardInstance(existingInstance)) return existingInstance;
+		resource[queryFieldSeedFromSearchSymbol] = true;
+		return this.addWithoutPersisting({ data: resource }, {
+			relativeTo: resource.id,
+			dependencyTrackingContext
+		});
+	}
+	async startAutoSaving(instanceOrError) {
+		if (!isCardInstance(instanceOrError)) return;
+		if (this.renderContextBlocksPersistence()) return;
+		let instance = instanceOrError;
+		this.cardApiCache = await this.cardService.getAPI();
+		this.cardApiCache.unsubscribeFromChanges(instance, this.onInstanceUpdated);
+		this.cardApiCache.subscribeToChanges(instance, this.onInstanceUpdated);
+	}
+	async stopAutoSaving(instanceOrError) {
+		if (!isCardInstance(instanceOrError)) return;
+		let instance = instanceOrError;
+		this.cardApiCache = await this.cardService.getAPI();
+		this.cardApiCache.unsubscribeFromChanges(instance, this.onInstanceUpdated);
+		this.autoSaveStates.delete(instance.id);
+		this.autoSaveStates.delete(instance[localId]);
+	}
+	async getCardInstance({ idOrDoc, relativeTo, realm, opts }) {
+		let deferred;
+		let id = asURL(idOrDoc, this.network.virtualNetwork);
+		if (id) {
+			let working = this.inflightGetCards.get(id);
+			if (working) return working;
+			deferred = new Deferred();
+			this.inflightGetCards.set(id, deferred.promise);
+		}
+		try {
+			if (!id) if (!this.renderContextBlocksPersistence()) {
+				let doc = idOrDoc;
+				let newInstance = await this.createFromSerialized(doc.data, doc, relativeTo, opts?.dependencyTrackingContext);
+				let maybeError = await this.persistAndUpdate(newInstance, {
+					realm,
+					localDir: opts?.localDir
+				});
+				if (!isCardInstance(maybeError)) return maybeError;
+				this.store.setCard(newInstance.id, newInstance);
+				deferred?.fulfill(newInstance);
+				return newInstance;
+			} else throw new Error(`cannot save serialized doc in render context`);
+			let existingInstance = this.peek(id);
+			if (!opts?.noCache && existingInstance) {
+				deferred?.fulfill(existingInstance);
+				return existingInstance;
+			}
+			let vn = this.network.virtualNetwork;
+			if (isLocalId(id) && !vn.isRegisteredPrefix(id)) {
+				let remoteId = this.store.getRemoteIds(id)?.[0];
+				if (!remoteId) throw new Error(`instance with local id ${id} does not exist in the store`);
+				id = remoteId;
+			}
+			let url = vn.isRegisteredPrefix(id) ? vn.toURL(id).href : id;
+			let doc = typeof idOrDoc !== "string" ? idOrDoc : void 0;
+			if (!doc) {
+				let json;
+				if (this.isRenderStore && globalThis.__boxelRenderContext) {
+					let result = await this.cardService.getSource(vn.toURL(`${url}.json`));
+					if (result.status === 200) {
+						if (!isJsonContentType(result.contentType)) throw new Error(`Could not load ${url} as a card: the response (content type ${result.contentType ?? "unknown"}) is not a card document. If this is a relationship link, it likely points at a non-card URL (e.g. an image) rather than a card.`);
+						try {
+							json = JSON.parse(result.content);
+						} catch {
+							throw new Error(`Could not load ${url} as a card: its source (content type ${result.contentType ?? "unknown"}) is not valid JSON.`);
+						}
+					} else throw new Error(`Received non-200 status fetching instance source ${url}.json: ${result.content}`);
+				} else json = await this.cardService.fetchJSON(url);
+				if (!isSingleCardDocument(json)) {
+					if (isSingleFileMetaDocument(json)) {
+						if (id) this.fileReadIds.add(id);
+						let fileMeta = await this.getFileMetaInstance({
+							idOrDoc: url,
+							opts: {
+								noCache: opts?.noCache,
+								dependencyTrackingContext: opts?.dependencyTrackingContext
+							}
+						});
+						if (id && !isFileDefInstance(fileMeta)) this.store.addFileMetaInstanceOrError(id, fileMeta);
+						deferred?.fulfill(fileMeta);
+						return fileMeta;
+					}
+					throw new Error(`bug: server returned a non card document for ${url}:
+        ${JSON.stringify(json, null, 2)}`);
+				}
+				if (!json.data.id || !isResolvableInstanceId(json.data.id, this.network.virtualNetwork)) json.data.id = rri(url);
+				if (!json.data.meta?.realmURL) {
+					let realmURL = this.realm.realmOf(rri(url));
+					if (realmURL) json.data.meta = {
+						...json.data.meta ?? {},
+						realmURL
+					};
+				}
+				doc = json;
+			}
+			let instance = await this.createFromSerialized(doc.data, doc, doc.data.id, opts?.dependencyTrackingContext);
+			this.store.setCard(url, instance);
+			deferred?.fulfill(instance);
+			if (!existingInstance || !isCardInstance(existingInstance)) {
+				this.setIdentityContext(instance);
+				await this.startAutoSaving(instance);
+			}
+			return instance;
+		} catch (error) {
+			let cardError = processCardError(id, error).errors[0];
+			let running = cardError?.awaitingIndex && id ? this.store.getCard(id) : void 0;
+			if (running) {
+				deferred?.fulfill(running);
+				return running;
+			}
+			deferred?.fulfill(cardError);
+			this.setIdentityContext(cardError);
+			let status = cardError?.status ?? error?.status;
+			let isSystemCardDefault = isSystemCardDefaultId(id, idOrDoc, cardError?.id);
+			let shouldLogAsError = !(isTesting() && status === 404 && isSystemCardDefault);
+			let message = `error getting instance ${JSON.stringify(idOrDoc, null, 2)}: ${stringifyErrorForLog(error)}`;
+			if (shouldLogAsError) storeLogger.error(message);
+			else storeLogger.debug(message);
+			return cardError;
+		} finally {
+			if (id && deferred && this.inflightGetCards.get(id) === deferred.promise) this.inflightGetCards.delete(id);
+		}
+	}
+	async getFileMetaInstance({ idOrDoc, opts }) {
+		let deferred;
+		let id = asURL(idOrDoc, this.network.virtualNetwork);
+		if (!id) throw new Error("file-meta reads require a URL id");
+		let working = this.inflightGetFileMeta.get(id);
+		if (working) return working;
+		deferred = new Deferred();
+		this.inflightGetFileMeta.set(id, deferred.promise);
+		try {
+			let existingInstance = this.peek(id, { type: "file-meta" });
+			if (!opts?.noCache && existingInstance) {
+				deferred.fulfill(existingInstance);
+				return existingInstance;
+			}
+			let vn = this.network.virtualNetwork;
+			if (isLocalId(id) && !vn.isRegisteredPrefix(id)) throw new Error(`file-meta reads do not support local ids (${id})`);
+			let url = vn.isRegisteredPrefix(id) ? vn.toURL(id).href : id;
+			let fileMetaDoc;
+			if (this.isRenderStore && globalThis.__boxelRenderContext) fileMetaDoc = await this.extractFileMetaDirectly(url);
+			else fileMetaDoc = await this.store.loadFileMetaDocument(url, { dependencyTrackingContext: opts?.dependencyTrackingContext });
+			if (isCardError(fileMetaDoc)) throw fileMetaDoc;
+			let fileInstance = await (await this.cardService.getAPI()).createFromSerialized(fileMetaDoc.data, fileMetaDoc, fileMetaDoc.data.id ?? new URL(url), {
+				store: this.store,
+				dependencyTrackingContext: opts?.dependencyTrackingContext
+			});
+			this.setIdentityContext(fileInstance, "file-meta");
+			if (fileMetaDoc.data.id && fileMetaDoc.data.id !== id) this.store.setFileMeta(id, fileInstance);
+			deferred.fulfill(fileInstance);
+			return fileInstance;
+		} catch (error) {
+			let cardError = processCardError(id, error, "file-meta").errors[0];
+			deferred.fulfill(cardError);
+			console.error(`error getting file-meta instance ${JSON.stringify(idOrDoc, null, 2)}: ${JSON.stringify(error, null, 2)}`, error);
+			return cardError;
+		} finally {
+			if (this.inflightGetFileMeta.get(id) === deferred.promise) this.inflightGetFileMeta.delete(id);
+		}
+	}
+	async extractFileMetaDirectly(url) {
+		let fileDefCodeRef = resolveFileDefCodeRef(new URL(url));
+		let result = await new FileDefAttributesExtractor({
+			loaderService: this.loaderService,
+			network: this.network,
+			fileURL: url,
+			fileDefCodeRef,
+			baseFileDefCodeRef: baseFileRef,
+			contentHash: void 0,
+			contentSize: void 0,
+			buildError: (errorUrl, error) => {
+				let errorJSONAPI = formattedError(errorUrl, error).errors[0];
+				return errorJsonApiToErrorEntry(errorJSONAPI);
+			}
+		}).extract();
+		if (result.status === "error" || !result.resource) return new CardError(result.error?.error?.message ?? "File extract failed", { status: 500 });
+		return { data: result.resource };
+	}
+	useEphemeralState(instance) {
+		if (!instance) return false;
+		let realmURL$2 = instance[realmURL];
+		if (!realmURL$2) return false;
+		return !this.realm.permissions(realmURL$2.href).canWrite;
+	}
+	doAutoSave(idOrInstance, opts) {
+		if (this.isRenderStore) return;
+		let instance;
+		if (typeof idOrInstance === "string") {
+			let maybeInstance = this.peek(idOrInstance);
+			if (!isCardInstance(maybeInstance)) return;
+			instance = maybeInstance;
+		} else instance = idOrInstance;
+		if (this.useEphemeralState(instance)) return;
+		let autoSaveState = this.initOrGetAutoSaveState(instance);
+		autoSaveState.lastSaveError = void 0;
+		let localId$3 = instance[localId];
+		let pending = this.#pendingAutoSaves.get(localId$3);
+		if (!pending) {
+			pending = {
+				instance,
+				firstChangeAt: Date.now(),
+				timer: void 0,
+				isImmediate: false,
+				keepalive: false,
+				isSending: false,
+				waiterToken: waiter.beginAsync(void 0, `pendingAutoSave ${localId$3}`),
+				sessionEpoch: this.#sessionEpoch,
+				...this.#holdForAutoSave(instance)
+			};
+			this.#pendingAutoSaves.set(localId$3, pending);
+		}
+		pending.instance = instance;
+		if (opts?.isImmediate) pending.isImmediate = true;
+		if (pending.isSending) return;
+		if (pending.isImmediate) {
+			this.#sendAutoSave(localId$3);
+			return;
+		}
+		let { autoSaveQuietPeriodMs, autoSaveMaxWaitMs } = this.environmentService;
+		let wait = Math.max(0, Math.min(autoSaveQuietPeriodMs, pending.firstChangeAt + autoSaveMaxWaitMs - Date.now()));
+		clearTimeout(pending.timer);
+		pending.timer = setTimeout(() => this.#sendAutoSave(localId$3), wait);
+		this.calculateLastSavedMsg(autoSaveState, { hasPendingSave: true });
+	}
+	#sendPendingAutoSaves(opts) {
+		for (let localId of [...this.#pendingAutoSaves.keys()]) this.#sendAutoSave(localId, opts);
+	}
+	#dropPendingAutoSaves() {
+		for (let [localId, pending] of [...this.#pendingAutoSaves]) {
+			if (pending.isSending) continue;
+			clearTimeout(pending.timer);
+			this.#pendingAutoSaves.delete(localId);
+			waiter.endAsync(pending.waiterToken);
+		}
+	}
+	#sendAutoSave(localId, opts) {
+		let pending = this.#pendingAutoSaves.get(localId);
+		if (!pending) return;
+		if (opts?.keepalive) pending.keepalive = true;
+		clearTimeout(pending.timer);
+		pending.timer = void 0;
+		if (pending.isSending) return;
+		pending.isSending = true;
+		let previous = this.autoSavePromises.get(localId);
+		let run;
+		run = (async () => {
+			try {
+				await previous;
+				await this.inflightCardMutations.get(localId);
+				if (this.#pendingAutoSaves.get(localId) === pending) this.#pendingAutoSaves.delete(localId);
+				if (pending.sessionEpoch !== this.#sessionEpoch) {
+					storeLogger.warn(`not saving ${localId}: the session it was edited in has ended`);
+					return;
+				}
+				let { instance } = pending;
+				let autoSaveState = this.initOrGetAutoSaveState(instance);
+				autoSaveState.isSaving = true;
+				await this.trackingSaveState(instance, localId, () => this.saveInstance(instance, {
+					...pending.isImmediate ? { isImmediate: true } : {},
+					...pending.keepalive ? { keepalive: true } : {}
+				}));
+			} catch {} finally {
+				if (this.#pendingAutoSaves.get(localId) === pending) this.#pendingAutoSaves.delete(localId);
+				if (this.autoSavePromises.get(localId) === run) this.autoSavePromises.delete(localId);
+				this.#releaseAutoSaveHold(pending);
+				waiter.endAsync(pending.waiterToken);
+			}
+		})();
+		this.autoSavePromises.set(localId, run);
+	}
+	#holdForAutoSave(instance) {
+		let holdKey = asURL(instance.id ?? instance[localId], this.network.virtualNetwork);
+		this.referenceCount.set(holdKey, (this.referenceCount.get(holdKey) ?? 0) + 1);
+		this.#autoSaveHolds.set(holdKey, (this.#autoSaveHolds.get(holdKey) ?? 0) + 1);
+		return {
+			holdKey,
+			heldIn: this.referenceCount
+		};
+	}
+	#releaseAutoSaveHold(pending) {
+		if (pending.heldIn !== this.referenceCount) return;
+		let { holdKey } = pending;
+		let holds = (this.#autoSaveHolds.get(holdKey) ?? 0) - 1;
+		if (holds > 0) this.#autoSaveHolds.set(holdKey, holds);
+		else this.#autoSaveHolds.delete(holdKey);
+		if (this.#teardownAfterSave.has(holdKey)) {
+			if (holds <= 0) this.#teardownAfterSave.delete(holdKey);
+			this.dropReference(holdKey);
+			return;
+		}
+		let count = (this.referenceCount.get(holdKey) ?? 0) - 1;
+		if (count > 0) this.referenceCount.set(holdKey, count);
+		else this.referenceCount.delete(holdKey);
+	}
+	async trackingSaveState(instance, stateKey, save) {
+		let autoSaveState = this.initOrGetAutoSaveState(instance);
+		try {
+			let maybeError = await save();
+			autoSaveState.hasUnsavedChanges = this.#pendingAutoSaves.has(instance[localId]);
+			autoSaveState.lastSaved = Date.now();
+			autoSaveState.lastSavedErrorMsg = void 0;
+			autoSaveState.lastSaveError = maybeError && !isCardInstance(maybeError) ? maybeError : void 0;
+			return maybeError;
+		} catch (error) {
+			autoSaveState.lastSaveError = error;
+			throw error;
+		} finally {
+			autoSaveState.isSaving = false;
+			this.calculateLastSavedMsg(autoSaveState, { hasPendingSave: this.#pendingAutoSaves.has(instance[localId]) });
+			if (isLocalId(stateKey) && instance.id) this.autoSaveStates.set(instance.id, autoSaveState);
+		}
+	}
+	initOrGetAutoSaveState(instance) {
+		let autoSaveState = this.autoSaveStates.get(instance.id ?? instance[localId]);
+		if (!autoSaveState) {
+			autoSaveState = new TrackedObject({
+				isSaving: false,
+				hasUnsavedChanges: false,
+				lastSaved: void 0,
+				lastSavedErrorMsg: void 0,
+				lastSaveError: void 0
+			});
+			this.autoSaveStates.set(instance[localId], autoSaveState);
+		}
+		if (instance.id && !this.autoSaveStates.get(instance.id)) this.autoSaveStates.set(instance.id, autoSaveState);
+		return autoSaveState;
+	}
+	async saveInstance(instance, opts) {
+		if (this.renderContextBlocksPersistence()) return;
+		let persistOpts = opts?.keepalive ? { keepalive: true } : void 0;
+		if (opts?.isImmediate || opts?.keepalive) return await this.persistAndUpdate(instance, persistOpts);
+		else {
+			let [result] = await Promise.all([this.persistAndUpdate(instance, persistOpts), delay(500)]);
+			return result;
+		}
+	}
+	async saveCardDocument(doc, opts) {
+		let isSaved = !!doc.data.id;
+		let url = resolveDocUrl(doc.data.id, opts?.realm, opts?.localDir);
+		let body = JSON.stringify(doc, null, 2);
+		let keepaliveBytes = opts?.keepalive ? new TextEncoder().encode(body).length : 0;
+		let keepalive = keepaliveBytes > 0 && this.#keepaliveBytesInFlight + keepaliveBytes <= KEEPALIVE_BODY_LIMIT;
+		if (keepalive) this.#keepaliveBytesInFlight += keepaliveBytes;
+		let json = await this.cardService.fetchJSON(url, {
+			method: isSaved ? "PATCH" : "POST",
+			body,
+			...keepalive ? { keepalive: true } : {},
+			headers: {
+				"Content-Type": SupportedMimeType.CardJson,
+				...headlessCommandWriteHeaders(),
+				...opts?.skipIndexWait === true ? { [SKIP_INDEX_WAIT_HEADER]: "1" } : {}
+			},
+			clientRequestId: opts?.clientRequestId
+		}).finally(() => {
+			if (keepalive) this.#keepaliveBytesInFlight -= keepaliveBytes;
+		});
+		if (!isSingleCardDocument(json)) throw new Error(`bug: arg is not a card document:
+        ${JSON.stringify(json, null, 2)}`);
+		return json;
+	}
+	calculateLastSavedMsg(autoSaveState, opts) {
+		let savedMessage;
+		if (autoSaveState.lastSaveError) savedMessage = `Failed to save: ${this.getErrorMessage(autoSaveState.lastSaveError)}`;
+		else if (opts?.hasPendingSave) savedMessage = "Unsaved changes";
+		else if (autoSaveState.lastSaved) savedMessage = `Saved ${formatDistanceToNow(autoSaveState.lastSaved, { addSuffix: true })}`;
+		if (autoSaveState.lastSavedErrorMsg != savedMessage) autoSaveState.lastSavedErrorMsg = savedMessage;
+	}
+	getErrorMessage(error) {
+		if ("meta" in error && typeof error.meta === "object" && "responseHeaders" in error.meta && error.meta.responseHeaders && typeof error.meta.responseHeaders === "object") {
+			let wafRule = Object.entries(error.meta.responseHeaders).find(([header]) => header.toLowerCase() === "x-blocked-by-waf-rule")?.[1];
+			if (wafRule) return `Request blocked by Web Application Firewall. X-blocked-by-waf-rule response header specifies rule: ${wafRule}`;
+		}
+		if (error.message) return error.message;
+		return "Unknown error";
+	}
+	async persistAndUpdate(instance, opts) {
+		let waiterLabel = `persistAndUpdate ${instance.id ?? instance[localId]}`;
+		return await this.withTestWaiters(waiterLabel, async () => {
+			let isNew = !instance.id;
+			return await this.withCardMutationLock(instance[localId], async () => {
+				let endCreate;
+				try {
+					let realmURL$3 = instance[realmURL];
+					if (!realmURL$3) {
+						let defaultRealmHref = opts?.realm ?? this.realm.defaultWritableRealm?.path;
+						if (!defaultRealmHref) throw new Error("Could not find a writable realm");
+						realmURL$3 = new URL(defaultRealmHref);
+					}
+					let doc;
+					let sentSeq;
+					({doc, sentSeq, endCreate} = await this.#serializeForSave(instance));
+					let json = await this.saveCardDocument(doc, {
+						realm: realmURL$3.href,
+						localDir: opts?.localDir,
+						clientRequestId: opts?.clientRequestId,
+						skipIndexWait: opts?.skipIndexWait,
+						keepalive: opts?.keepalive
+					});
+					let api = await this.cardService.getAPI();
+					if (needsServerStateMerge(instance, json)) {
+						let serverState = cloneDeep(json);
+						delete serverState.data.attributes;
+						delete serverState.data.relationships;
+						await api.updateFromSerialized(instance, serverState, this.store);
+					}
+					if (isNew) await this.assignRemoteIdentity(instance, json.data.id);
+					this.#recordWrittenVersion(instance, json);
+					this.#acknowledgeLocalEdits(instance, sentSeq);
+					if (this.onSaveSubscriber) this.onSaveSubscriber(this.network.virtualNetwork.toURL(json.data.id), json);
+					return instance;
+				} catch (err) {
+					console.error(`Failed to save ${instance.id}: `, err);
+					let cardError = processCardError(instance.id ?? instance[localId], err).errors[0];
+					this.setIdentityContext(cardError);
+					let remoteId = cardError.meta?.remoteId;
+					if (remoteId && (!cardError.id || isLocalId(cardError.id))) this.store.addCardInstanceOrError(remoteId, cardError);
+					return cardError;
+				} finally {
+					endCreate?.();
+				}
+			});
+		});
+	}
+	async #serializeForSave(instance) {
+		for (;;) {
+			let sentSeq = this.#localEditSeq;
+			let doc = await this.cardService.serializeCard(instance, {
+				useAbsoluteURL: true,
+				withLocalResourcesIncluded: true,
+				omitQueryFields: true
+			});
+			let pendingCreates = (doc.included ?? []).flatMap((resource) => {
+				let pending = !resource.id && "lid" in resource && resource.lid ? this.inflightCardCreates.get(resource.lid) : void 0;
+				return pending ? [pending] : [];
+			});
+			if (pendingCreates.length === 0) return {
+				doc,
+				sentSeq,
+				...doc.data.id ? {} : { endCreate: this.beginCreates([instance[localId]]) }
+			};
+			await Promise.all(pendingCreates);
+		}
+	}
+	beginCreates(localIds) {
+		let sent = new Deferred();
+		for (let localId of localIds) this.inflightCardCreates.set(localId, sent.promise);
+		return () => {
+			for (let localId of localIds) if (this.inflightCardCreates.get(localId) === sent.promise) this.inflightCardCreates.delete(localId);
+			sent.fulfill();
+		};
+	}
+	async withCardMutationLock(localId, fn) {
+		let inflightMutation = this.inflightCardMutations.get(localId);
+		if (inflightMutation) await inflightMutation;
+		let deferred = new Deferred();
+		this.inflightCardMutations.set(localId, deferred.promise);
+		try {
+			return await fn();
+		} finally {
+			deferred.fulfill();
+		}
+	}
+	async withMutationLocks(localIds, fn) {
+		let [first, ...rest] = [...new Set(localIds)];
+		if (first === void 0) return await fn();
+		return await this.withCardMutationLock(first, () => this.withMutationLocks(rest, fn));
+	}
+	onCardReloaded(cb) {
+		this.cardReloadSubscribers.add(cb);
+		return () => {
+			this.cardReloadSubscribers.delete(cb);
+		};
+	}
+	notifyCardReloadSubscribers(instance) {
+		for (let subscriber of [...this.cardReloadSubscribers]) try {
+			subscriber(instance);
+		} catch (err) {
+			console.error(`card reload subscriber threw for ${instance.id}`, err);
+		}
+	}
+	operationVersionOf(instance) {
+		return instance[meta]?.version;
+	}
+	recordOperationVersion(instance, version) {
+		this.#recordWrittenVersion(instance, { data: { meta: { version } } });
+	}
+	async applyOperationSource(instance, resource, basis) {
+		let api = await this.cardService.getAPI();
+		let held = instance[meta];
+		this.#recordOptimisticFields(instance, basis, resource);
+		await api.updateFromSerialized(instance, { data: resource }, this.store);
+		instance[meta] = {
+			...held,
+			...instance[meta]
+		};
+	}
+	async reloadForRollback(instance) {
+		await this.reloadTask.perform(instance);
+	}
+	async adoptMintedIdentities(minted) {
+		let conflicts = [];
+		let pairs = [];
+		for (let { lid, id } of minted) {
+			let held = this.store.getCard(rri(id));
+			if (held && held[localId] !== lid) conflicts.push({
+				lid,
+				id,
+				held
+			});
+			else pairs.push({
+				lid,
+				id
+			});
+		}
+		for (let { lid, id } of pairs) {
+			let instance = this.store.getCard(lid);
+			if (!instance || instance.id) continue;
+			await this.assignRemoteIdentity(instance, rri(id));
+		}
+		if (conflicts.length === 0) return;
+		for (let { held } of conflicts) if (held.id) this.reloadTask.perform(held);
+		let [{ id, lid, held }] = conflicts;
+		throw new Error(`the batch committed, but its card ${id} cannot be paired with local id ${lid}: this store already holds that card under local id ${held[localId]}. The realm has the write, the batch's other cards are paired, and this tab's copy of that card is being re-read.`);
+	}
+	async assignRemoteIdentity(instance, remoteId) {
+		(await this.cardService.getAPI()).setId(instance, remoteId);
+		this.subscribeToRealm(rri(instance.id));
+		this.operatorModeStateService.handleCardIdAssignment(instance[localId]);
+		await this.updateForeignConsumersOf(instance);
+		this.setIdentityContext(instance);
+		await this.startAutoSaving(instance);
+	}
+	#recordWrittenVersion(instance, json) {
+		let held = instance[meta];
+		let version = json.data.meta?.version;
+		if (version === held?.version) return;
+		instance[meta] = {
+			...held,
+			version
+		};
+	}
+	async updateForeignConsumersOf(instance) {
+		let consumers = this.store.consumersOf(await this.cardService.getAPI(), instance);
+		let instanceRealm = instance[realmURL]?.href;
+		if (!instanceRealm) return;
+		for (let consumer of consumers) if (consumer[realmURL]?.href !== instanceRealm && consumer.id) this.save(consumer.id);
+	}
+	async reloadInstance(instance, identityMap, identityEpoch) {
+		let waiterLabel = `reloadInstance ${instance.id}`;
+		return await this.withTestWaiters(waiterLabel, async () => {
+			let api = await this.cardService.getAPI();
+			let pinnedAtRead = this.#pinnedFields(instance);
+			let incomingDoc = await this.cardService.fetchJSON(instance.id, void 0);
+			if (!isSingleCardDocument(incomingDoc)) throw new Error(`bug: server returned a non card document for ${instance.id}:
+        ${JSON.stringify(incomingDoc, null, 2)}`);
+			let newDef;
+			try {
+				newDef = await loadCardDef(incomingDoc.data.meta.adoptsFrom, {
+					loader: this.loaderService.loader,
+					relativeTo: this.network.virtualNetwork.toURL(instance.id)
+				});
+			} catch (err) {
+				if (isCardError(err) && err.status === 404) err.status = 422;
+				throw err;
+			}
+			if (this.#identityEpoch !== identityEpoch) return;
+			if (Reflect.getPrototypeOf(instance)?.constructor !== newDef) {
+				let rebuilt = new newDef({
+					id: instance.id,
+					[localId]: instance[localId]
+				});
+				await api.updateFromSerialized(rebuilt, incomingDoc, identityMap);
+				return rebuilt;
+			}
+			let kept = /* @__PURE__ */ new Set();
+			await api.updateFromSerialized(instance, incomingDoc, identityMap, void 0, (fieldName) => {
+				let keep = this.#pinnedFields(instance).has(fieldName) || pinnedAtRead.has(fieldName) && !this.#optimisticFields.get(instance[localId])?.has(fieldName);
+				if (keep) kept.add(fieldName);
+				return keep;
+			});
+			if (this.#identityEpoch !== identityEpoch) return;
+			if (kept.size > 0) {
+				realmEventsLogger.debug(`reload of ${instance.id} keeps local edits to ${[...kept].join(", ")}`);
+				this.doAutoSave(instance);
+			}
+			return instance;
+		});
+	}
+	subscribeToRealm(url) {
+		if (this.hostModeService.isActive) return;
+		let realmURL = this.realm.realmOf(url);
+		if (!realmURL) {
+			console.warn(`could not determine realm for card ${url instanceof URL ? url.href : url} when trying to subscribe to realm`);
+			return;
+		}
+		if (!this.subscriptions.get(realmURL)) this.subscriptions.set(realmURL, { unsubscribe: this.messageService.subscribe(realmURL, (event) => this.handleInvalidations(event)) });
+	}
+	async loadPatchedInstances(patchData, relativeTo) {
+		if (!patchData?.relationships) return {};
+		let result = {};
+		await Promise.all(Object.entries(patchData.relationships).map(async ([fieldName, rel]) => {
+			if (Array.isArray(rel)) {
+				let instances = [];
+				await Promise.all(rel.map(async (r) => {
+					let instance = await this.loadRelationshipInstance(r, relativeTo);
+					if (instance) instances.push(instance);
+				}));
+				result[fieldName] = instances;
+			} else {
+				let instance = await this.loadRelationshipInstance(rel, relativeTo);
+				if (instance) result[fieldName] = instance;
+			}
+		}));
+		return result;
+	}
+	async loadRelationshipInstance(rel, relativeTo) {
+		if (!rel.links?.self) return;
+		let id = rel.links.self;
+		let instance = await this.getCardInstance({ idOrDoc: this.network.virtualNetwork.resolveURL(id, relativeTo).href });
+		return isCardInstance(instance) ? instance : void 0;
+	}
+	async withTestWaiters(label, cb) {
+		let token = waiter.beginAsync(void 0, label);
+		try {
+			let result = await cb();
+			if (isTesting()) await this.cardService.cardsSettled();
+			return result;
+		} finally {
+			waiter.endAsync(token);
+		}
+	}
+};
+function processCardError(url, error, readType = "card") {
+	let httpStatus = typeof error?.status === "number" ? error.status : void 0;
+	let errorResponse;
+	let body = errorResponseBody(error);
+	if (body) errorResponse = formattedError(url, error, body.errors?.[0]);
+	else switch (error.status) {
+		case 404:
+			errorResponse = formattedError(url, error, notFoundError(url, readType));
+			break;
+		default: errorResponse = formattedError(url, error, void 0);
+	}
+	if (httpStatus != null && httpStatus !== 404) {
+		let cardError = errorResponse.errors[0];
+		if (cardError?.status === 404) cardError.status = httpStatus;
+	}
+	return errorResponse;
+}
+function errorResponseBody(error) {
+	if (typeof error?.responseText !== "string") return;
+	let parsed;
+	try {
+		parsed = JSON.parse(error.responseText);
+	} catch {
+		return;
+	}
+	return parsed != null && typeof parsed === "object" ? parsed : void 0;
+}
+function notFoundError(url, readType) {
+	let { title, noun } = readType === "file-meta" ? {
+		title: "File Not Found",
+		noun: "file"
+	} : {
+		title: "Card Not Found",
+		noun: "card"
+	};
+	return {
+		status: 404,
+		title,
+		message: `The ${noun} ${url} does not exist`
+	};
+}
+function replacePrimitiveValues(api, merged, patch, owner) {
+	let fields = api.getFields(owner, { includeComputeds: true });
+	for (let [name, source] of Object.entries(patch)) {
+		if (!isPlainRecord(source) || !Object.hasOwn(fields, name)) continue;
+		let field = fields[name];
+		if (api.primitive in field.card) {
+			merged[name] = cloneDeep(source);
+			continue;
+		}
+		let target = merged[name];
+		let value = owner[name];
+		if (field.fieldType !== "contains" || !isPlainRecord(target) || !(value instanceof api.BaseDef)) continue;
+		replacePrimitiveValues(api, target, source, value);
+	}
+}
+function isPlainRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function needsServerStateMerge(instance, serverState) {
+	return instance.id !== serverState.data.id || !isEqual(instance[meta]?.realmInfo, serverState.data.meta.realmInfo);
+}
+function isResolvableInstanceId(id, vn) {
+	return vn.isRegisteredPrefix(id) || id.startsWith("http://") || id.startsWith("https://");
+}
+function asURL(urlOrDoc, vn) {
+	let id = typeof urlOrDoc === "string" ? urlOrDoc.replace(/\.json$/, "") : void 0;
+	if (id === void 0) {
+		id = urlOrDoc.data.id;
+		if (id == null) return;
+	}
+	return isLocalId(id) ? id : vn.keyForIdentifier(id);
+}
+function isSystemCardDefaultId(id, idOrDoc, errorId) {
+	return [
+		id,
+		typeof idOrDoc === "string" ? idOrDoc : idOrDoc?.data?.id,
+		errorId
+	].filter(Boolean).some((candidate) => candidate.includes("/SystemCard/default"));
+}
+async function withStubbedRenderTimers(cb) {
+	if (typeof window === "undefined" || isTesting()) return await cb();
+	let restore = enableRenderTimerStub();
+	try {
+		return await withTimersBlocked(cb);
+	} finally {
+		restore();
+	}
+}
+function resolveDocUrl(id, realm, local) {
+	if (id) return id;
+	if (!realm) throw new Error("Cannot resolve target url without a realm");
+	let path = new RealmPaths(ri(realm));
+	if (local) return path.directoryRRI(local);
+	return path.url;
+}
+//#endregion
+export { resolveOutboundJobPriority as n, store_exports as r, StoreService as t };