@warp-drive/core 5.9.0-beta.1 → 5.9.0-beta.3

package/dist/signals/-leaked.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"-leaked.d.ts","names":[],"sources":["../../src/signals/page-cache.ts","../../src/signals/pagination-cache.ts","../../src/signals/pagination-state.ts","../../src/signals/pagination-links.ts","../../src/signals/pagination-subscription.ts","../../src/signals/pagination-links-subscription.ts","../../src/signals/reactivity/signal.ts"],"mappings":"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"}

package/dist/signals/-leaked.js

@@ -1,3 +1,3 @@
-import { E as waitFor, S as withSignalStore, b as notifyInternalSignal, c as defineSignal, d as gate, f as memoized, n as DISPOSE, o as defineGate, p as signal, s as defineNonEnumerableSignal, u as entangleSignal, v as getOrCreateInternalSignal, x as peekInternalSignal, y as makeInitializer } from "../-private-HjaQ1wp1.js";
+import { D as notifyInternalSignal, E as makeInitializer, N as waitFor, O as peekInternalSignal, T as getOrCreateInternalSignal, _ as entangleSignal, a as getPaginationState, b as signal, c as getPaginationCache, h as defineSignal, i as getPaginationLinks, k as withSignalStore, l as DISPOSE, m as defineNonEnumerableSignal, n as createPaginationLinksSubscription, o as clearPaginationCache, p as defineGate, r as createPaginationSubscription, s as defaultPageHints, v as gate, y as memoized } from "../-private-BL9zXgJB.js";
 
-export { DISPOSE, defineGate, defineNonEnumerableSignal, defineSignal, entangleSignal, gate, getOrCreateInternalSignal, makeInitializer, memoized, notifyInternalSignal, peekInternalSignal, signal, waitFor, withSignalStore };
+export { DISPOSE, clearPaginationCache, createPaginationLinksSubscription, createPaginationSubscription, defaultPageHints, defineGate, defineNonEnumerableSignal, defineSignal, entangleSignal, gate, getOrCreateInternalSignal, getPaginationCache, getPaginationLinks, getPaginationState, makeInitializer, memoized, notifyInternalSignal, peekInternalSignal, signal, waitFor, withSignalStore };

package/dist/{src-Dex_phWI.js → src-s5HHjglV.js}

@@ -1,10 +1,10 @@
-import { a as setTransient, i as peekUniversalTransient, o as setUniversalTransient, r as peekTransient, t as getOrSetGlobal } from "./-private-DMzvF_Q6.js";
-import { C as ARRAY_SIGNAL, D as willSyncFlushWatchers, E as waitFor, S as withSignalStore, _ as createInternalSignal, a as createSignalDescriptor, b as notifyInternalSignal, c as defineSignal, g as createInternalMemo, h as consumeInternalSignal, l as entangleInitiallyStaleSignal, m as Signals, o as defineGate, u as entangleSignal, v as getOrCreateInternalSignal, w as OBJECT_SIGNAL, x as peekInternalSignal } from "./-private-HjaQ1wp1.js";
+import { a as setTransient, i as peekUniversalTransient, o as setUniversalTransient, r as peekTransient, t as getOrSetGlobal } from "./-private-Cxa8cMBj.js";
+import { A as ARRAY_SIGNAL, C as createInternalMemo, D as notifyInternalSignal, N as waitFor, O as peekInternalSignal, P as willSyncFlushWatchers, S as consumeInternalSignal, T as getOrCreateInternalSignal, _ as entangleSignal, f as createSignalDescriptor, g as entangleInitiallyStaleSignal, h as defineSignal, j as OBJECT_SIGNAL, k as withSignalStore, p as defineGate, w as createInternalSignal, x as Signals } from "./-private-BL9zXgJB.js";
 import { EnableHydration, STRUCTURED, SkipCache } from "./types/request.js";
 import { CACHE_OWNER, DEBUG_CLIENT_ORIGINATED, DEBUG_KEY_TYPE, DEBUG_STALE_CACHE_OWNER } from "./types/identifier.js";
-import { a as upgradePromise, c as executeNextHandler, d as getRequestResult, f as setPromiseResult, l as clearRequestResult, m as assertValidRequest, o as DOMError, p as cloneResponseProperties, s as IS_CACHE_HANDLER, t as withBrand } from "./request--vRFALbQ.js";
+import { a as upgradePromise, c as executeNextHandler, d as getRequestResult, f as setPromiseResult, l as clearRequestResult, m as assertValidRequest, o as DOMError, p as cloneResponseProperties, s as IS_CACHE_HANDLER, t as withBrand } from "./request-z2NByNx0.js";
 import { getRuntimeConfig, setIsMaybeMirage, setLogging } from "./types/runtime.js";
-import { a as SOURCE, i as Destroy, n as Commit, r as Context, t as Checkout } from "./-private-b1g4dhl0.js";
+import { a as SOURCE, i as Destroy, n as Commit, r as Context, t as Checkout } from "./-private-xK1KgxZJ.js";
 import { dasherize } from "./utils/string.js";
 import { RecordStore, Type } from "./types/symbols.js";
 import { isResourceSchema } from "./types/schema/fields.js";
@@ -1210,13 +1210,18 @@ var CacheCapabilitiesManager = class {
 		return this.cacheKeyManager;
 	}
 	/** @internal */
-	_scheduleNotification(identifier, key) {
+	_scheduleNotification(identifier, key, channel) {
 		let pending = this._pendingNotifies.get(identifier);
 		if (!pending) {
-			pending = /* @__PURE__ */ new Set();
+			pending = /* @__PURE__ */ new Map();
 			this._pendingNotifies.set(identifier, pending);
 		}
-		pending.add(key);
+		let channels = pending.get(key);
+		if (!channels) {
+			channels = /* @__PURE__ */ new Set();
+			pending.set(key, channels);
+		}
+		channels.add(channel);
 		if (this._willNotify === true) return;
 		this._willNotify = true;
 		if (this._store._cbs) this._store._schedule("notify", () => this._flushNotifications());
@@ -1228,11 +1233,24 @@ var CacheCapabilitiesManager = class {
 		const pending = this._pendingNotifies;
 		this._pendingNotifies = /* @__PURE__ */ new Map();
 		this._willNotify = false;
-		pending.forEach((set, identifier) => {
-			this._store.notifications.notify(identifier, "relationships", set);
+		pending.forEach((channelsByKey, identifier) => {
+			const keysByChannel = /* @__PURE__ */ new Map();
+			channelsByKey.forEach((channels, key) => {
+				channels.forEach((channel) => {
+					let keys = keysByChannel.get(channel);
+					if (!keys) {
+						keys = /* @__PURE__ */ new Set();
+						keysByChannel.set(channel, keys);
+					}
+					keys.add(key);
+				});
+			});
+			keysByChannel.forEach((keys, channel) => {
+				this._store.notifications.notify(identifier, "relationships", keys, channel);
+			});
 		});
 	}
-	notifyChange(identifier, namespace, key) {
+	notifyChange(identifier, namespace, key, channel) {
 		macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) && ((test) => {
 			if (!test) throw new Error(`Expected a stable identifier`);
 		})(isResourceKey(identifier) || isRequestKey(identifier));
@@ -1240,10 +1258,10 @@ var CacheCapabilitiesManager = class {
 			macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) && ((test) => {
 				if (!test) throw new Error(`Expected a single relationship key`);
 			})(typeof key === "string");
-			this._scheduleNotification(identifier, key);
+			this._scheduleNotification(identifier, key, channel);
 			return;
 		}
-		this._store.notifications.notify(identifier, namespace, key);
+		this._store.notifications.notify(identifier, namespace, key, channel);
 	}
 	get schema() {
 		return this._store.schema;
@@ -2001,6 +2019,52 @@ function isCacheOperationValue(value) {
 * @since 5.9.0
 * @public
 */
+/**
+* A change to a resource's `attributes` or `relationships` can be relevant to
+* a "local" view of the resource (its mutable/editable state), a "remote" view
+* (its last-known-persisted state), or both.
+*
+* Each view subscribes to its own channel and, when notified, re-pulls its own
+* projection of the data: a remote-only reader (e.g. PolarisMode's default
+* immutable record) subscribes `'remote'` and re-reads remote state; an
+* editable/reconciled reader (a legacy record, or an editable checkout)
+* subscribes `'local'` (the same as omitting the channel) and re-reads local
+* state. A notifier that knows which projection changed tags the notification
+* with that channel; each tag is delivered only to that channel's subscribers.
+* A change affecting both projections is either notified unscoped or once per
+* channel. An unscoped notify cannot guarantee which view changed, so it
+* reaches every subscriber -- this keeps every pre-channel `notify` callsite
+* (and any custom cache that doesn't know about channels) fully compatible.
+*
+* The full delivery matrix:
+*
+* | notify ↓ subscribe → | `'local'` | `'remote'` | omitted (= `'local'`) |
+* | -------------------- | --------- | ---------- | --------------------- |
+* | `'local'`            | ✅        | ❌         | ✅                    |
+* | `'remote'`           | ❌        | ✅         | ❌                    |
+* | omitted              | ✅        | ✅         | ✅                    |
+*
+* Channel only applies to the `'attributes'` and `'relationships'`
+* notification types. All other types (`'errors'`,
+* `'identity'`, `'state'`, and the various `CacheOperation`/
+* `DocumentCacheOperation` values) are never filtered by channel since they
+* have no local/remote duality.
+*
+* @public
+*/
+/**
+* Well-known sentinel recorded in a {@link ChannelSet} for a touch that
+* carried no channel. An unscoped touch always reaches every subscriber
+* regardless of what channel(s) the same key was also touched with, so its
+* presence in the set short-circuits channel filtering.
+*/
+const UnscopedChannel = getOrSetGlobal("UnscopedChannel", Symbol("unscoped"));
+/**
+* The set of channels (if any) a given `'attributes'`/`'relationships'` touch
+* was tagged with while buffered. {@link UnscopedChannel} is included in this
+* set when at least one of the coalesced touches was itself unscoped (no
+* channel given).
+*/
 function keyToString(key) {
 	return key instanceof Set ? Array.from(key).join(", ") : key || "";
 }
@@ -2010,44 +2074,83 @@ function keyToString(key) {
 * a single flush window.
 *
 * The buffer is a `Map` from namespace (`'attributes'`, `'relationships'`,
-* `'state'`, etc.) to either a `Set<string>` of pending keys or `null`. Using
-* a `Map` means the *first* time a namespace is touched during this flush
-* window fixes its position in iteration order; every subsequent touch to
-* that same namespace (regardless of how much later, or how many other
-* namespaces fired in between) updates its value in place without moving it.
-* This preserves the relative order in which *different* namespaces first
-* fired, while intentionally not tracking the arrival order of repeated
-* touches to the *same* namespace - those are provably safe to coalesce
-* because subscribers never receive anything about a notification beyond
-* `(cacheKey, type, key?)`.
-*
-* For `'attributes'`/`'relationships'`, `null` is a wildcard meaning "an
-* unspecified set of keys changed" - a strict superset of any specific key
-* list, per the existing contract of {@link CacheCapabilitiesManager.notifyChange}.
-* A keyless call always upgrades the bucket to `null`, discarding any
-* specific keys already collected; a keyed call is a no-op once the bucket
-* is already `null`.
-*
-* For every other namespace, subscriber callbacks never receive a key at
-* all, so `null` is used purely as a "this namespace fired at least once"
-* presence marker; multiple firings within one flush all collapse to the
-* same single marker.
+* `'state'`, etc.) to a "bucket". Using a `Map` means the *first* time a
+* namespace is touched during this flush window fixes its position in
+* iteration order; every subsequent touch to that same namespace (regardless
+* of how much later, or how many other namespaces fired in between) updates
+* its value in place without moving it. This preserves the relative order in
+* which *different* namespaces first fired, while intentionally not tracking
+* the arrival order of repeated touches to the *same* namespace - those are
+* provably safe to coalesce because subscribers never receive anything about
+* a notification beyond `(cacheKey, type, key?)`.
+*
+* For every namespace other than `'attributes'`/`'relationships'`, subscriber
+* callbacks never receive a key at all (and channel never applies to them -
+* see {@link NotificationChannel}), so the bucket is simply `null`, used
+* purely as a "this namespace fired at least once" presence marker; multiple
+* firings within one flush all collapse to the same single marker.
+*
+* For `'attributes'`/`'relationships'`, a key (or channel) *does* matter, so
+* the bucket is one of:
+* - a `Map<string, ChannelSet>`: the normal case, mapping each specific key
+*   touched to the set of channels it was touched with ({@link UnscopedChannel}
+*   in that set means at least one of those touches was itself unscoped).
+* - a `ChannelSet` directly: a wildcard meaning "an unspecified set of keys
+*   changed" - a strict superset of any specific key list, per the existing
+*   contract of {@link CacheCapabilitiesManager.notifyChange} - tagged with
+*   the set of channels any of the coalesced keyless (or post-wildcard
+*   keyed) touches carried.
+*
+* A keyless call always upgrades the bucket to the wildcard form. When
+* upgrading away from a `Map`, every channel ever recorded against any of
+* its specific keys is folded into the new wildcard `ChannelSet` - the
+* wildcard must remain a superset not just key-wise but channel-wise too, or
+* a channel-scoped subscriber that would have heard about one of those
+* specific keys could silently stop hearing about it once the bucket flips
+* to wildcard. Once a bucket is a wildcard it can never downgrade back to a
+* `Map`; a keyed touch that arrives after that point still folds its channel
+* into the wildcard's `ChannelSet` (the specific key itself is discarded,
+* since the wildcard already covers it).
 */
-function mergeIntoBuffer(buffer, value, key) {
+function mergeIntoBuffer(buffer, value, key, channel) {
 	if (value !== "attributes" && value !== "relationships") {
 		buffer.set(value, null);
 		return;
 	}
 	const existing = buffer.get(value);
 	if (key === null || key === void 0) {
-		buffer.set(value, null);
+		const channels = existing instanceof Set ? existing : /* @__PURE__ */ new Set();
+		if (existing instanceof Map) for (const channelsForKey of existing.values()) for (const ch of channelsForKey) channels.add(ch);
+		channels.add(channel ?? UnscopedChannel);
+		buffer.set(value, channels);
 		return;
 	}
-	if (existing === null) return;
-	const set = existing ?? /* @__PURE__ */ new Set();
-	if (!existing) buffer.set(value, set);
-	if (key instanceof Set) for (const k of key) set.add(k);
-	else set.add(key);
+	if (existing instanceof Set) {
+		existing.add(channel ?? UnscopedChannel);
+		return;
+	}
+	const map = existing ?? /* @__PURE__ */ new Map();
+	if (!existing) buffer.set(value, map);
+	const keys = key instanceof Set ? key : [key];
+	for (const k of keys) {
+		let channels = map.get(k);
+		if (!channels) {
+			channels = /* @__PURE__ */ new Set();
+			map.set(k, channels);
+		}
+		channels.add(channel ?? UnscopedChannel);
+	}
+}
+/**
+* Given the set of channels a touch (or coalesced group of touches) was
+* recorded with, determines whether a subscriber scoped to `subscriberChannel`
+* should be delivered to (see the delivery matrix on
+* {@link NotificationChannel}): a subscriber hears a touch-set if any of its
+* touches was unscoped or tagged with the subscriber's own channel; a
+* touch-set exclusively tagged with the *other* channel is skipped.
+*/
+function shouldDeliverToChannel(channels, subscriberChannel) {
+	return channels.has(UnscopedChannel) || channels.has(subscriberChannel);
 }
 function count(label) {
 	globalThis.__WarpDriveMetricCountData[label] = (globalThis.__WarpDriveMetricCountData[label] || 0) + 1;
@@ -2124,10 +2227,23 @@ var NotificationManager = class {
 	* }
 	* ```
 	*
+	* A `channel` may be provided when subscribing to a `ResourceKey`. Its
+	* effect is that the subscription skips `'attributes'`/`'relationships'`
+	* notifications explicitly tagged with the *other* channel; unscoped
+	* notifications, and notifications for all other notification types, always
+	* reach the subscriber. Subscribing `'local'` and omitting the channel are
+	* the same thing. See {@link NotificationChannel}.
+	*
+	* | notify ↓ subscribe → | `'local'` | `'remote'` | omitted (= `'local'`) |
+	* | -------------------- | --------- | ---------- | --------------------- |
+	* | `'local'`            | ✅        | ❌         | ✅                    |
+	* | `'remote'`           | ❌        | ✅         | ❌                    |
+	* | omitted              | ✅        | ✅         | ✅                    |
+	*
 	* @public
 	* @return an opaque token to be used with unsubscribe
 	*/
-	subscribe(cacheKey, callback) {
+	subscribe(cacheKey, callback, channel) {
 		macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) && ((test) => {
 			if (!test) throw new Error(`Expected not to be destroyed`);
 		})(!this.isDestroyed);
@@ -2142,6 +2258,7 @@ var NotificationManager = class {
 			if (!test) throw new Error(`cannot subscribe with the same callback twice`);
 		})(!callbacks || !callbacks.includes(callback));
 		callback.for = cacheKey;
+		callback.channel = channel ?? "local";
 		if (!callbacks) {
 			callbacks = [];
 			this._cache.set(cacheKey, callbacks);
@@ -2171,13 +2288,29 @@ var NotificationManager = class {
 	* buffer/flush scheduling) only once for the whole batch instead of once
 	* per key.
 	*
+	* A `channel` may be supplied for the `'attributes'`/`'relationships'`
+	* namespaces. Tagging a notification `'local'` declares "only the local
+	* (reconciled/editable) view changed"; tagging it `'remote'` declares "only
+	* the remote view changed". Each tag is delivered only to that channel's
+	* subscribers. Omitting the channel reaches every subscriber regardless of
+	* its channel. See {@link NotificationChannel}.
+	*
+	* | notify ↓ subscribe → | `'local'` | `'remote'` | omitted (= `'local'`) |
+	* | -------------------- | --------- | ---------- | --------------------- |
+	* | `'local'`            | ✅        | ❌         | ✅                    |
+	* | `'remote'`           | ❌        | ✅         | ❌                    |
+	* | omitted              | ✅        | ✅         | ✅                    |
+	*
 	* @private
 	*/
-	notify(cacheKey, value, key) {
+	notify(cacheKey, value, key, channel) {
 		if (this.isDestroyed) return false;
 		macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) && ((test) => {
 			if (!test) throw new Error(`Notify does not accept a key argument for the namespace '${value}'. Received key '${keyToString(key)}'.`);
 		})(!key || value === "attributes" || value === "relationships");
+		macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) && ((test) => {
+			if (!test) throw new Error(`Notify does not accept a channel argument for the namespace '${value}'. Received channel '${channel || ""}'.`);
+		})(!channel || value === "attributes" || value === "relationships");
 		if (!isResourceKey(cacheKey) && !isRequestKey(cacheKey)) {
 			if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_NOTIFICATIONS)) {
 				if (getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_NOTIFICATIONS) console.log(`Notifying: Expected to receive a stable Identifier to notify '${value}' '${keyToString(key)}' with, but ${String(cacheKey)} is not in the cache`, cacheKey);
@@ -2191,7 +2324,7 @@ var NotificationManager = class {
 				buffer = /* @__PURE__ */ new Map();
 				this._buffered.set(cacheKey, buffer);
 			}
-			mergeIntoBuffer(buffer, value, key);
+			mergeIntoBuffer(buffer, value, key, channel);
 			if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_METRIC_COUNTS)) {
 				if (getGlobalConfig().WarpDrive.debug.LOG_METRIC_COUNTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_METRIC_COUNTS) count(`notify ${"type" in cacheKey ? cacheKey.type : "<document>"} ${value} ${keyToString(key)}`);
 			}
@@ -2232,8 +2365,9 @@ var NotificationManager = class {
 		const buffered = this._buffered;
 		if (buffered.size) {
 			this._buffered = /* @__PURE__ */ new Map();
-			for (const [cacheKey, states] of buffered) for (const [value, keyOrKeys] of states) if (keyOrKeys === null) _flushNotification(this._cache, cacheKey, value, null);
-			else for (const key of keyOrKeys) _flushNotification(this._cache, cacheKey, value, key);
+			for (const [cacheKey, states] of buffered) for (const [value, bucket] of states) if (bucket === null) _flushNotification(this._cache, cacheKey, value, null);
+			else if (bucket instanceof Set) _flushNotification(this._cache, cacheKey, value, null, bucket);
+			else for (const [key, channels] of bucket) _flushNotification(this._cache, cacheKey, value, key, channels);
 		}
 		this._hasFlush = false;
 		this._onFlushCB?.();
@@ -2252,7 +2386,7 @@ var NotificationManager = class {
 *
 * @private
 */
-function _flushNotification(cache, cacheKey, value, key) {
+function _flushNotification(cache, cacheKey, value, key, channels) {
 	if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_NOTIFICATIONS)) {
 		if (getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_NOTIFICATIONS) log("notify", "", `${"type" in cacheKey ? cacheKey.type : "document"}`, cacheKey.lid, `${value}`, key || "");
 	}
@@ -2265,6 +2399,10 @@ function _flushNotification(cache, cacheKey, value, key) {
 	const callbacks = cache.get(cacheKey);
 	if (!callbacks || !callbacks.length) return false;
 	callbacks.forEach((cb) => {
+		if (channels) {
+			const subscriberChannel = cb.channel;
+			if (!shouldDeliverToChannel(channels, subscriberChannel)) return;
+		}
 		cb(cacheKey, value, key);
 	});
 	return true;
@@ -3181,7 +3319,7 @@ var RecordArrayManager = class {
 	}
 	getCollection(config) {
 		if ("requestKey" in config && this._keyedArrays.has(config.requestKey.lid)) return this._keyedArrays.get(config.requestKey.lid);
-		let array = null;
+		let array;
 		if ("requestKey" in config) {
 			const options = {
 				store: this.store,
@@ -4118,7 +4256,7 @@ var Store = class extends BaseClass {
 		this._join(() => {
 			const normalizedModelName = normalizeModelName(type);
 			const properties = { ...inputProperties };
-			let id = null;
+			let id;
 			if (properties.id === null || properties.id === void 0) {
 				const adapter = this.adapterFor?.(normalizedModelName, true);
 				if (adapter && adapter.generateIdForRecord) id = properties.id = coerceId(adapter.generateIdForRecord(this, normalizedModelName, properties));
@@ -6312,7 +6450,7 @@ var ManyArrayManager = class {
 		if (rawValue.meta) array.meta = rawValue.meta;
 		if (rawValue.links) array.links = rawValue.links;
 		const currentState = array[Context].source;
-		if (currentState !== rawValue.data) {
+		if (rawValue.data !== void 0 && currentState !== rawValue.data) {
 			currentState.length = 0;
 			fastPush(currentState, rawValue.data);
 		}
@@ -6370,7 +6508,7 @@ function getHasManyField(context) {
 		if (cached) return cached;
 		const { editable, resourceKey } = context;
 		const { cache } = store;
-		const rawValue = cache.getRelationship(resourceKey, getFieldCacheKeyStrict(field));
+		const rawValue = editable ? cache.getRelationship(resourceKey, getFieldCacheKeyStrict(field)) : cache.getRemoteRelationship(resourceKey, getFieldCacheKeyStrict(field));
 		if (!rawValue) return null;
 		const managedArray = createLegacyManyArray({
 			store,
@@ -7011,7 +7149,7 @@ var ReactiveResource = class ReactiveResource {
 					}
 				}
 			}
-		});
+		}, context.legacy || context.editable ? "local" : "remote");
 		const proxy = new Proxy(this, {
 			ownKeys() {
 				const identityKey = identityField?.name;
@@ -8554,6 +8692,7 @@ const ERROR_STATUS_CODE_FOR = /* @__PURE__ */ new Map([
 * ```
 *
 * @public
+* @badge Handler
 */
 const Fetch = { 
 /**
@@ -9085,4 +9224,4 @@ function useRecommendedStore(options, StoreKlass = Store) {
 
 //#endregion
 export { setIdentifierResetMethod as A, setRecordIdentifier as C, isResourceKey as D, isRequestKey as E, ensureStringId as F, log as I, logGroup as L, setKeyInfoForResource as M, normalizeModelName as N, setIdentifierForgetMethod as O, coerceId as P, recordIdentifierFor as S, assertPrivateCapabilities as T, isPrivateStore as _, fromIdentity as a, StoreMap as b, instantiateRecord as c, commit as d, createLegacyManyArray as f, assertPrivateStore as g, Store as h, SchemaService as i, setIdentifierUpdateMethod as j, setIdentifierGenerationMethod as k, teardownRecord as l, CacheHandler as m, RequestManager as n, registerDerivations as o, constructResource as p, Fetch as r, withDefaults as s, useRecommendedStore as t, checkout as u, RecordArrayManager as v, storeFor as w, _clearCaches as x, fastPush as y };
-//# sourceMappingURL=src-Dex_phWI.js.map
+//# sourceMappingURL=src-s5HHjglV.js.map