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

package/dist/unpkg/{dev-deprecated/-private-DL4tfrv9.js.map → dev/-private-CUkeqUhO.js.map}

@@ -1 +1 @@
-{"version":3,"file":"-private-DL4tfrv9.js","names":["getOrSetGlobal","SOURCE","Symbol","Destroy","dispose","for","Checkout","Commit","Context"],"sources":["../../../src/reactive/-private/symbols.ts"],"sourcesContent":["///////////////////\n///// WARNING /////\n///////////////////\n\nimport { getOrSetGlobal } from '../../types/-private';\n\n// Great, got your attention with that warning didn't we?\n// Good. Here's the deal: typescript treats symbols as unique types.\n// If by accident a module creating a symbol is processed more than\n// once, the symbol will be different in each processing. This will\n// cause a type error.\n// It could also cause a runtime error if the symbol is used innapropriately.\n// However, this case is extremely hard to hit and would require other things\n// to go wrong first.\n//\n// So, why do the warning? And why do we lie about the types of the symbols?\n//\n// Because we intentionally create multiple copies of them within the types\n// at build time. This is because we rollup our d.ts files in order to give\n// our consumers a better experience.\n//\n// However, no tool today supports rolling up d.ts files with multiple entry\n// points correctly. The tool we use currently (vite-plugin-dts) uses @microsoft/api-extractor\n// which creates a fully unique stand-alone types file per-entry-point. Thus\n// every entry point that uses one of these symbols somewhere will have accidentally\n// created a new symbol type.\n//\n// This cast allows us to rollup these types using this tool while not encountering\n// the unique symbol type issue.\n//\n// Note that none of these symbols are part of the public API, these are used for\n// debugging DX and as a safe way to provide an intimate contract on public objects.\n\nexport const SOURCE: '___(unique) Symbol(SOURCE)' = getOrSetGlobal('SOURCE', Symbol('#source'));\n\nexport const Destroy: '___(unique) Symbol(Destroy)' = getOrSetGlobal(\n  'Destroy',\n  Symbol.dispose || Symbol.for('Dispose')\n);\n/**\n * Symbol for the method used to request a mutable copy of an otherwise\n * immutable {@link ReactiveResource}.\n *\n * @deprecated use the {@link checkout} utility function instead.\n */\nexport const Checkout: '___(unique) Symbol(Checkout)' = getOrSetGlobal('Checkout', Symbol('Checkout'));\nexport const Commit: '___(unique) Symbol(Commit)' = getOrSetGlobal('Commit', Symbol('Commit'));\n\n/**\n * Symbol used to stash the internal field/resource context (schema, store,\n * mutability, etc.) on a {@link ReactiveResource} or reactive field instance.\n */\nexport const Context: '___(unique) Symbol(Context)' = getOrSetGlobal('Context', Symbol('Context'));\n"],"mappings":";;;AAiCA,MAAaC,SAAuCD,eAAe,UAAUE,OAAO,SAAS,CAAC;AAE9F,MAAaC,UAAyCH,eACpD,WACAE,OAAOE,WAAWF,OAAOG,IAAI,SAAS,CACxC;;;;;;;AAOA,MAAaC,WAA2CN,eAAe,YAAYE,OAAO,UAAU,CAAC;AACrG,MAAaK,SAAuCP,eAAe,UAAUE,OAAO,QAAQ,CAAC;;;;;AAM7F,MAAaM,UAAyCR,eAAe,WAAWE,OAAO,SAAS,CAAC"}
+{"version":3,"file":"-private-CUkeqUhO.js","names":["getOrSetGlobal","SOURCE","Symbol","Destroy","dispose","for","Checkout","Commit","Context"],"sources":["../../../src/reactive/-private/symbols.ts"],"sourcesContent":["///////////////////\n///// WARNING /////\n///////////////////\n\nimport { getOrSetGlobal } from '../../types/-private';\n\n// Great, got your attention with that warning didn't we?\n// Good. Here's the deal: typescript treats symbols as unique types.\n// If by accident a module creating a symbol is processed more than\n// once, the symbol will be different in each processing. This will\n// cause a type error.\n// It could also cause a runtime error if the symbol is used innapropriately.\n// However, this case is extremely hard to hit and would require other things\n// to go wrong first.\n//\n// So, why do the warning? And why do we lie about the types of the symbols?\n//\n// Because we intentionally create multiple copies of them within the types\n// at build time. This is because we rollup our d.ts files in order to give\n// our consumers a better experience.\n//\n// However, no tool today supports rolling up d.ts files with multiple entry\n// points correctly. The tool we use currently (vite-plugin-dts) uses @microsoft/api-extractor\n// which creates a fully unique stand-alone types file per-entry-point. Thus\n// every entry point that uses one of these symbols somewhere will have accidentally\n// created a new symbol type.\n//\n// This cast allows us to rollup these types using this tool while not encountering\n// the unique symbol type issue.\n//\n// Note that none of these symbols are part of the public API, these are used for\n// debugging DX and as a safe way to provide an intimate contract on public objects.\n\nexport const SOURCE: '___(unique) Symbol(SOURCE)' = getOrSetGlobal('SOURCE', Symbol('#source'));\n\nexport const Destroy: '___(unique) Symbol(Destroy)' = getOrSetGlobal(\n  'Destroy',\n  Symbol.dispose || Symbol.for('Dispose')\n);\n/**\n * Symbol for the method used to request a mutable copy of an otherwise\n * immutable {@link ReactiveResource}.\n *\n * @deprecated use the {@link checkout} utility function instead.\n */\nexport const Checkout: '___(unique) Symbol(Checkout)' = getOrSetGlobal('Checkout', Symbol('Checkout'));\nexport const Commit: '___(unique) Symbol(Commit)' = getOrSetGlobal('Commit', Symbol('Commit'));\n\n/**\n * Symbol used to stash the internal field/resource context (schema, store,\n * mutability, etc.) on a {@link ReactiveResource} or reactive field instance.\n */\nexport const Context: '___(unique) Symbol(Context)' = getOrSetGlobal('Context', Symbol('Context'));\n"],"mappings":";;;AAiCA,MAAaC,SAAuCD,eAAe,UAAUE,OAAO,SAAS,CAAC;AAE9F,MAAaC,UAAyCH,eACpD,WACAE,OAAOE,WAAWF,OAAOG,IAAI,SAAS,CACxC;;;;;;;AAOA,MAAaC,WAA2CN,eAAe,YAAYE,OAAO,UAAU,CAAC;AACrG,MAAaK,SAAuCP,eAAe,UAAUE,OAAO,QAAQ,CAAC;;;;;AAM7F,MAAaM,UAAyCR,eAAe,WAAWE,OAAO,SAAS,CAAC"}

package/dist/unpkg/{dev-deprecated/-private-2RfQ2761.js → dev/-private-D6Tw25AD.js}

@@ -1,6 +1,6 @@
 //#region package.json
 var name = "@warp-drive/core";
-var version = "5.9.0-beta.1";
+var version = "5.9.0-beta.2";
 
 //#endregion
 //#region src/types/-private.ts
@@ -108,4 +108,4 @@ function setUniversalTransient(key, value) {
 
 //#endregion
 export { setTransient as a, peekUniversalTransient as i, getOrSetUniversal as n, setUniversalTransient as o, peekTransient as r, getOrSetGlobal as t };
-//# sourceMappingURL=-private-2RfQ2761.js.map
+//# sourceMappingURL=-private-D6Tw25AD.js.map

package/dist/unpkg/dev/-private-D6Tw25AD.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"-private-D6Tw25AD.js","names":["name","version","GlobalRef","globalThis","UniversalCache","__warpDrive_universalCache","__version","GlobalSink","Error","ModuleScopedCaches","__warpDrive_ModuleScopedCaches","console","warn","getOrSetGlobal","key","value","existing","undefined","peekTransient","globalKey","setTransient","getOrSetUniversal","peekUniversalTransient","setUniversalTransient"],"sources":["../../../package.json","../../../src/types/-private.ts"],"sourcesContent":["","// in testing mode, we utilize globals to ensure only one copy exists of\n// these maps, due to bugs in ember-auto-import\nimport { DEBUG, TESTING } from '@warp-drive/core/build-config/env';\n\nimport { name, version } from '../../package.json';\n\ntype UniversalTransientKey =\n  // @warp-drive/core/request\n  'REQ_ID';\n\ntype UniversalKey =\n  | `(transient) ${UniversalTransientKey}`\n  // @warp-drive/core/request\n  | 'RequestMap'\n  | 'PromiseCache'\n  | 'RequestCache'\n  // @warp-drive/core-types/request\n  | 'SkipCache'\n  | 'EnableHydration'\n  // @warp-drive/core-types/runtime\n  | 'WarpDriveRuntimeConfig';\n\ntype TransientKey =\n  // @warp-drive/core/graph\n  | 'transactionRef'\n  // @warp-drive/core/store\n  | 'configuredGenerationMethod'\n  | 'configuredUpdateMethod'\n  | 'configuredForgetMethod'\n  | 'configuredResetMethod'\n  | 'configuredKeyInfoMethod'\n  | 'signalHooks';\n\ntype GlobalKey =\n  | `(transient) ${TransientKey}`\n  // @warp-drive/legacy/adapter\n  | 'AdapterError'\n  | 'InvalidError'\n  | 'TimeoutError'\n  | 'AbortError'\n  | 'UnauthorizedError'\n  | 'ForbiddenError'\n  | 'NotFoundError'\n  | 'ConflictError'\n  | 'ServerError'\n  // @warp-drive/core/store/reactivity\n  | '#{}'\n  | '#[]'\n  | 'Signals'\n  // @warp-drive/legacy LegacySupport\n  | 'AvailableShims'\n  // @warp-drive/core RecordArrayManager\n  | 'FAKE_ARR'\n  // @warp-drive/core ReactiveArray\n  | '#source'\n  | '#update'\n  | '#notify'\n  | 'IS_COLLECTION'\n  // @warp-drive/core RequestCache\n  | 'Touching'\n  | 'RequestPromise'\n  // @warp-drive/legacy/compat FetchManager\n  | 'SaveOp'\n  // @warp-drive/legacy Model\n  | 'LEGACY_SUPPORT'\n  | 'LegacySupport'\n  // @warp-drive/core/graph\n  | 'Graphs'\n  // @warp-drive/core/request\n  | 'IS_FROZEN'\n  | 'IS_CACHE_HANDLER'\n  // @warp-drive/utilities\n  | 'CONFIG'\n  // @warp-drive/core CacheKeyManager\n  | 'DEBUG_MAP'\n  | 'IDENTIFIERS'\n  | 'DOCUMENTS'\n  // @warp-drive/core InstanceCache\n  | 'RecordCache'\n  | 'StoreMap'\n  // @warp-drive/core/types/symbols\n  | 'Store'\n  | '$type'\n  | 'TransformName'\n  | 'RequestSignature'\n  // @warp-drive/core/types/request\n  | 'IS_FUTURE'\n  | 'DOC'\n  // @warp-drive/core NotificationManager\n  | 'UnscopedChannel'\n  // @warp-drive/core/reactive\n  | 'ManagedArrayMap'\n  | 'ManagedObjectMap'\n  | 'Support'\n  | 'SOURCE'\n  | 'Destroy'\n  | 'Checkout'\n  | 'Commit'\n  | 'Context';\n\ntype ModuleScopedCaches = Record<GlobalKey, unknown>;\n\nconst GlobalRef = globalThis as unknown as Record<\n  string,\n  {\n    __warpDrive_ModuleScopedCaches?: ModuleScopedCaches;\n    __warpDrive_hasOtherCopy?: boolean;\n    __version: string;\n  }\n> & {\n  __warpDrive_universalCache: Record<UniversalKey, unknown>;\n};\nconst UniversalCache = (GlobalRef.__warpDrive_universalCache =\n  GlobalRef.__warpDrive_universalCache ?? ({} as Record<UniversalKey, unknown>));\n\n// in order to support mirror packages, we ensure that each\n// unique package name has its own global cache\nGlobalRef[name] = GlobalRef[name] ?? { __version: version };\nconst GlobalSink = GlobalRef[name];\n\nif (DEBUG) {\n  if (GlobalSink.__version !== version) {\n    throw new Error('Multiple versions of WarpDrive detected, the application will malfunction.');\n  }\n}\n\nconst ModuleScopedCaches = GlobalSink.__warpDrive_ModuleScopedCaches ?? ({} as ModuleScopedCaches);\nif (TESTING) {\n  if (!GlobalSink.__warpDrive_ModuleScopedCaches) {\n    GlobalSink.__warpDrive_ModuleScopedCaches = ModuleScopedCaches;\n  } else {\n    // oxlint-disable-next-line no-console\n    console.warn(`\nMultiple copies of WarpDrive have been detected. This may be due to a bug in ember-auto-import\n  in which test assets get their own copy of some v2-addons. This can cause the application to\n  malfunction as each copy will maintain its own separate state.`);\n  }\n} else {\n  if (GlobalSink.__warpDrive_hasOtherCopy) {\n    throw new Error('Multiple copies of WarpDrive detected, the application will malfunction.');\n  }\n  GlobalSink.__warpDrive_hasOtherCopy = true;\n}\n\ntype UniqueSymbol<T extends string> = `___(unique) Symbol(${T})`;\ntype UniqueSymbolOr<T, K extends string> = T extends symbol ? UniqueSymbol<K> : T;\n\n/**\n * Coordinates creation of a singleton `value` (e.g. a symbol, WeakMap, or\n * error class) for `key` so that duplicate copies of this package loaded\n * into the same process observe the same instance instead of each creating\n * their own.\n *\n * In `TESTING` builds this stores/reads `value` from a cache namespaced to\n * this package's name on `globalThis` (see the file-level comments above for\n * why this is necessary). Outside of `TESTING`, only one copy of the package\n * is expected to exist, so this is a no-op that always returns `value`\n * unchanged.\n *\n * The return type lies about symbols being unique to work around the d.ts\n * rollup issue described in `reactive/-private/symbols.ts`.\n *\n * @private\n */\nexport function getOrSetGlobal<T, K extends GlobalKey>(key: K, value: T): UniqueSymbolOr<T, K> {\n  if (TESTING) {\n    const existing = ModuleScopedCaches[key];\n    if (existing === undefined) {\n      return (ModuleScopedCaches[key] = value) as UniqueSymbolOr<T, K>;\n    } else {\n      return existing as UniqueSymbolOr<T, K>;\n    }\n  } else {\n    return value as UniqueSymbolOr<T, K>;\n  }\n}\n\n/**\n * Reads back the current value stored for `key` by {@link setTransient}, or\n * `null` if nothing has been stored yet.\n *\n * Unlike {@link getOrSetGlobal}, this always reads through the same\n * package-namespaced cache regardless of the `TESTING` flag, since this is\n * used for genuinely mutable state (not just singleton values) that must\n * stay in sync across any duplicate copies of this package.\n *\n * @private\n */\nexport function peekTransient<T>(key: TransientKey): T | null {\n  const globalKey: `(transient) ${TransientKey}` = `(transient) ${key}`;\n  return (ModuleScopedCaches[globalKey] as T) ?? null;\n}\n\n/**\n * Stores `value` for `key`, overwriting whatever was previously stored, so\n * that it can later be read back via {@link peekTransient}.\n *\n * See {@link peekTransient} for details on when/why this cache is shared.\n *\n * @private\n */\nexport function setTransient<T>(key: TransientKey, value: T): T {\n  const globalKey: `(transient) ${TransientKey}` = `(transient) ${key}`;\n  return (ModuleScopedCaches[globalKey] = value);\n}\n\n/**\n * Like {@link getOrSetGlobal}, but reads/writes a cache that is shared across\n * *all* copies of WarpDrive on `globalThis`, regardless of package name.\n *\n * This is used for keys (e.g. request/promise caches) that must be\n * coordinated even across \"mirror\" packages published under different\n * names, rather than only across duplicate copies of the same package name.\n *\n * @private\n */\nexport function getOrSetUniversal<T, K extends UniversalKey>(key: K, value: T): UniqueSymbolOr<T, K> {\n  if (TESTING) {\n    const existing = UniversalCache[key];\n    if (existing === undefined) {\n      return (UniversalCache[key] = value) as UniqueSymbolOr<T, K>;\n    } else {\n      return existing as UniqueSymbolOr<T, K>;\n    }\n  } else {\n    return value as UniqueSymbolOr<T, K>;\n  }\n}\n\n/**\n * Like {@link peekTransient}, but reads from the package-name-independent\n * cache used by {@link getOrSetUniversal}. Always reads through this shared\n * cache regardless of the `TESTING` flag.\n *\n * @private\n */\nexport function peekUniversalTransient<T>(key: UniversalTransientKey): T | null {\n  const globalKey: `(transient) ${UniversalTransientKey}` = `(transient) ${key}`;\n  return (UniversalCache[globalKey] as T) ?? null;\n}\n\n/**\n * Like {@link setTransient}, but writes to the package-name-independent\n * cache used by {@link getOrSetUniversal}, so it can later be read via\n * {@link peekUniversalTransient}.\n *\n * @private\n */\nexport function setUniversalTransient<T>(key: UniversalTransientKey, value: T): T {\n  const globalKey: `(transient) ${UniversalTransientKey}` = `(transient) ${key}`;\n  return (UniversalCache[globalKey] = value);\n}\n"],"mappings":";;;;;;ACsGA,MAAME,YAAYC;AAUlB,MAAMC,iBAAkBF,UAAUG,6BAChCH,UAAUG,8BAA+B,CAAC;AAI5CH,UAAUF,QAAQE,UAAUF,SAAS,EAAEM,WAAWL,QAAQ;AAC1D,MAAMM,aAAaL,UAAUF;AAG3B,IAAIO,WAAWD,cAAcL,SAC3B,MAAM,IAAIO,MAAM,4EAA4E;AAIhG,MAAMC,qBAAqBF,WAAWG,kCAAmC,CAAC;AAExE,IAAI,CAACH,WAAWG,gCACdH,WAAWG,iCAAiCD;KAG5CE,QAAQC,KAAK;;;iEAGgD;;;;;;;;;;;;;;;;;;AA6BjE,SAAgBC,eAAuCC,KAAQC,OAAgC;CAChF;EACX,MAAMC,WAAWP,mBAAmBK;EACpC,IAAIE,aAAaC,QACf,OAAQR,mBAAmBK,OAAOC;OAElC,OAAOC;CAEX;AAGF;;;;;;;;;;;;AAaA,SAAgBE,cAAiBJ,KAA6B;CAC5D,MAAMK,YAA2C,eAAeL;CAChE,OAAQL,mBAAmBU,cAAoB;AACjD;;;;;;;;;AAUA,SAAgBC,aAAgBN,KAAmBC,OAAa;CAC9D,MAAMI,YAA2C,eAAeL;CAChE,OAAQL,mBAAmBU,aAAaJ;AAC1C;;;;;;;;;;;AAYA,SAAgBM,kBAA6CP,KAAQC,OAAgC;CACtF;EACX,MAAMC,WAAWZ,eAAeU;EAChC,IAAIE,aAAaC,QACf,OAAQb,eAAeU,OAAOC;OAE9B,OAAOC;CAEX;AAGF;;;;;;;;AASA,SAAgBM,uBAA0BR,KAAsC;CAC9E,MAAMK,YAAoD,eAAeL;CACzE,OAAQV,eAAee,cAAoB;AAC7C;;;;;;;;AASA,SAAgBI,sBAAyBT,KAA4BC,OAAa;CAChF,MAAMI,YAAoD,eAAeL;CACzE,OAAQV,eAAee,aAAaJ;AACtC"}

package/dist/unpkg/dev/configure.js

@@ -1,3 +1,3 @@
-import { T as setupSignals } from "./-private-CM1zxNws.js";
+import { M as setupSignals } from "./-private-BoSTJwp9.js";
 
 export { setupSignals };

package/dist/unpkg/dev/graph/-private.js

@@ -1,5 +1,5 @@
-import { a as setTransient, r as peekTransient, t as getOrSetGlobal } from "../-private-2RfQ2761.js";
-import { t as getGlobalConfig } from "../runtime-EoVKAhTv.js";
+import { a as setTransient, r as peekTransient, t as getOrSetGlobal } from "../-private-D6Tw25AD.js";
+import { t as getGlobalConfig } from "../runtime-DoDtzXJb.js";
 
 //#region src/graph/-private/coerce-id.ts
 function coerceId(id) {
@@ -135,7 +135,7 @@ function removeIdentifierCompletelyFromRelationship(graph, relationship, value,
 	}
 }
 /** Notifies the store that a relationship has changed, provided the relationship has been accessed and is not currently being removed. */
-function notifyChange(graph, relationship) {
+function notifyChange(graph, relationship, channel) {
 	if (!relationship.accessed) return;
 	const resourceKey = relationship.identifier;
 	const key = relationship.definition.key;
@@ -144,7 +144,7 @@ function notifyChange(graph, relationship) {
 		return;
 	}
 	if (getGlobalConfig().WarpDrive.debug.LOG_GRAPH || globalThis.getWarpDriveRuntimeConfig().debug.LOG_GRAPH) console.log(`Graph: notifying relationship change for ${String(resourceKey)} ${key}`);
-	graph.store.notifyChange(resourceKey, "relationships", key);
+	graph.store.notifyChange(resourceKey, "relationships", key, channel);
 }
 /**
 * Asserts (dev-only) that a pushed relationship data payload conforms to the JSON:API resource
@@ -682,7 +682,7 @@ function replaceRelatedRecordsLocal(graph, op, isRemote) {
 	relationship.additions = diff.add;
 	relationship.removals = diff.del;
 	relationship.localState = diff.finalState;
-	if (becameDirty && !wasDirty) notifyChange(graph, relationship);
+	if (becameDirty && !wasDirty) notifyChange(graph, relationship, "local");
 }
 function replaceRelatedRecordsRemote(graph, op, isRemote) {
 	const resourceKeys = op.value;
@@ -692,7 +692,7 @@ function replaceRelatedRecordsRemote(graph, op, isRemote) {
 		if (!test) throw new Error(`You can only '${op.op}' on a hasMany relationship. ${op.record.type}.${op.field} is a ${relationship.definition.kind}`);
 	})(isHasMany(relationship));
 	if (isRemote) graph._addToTransaction(relationship);
-	const wasDirty = relationship.isDirty;
+	relationship.isDirty;
 	if (!relationship.state.hasReceivedData) relationship.isDirty = true;
 	relationship.state.hasReceivedData = true;
 	const { definition } = relationship;
@@ -718,7 +718,8 @@ function replaceRelatedRecordsRemote(graph, op, isRemote) {
 	relationship.remoteState = diff.finalState;
 	if (diff.changed) relationship.isDirty = true;
 	relationship._diff = diff;
-	if (relationship.isDirty && !wasDirty) flushCanonical(graph, relationship);
+	if (diff.remoteOrderChanged) flushCanonical(graph, relationship, "remote");
+	if (diff.changed) flushCanonical(graph, relationship, "local");
 }
 function addToInverse(graph, resourceKey, key, value, isRemote) {
 	const relationship = graph.get(resourceKey, key);
@@ -734,11 +735,12 @@ function addToInverse(graph, resourceKey, key, value, isRemote) {
 			graph._addToTransaction(relationship);
 			if (relationship.remoteState !== null) removeFromInverse(graph, relationship.remoteState, relationship.definition.inverseKey, resourceKey, isRemote);
 			relationship.remoteState = value;
+			notifyChange(graph, relationship);
 		}
 		if (relationship.localState !== value) {
 			if (!isRemote && relationship.localState) removeFromInverse(graph, relationship.localState, relationship.definition.inverseKey, resourceKey, isRemote);
 			relationship.localState = value;
-			notifyChange(graph, relationship);
+			if (!isRemote) notifyChange(graph, relationship, "local");
 		}
 	} else if (isHasMany(relationship)) {
 		if (isRemote) {
@@ -755,7 +757,7 @@ function addToInverse(graph, resourceKey, key, value, isRemote) {
 			}
 		} else {
 			if (!relationship.isDirty && !relationship.localState) relationship.localState = [];
-			if (_add(graph, resourceKey, relationship, value, null, isRemote)) notifyChange(graph, relationship);
+			if (_add(graph, resourceKey, relationship, value, null, isRemote)) notifyChange(graph, relationship, "local");
 		}
 	} else if (isRemote) {
 		if (!relationship.remoteMembers.has(value)) {
@@ -775,23 +777,24 @@ function removeFromInverse(graph, resourceKey, key, value, isRemote) {
 		if (isRemote) {
 			graph._addToTransaction(relationship);
 			relationship.remoteState = null;
+			notifyChange(graph, relationship);
 		}
 		if (relationship.localState === value) {
 			relationship.localState = null;
-			notifyChange(graph, relationship);
+			if (!isRemote) notifyChange(graph, relationship, "local");
 		}
 	} else if (isHasMany(relationship)) {
 		if (isRemote) {
 			graph._addToTransaction(relationship);
 			if (_removeRemote(relationship, value)) notifyChange(graph, relationship);
-		} else if (_removeLocal(relationship, value)) notifyChange(graph, relationship);
+		} else if (_removeLocal(relationship, value)) notifyChange(graph, relationship, "local");
 	} else if (isRemote) {
 		relationship.remoteMembers.delete(value);
 		relationship.localMembers.delete(value);
 	} else if (value && relationship.localMembers.has(value)) relationship.localMembers.delete(value);
 }
-function flushCanonical(graph, rel) {
-	if (rel.accessed) graph._scheduleLocalSync(rel);
+function flushCanonical(graph, rel, channel) {
+	if (rel.accessed) graph._scheduleLocalSync(rel, channel);
 }
 
 //#endregion
@@ -836,13 +839,11 @@ function replaceRelatedRecord(graph, op, isRemote = false) {
 		addToInverse(graph, op.value, definition.inverseKey, op.record, isRemote);
 	}
 	if (isRemote) {
+		notifyChange(graph, relationship);
 		const { localState, remoteState } = relationship;
 		if (localState && checkIfNew(graph._realStore, localState) && !remoteState) return;
-		if (localState !== remoteState && localState === existingState) {
-			relationship.localState = remoteState;
-			notifyChange(graph, relationship);
-		}
-	} else notifyChange(graph, relationship);
+		if (localState !== remoteState && localState === existingState) relationship.localState = remoteState;
+	} else notifyChange(graph, relationship, "local");
 }
 
 //#endregion
@@ -1260,7 +1261,7 @@ function addToRelatedRecords(graph, op, isRemote) {
 	if (!relationship.isDirty && !relationship.localState) relationship.localState = [];
 	if (Array.isArray(value)) for (let i = 0; i < value.length; i++) addRelatedRecord(graph, relationship, record, value[i], index !== void 0 ? index + i : null, isRemote);
 	else addRelatedRecord(graph, relationship, record, value, index ?? null, isRemote);
-	notifyChange(graph, relationship);
+	notifyChange(graph, relationship, isRemote ? void 0 : "local");
 }
 function addRelatedRecord(graph, relationship, record, value, index, isRemote) {
 	((test) => {
@@ -1290,11 +1291,16 @@ function mergeInRelationship(graph, rel, op) {
 	else mergeImplicit(graph, rel, op);
 }
 function mergeBelongsTo(graph, rel, op) {
-	if (rel.remoteState === op.record) rel.remoteState = op.value;
+	let changed = false;
+	if (rel.remoteState === op.record) {
+		rel.remoteState = op.value;
+		changed = true;
+	}
 	if (rel.localState === op.record) {
 		rel.localState = op.value;
-		notifyChange(graph, rel);
+		changed = true;
 	}
+	if (changed) notifyChange(graph, rel);
 }
 function mergeHasMany(graph, rel, op) {
 	if (rel.remoteMembers.has(op.record)) {
@@ -1353,7 +1359,7 @@ function removeFromRelatedRecords(graph, op, isRemote) {
 	})(isHasMany(relationship));
 	if (Array.isArray(value)) for (let i = 0; i < value.length; i++) removeRelatedRecord(graph, record, relationship, value[i], op.index ?? null, isRemote);
 	else removeRelatedRecord(graph, record, relationship, value, op.index ?? null, isRemote);
-	notifyChange(graph, relationship);
+	notifyChange(graph, relationship, isRemote ? void 0 : "local");
 }
 function removeRelatedRecord(graph, record, relationship, value, index, isRemote) {
 	((test) => {
@@ -1525,8 +1531,11 @@ var Graph = class {
 	* {@link Graph.push} but not yet flushed into the graph by {@link Graph._flushRemoteQueue}.
 	*/
 	/**
-	* The set of {@link CollectionEdge}s that have local changes pending notification, scheduled
-	* via {@link Graph._scheduleLocalSync} and drained by {@link Graph._flushLocalQueue}.
+	* The {@link CollectionEdge}s that have changes pending notification, scheduled via
+	* {@link Graph._scheduleLocalSync} and drained by {@link Graph._flushLocalQueue}, each
+	* mapped to the {@link NotificationChannel} the notification should be scoped to —
+	* `null` when it must reach every subscriber (scheduled unscoped, or scheduled for
+	* both channels).
 	*/
 	/**
 	* The identifier of the current remote-update transaction, or `null` when no transaction is
@@ -1552,7 +1561,7 @@ var Graph = class {
 			hasMany: void 0,
 			deletions: []
 		};
-		this._updatedRelationships = /* @__PURE__ */ new Set();
+		this._updatedRelationships = /* @__PURE__ */ new Map();
 		this._transaction = null;
 		this._removing = null;
 		this.silenceNotifications = false;
@@ -1884,12 +1893,16 @@ var Graph = class {
 		}
 	}
 	/**
-	* Marks a {@link CollectionEdge} as having local changes that need to be notified, and
-	* schedules a flush of the local sync queue (see {@link Graph._flushLocalQueue}) if one is not
-	* already pending.
+	* Marks a {@link CollectionEdge} as having changes that need to be notified on the given
+	* {@link NotificationChannel} (omitted = unscoped, reaching every subscriber), and schedules
+	* a flush of the sync queue (see {@link Graph._flushLocalQueue}) if one is not already
+	* pending. Scheduling the same edge for both channels (or once unscoped) coalesces into a
+	* single unscoped notification.
 	*/
-	_scheduleLocalSync(relationship) {
-		this._updatedRelationships.add(relationship);
+	_scheduleLocalSync(relationship, channel) {
+		const pending = this._updatedRelationships;
+		if (!pending.has(relationship)) pending.set(relationship, channel ?? null);
+		else if (pending.get(relationship) !== (channel ?? null)) pending.set(relationship, null);
 		if (!this._willSyncLocal) {
 			this._willSyncLocal = true;
 			getStore(this.store)._schedule("sync", () => this._flushLocalQueue());
@@ -1942,13 +1955,13 @@ var Graph = class {
 		if (!this._willSyncLocal) return;
 		if (this.silenceNotifications) {
 			this.silenceNotifications = false;
-			this._updatedRelationships = /* @__PURE__ */ new Set();
+			this._updatedRelationships = /* @__PURE__ */ new Map();
 			return;
 		}
 		this._willSyncLocal = false;
 		const updated = this._updatedRelationships;
-		this._updatedRelationships = /* @__PURE__ */ new Set();
-		updated.forEach((rel) => notifyChange(this, rel));
+		this._updatedRelationships = /* @__PURE__ */ new Map();
+		updated.forEach((channel, rel) => notifyChange(this, rel, channel ?? void 0));
 	}
 	/**
 	* Tears down the graph: clears all tracked identifiers/edges, removes it from the global