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

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

@@ -1,2208 +1,1596 @@
-import { getOrSetGlobal, peekTransient, setTransient } from '../types/-private.js';
+import { a as setTransient, r as peekTransient, t as getOrSetGlobal } from "../-private-Dhl123OI.js";
+
+//#region src/graph/-private/-utils.ts
+/** Retrieves the private {@link Store} instance from a capabilities manager (or any object exposing `_store`). */
 function getStore(wrapper) {
-  return wrapper._store;
+	return wrapper._store;
 }
+/** Reads a value from a two-level keyed cache, without creating the first-level entry if it is missing. */
 function expandingGet(cache, key1, key2) {
-  const mainCache = cache[key1] = cache[key1] || Object.create(null);
-  return mainCache[key2];
+	return (cache[key1] = cache[key1] || Object.create(null))[key2];
 }
+/** Writes a value into a two-level keyed cache, lazily creating the first-level entry if it does not yet exist. */
 function expandingSet(cache, key1, key2, value) {
-  const mainCache = cache[key1] = cache[key1] || Object.create(null);
-  mainCache[key2] = value;
+	const mainCache = cache[key1] = cache[key1] || Object.create(null);
+	mainCache[key2] = value;
 }
+/** Returns whether the given resource is new, i.e. it has no `id` or is flagged as new by the cache. */
 function checkIfNew(store, resourceKey) {
-  if (!resourceKey.id) {
-    return true;
-  }
-  return store.cache.isNew(resourceKey);
+	if (!resourceKey.id) return true;
+	return store.cache.isNew(resourceKey);
 }
+/** A type-guard returning whether the given edge is a `belongsTo` {@link ResourceEdge}. */
 function isBelongsTo(relationship) {
-  return relationship.definition.kind === 'belongsTo';
+	return relationship.definition.kind === "belongsTo";
 }
+/** A type-guard returning whether the given edge is an {@link ImplicitEdge}. */
 function isImplicit(relationship) {
-  return relationship.definition.isImplicit;
+	return relationship.definition.isImplicit;
 }
+/** A type-guard returning whether the given edge is a `hasMany` {@link CollectionEdge}. */
 function isHasMany(relationship) {
-  return relationship.definition.kind === 'hasMany';
+	return relationship.definition.kind === "hasMany";
 }
+/** Invokes `cb` for every resource identifier currently related through `rel`, covering both local and remote membership regardless of the edge's kind. */
 function forAllRelatedIdentifiers(rel, cb) {
-  if (isBelongsTo(rel)) {
-    if (rel.remoteState) {
-      cb(rel.remoteState);
-    }
-    if (rel.localState && rel.localState !== rel.remoteState) {
-      cb(rel.localState);
-    }
-  } else if (isHasMany(rel)) {
-    // TODO
-    // rel.remoteMembers.forEach(cb);
-    // might be simpler if performance is not a concern
-    for (let i = 0; i < rel.remoteState.length; i++) {
-      const inverseIdentifier = rel.remoteState[i];
-      cb(inverseIdentifier);
-    }
-    rel.additions?.forEach(cb);
-  } else {
-    rel.localMembers.forEach(cb);
-    rel.remoteMembers.forEach(inverseIdentifier => {
-      if (!rel.localMembers.has(inverseIdentifier)) {
-        cb(inverseIdentifier);
-      }
-    });
-  }
-}
-
-/*
-  Removes the given identifier from BOTH remote AND local state.
-
-  This method is useful when either a deletion or a rollback on a new record
-  needs to entirely purge itself from an inverse relationship.
-  */
-function removeIdentifierCompletelyFromRelationship(graph, relationship, value, silenceNotifications) {
-  if (isBelongsTo(relationship)) {
-    if (relationship.remoteState === value) {
-      relationship.remoteState = null;
-    }
-    if (relationship.localState === value) {
-      relationship.localState = null;
-      // This allows dematerialized inverses to be rematerialized
-      // we shouldn't be notifying here though, figure out where
-      // a notification was missed elsewhere.
-      {
-        notifyChange(graph, relationship);
-      }
-    }
-  } else if (isHasMany(relationship)) {
-    relationship.remoteMembers.delete(value);
-    relationship.additions?.delete(value);
-    const wasInRemovals = relationship.removals?.delete(value);
-    const canonicalIndex = relationship.remoteState.indexOf(value);
-    if (canonicalIndex !== -1) {
-      relationship.remoteState.splice(canonicalIndex, 1);
-    }
-    if (!wasInRemovals) {
-      const currentIndex = relationship.localState?.indexOf(value);
-      if (currentIndex !== -1 && currentIndex !== undefined) {
-        relationship.localState.splice(currentIndex, 1);
-        // This allows dematerialized inverses to be rematerialized
-        // we shouldn't be notifying here though, figure out where
-        // a notification was missed elsewhere.
-        {
-          notifyChange(graph, relationship);
-        }
-      }
-    }
-  } else {
-    relationship.remoteMembers.delete(value);
-    relationship.localMembers.delete(value);
-  }
-}
-function notifyChange(graph, relationship) {
-  if (!relationship.accessed) {
-    return;
-  }
-  const resourceKey = relationship.identifier;
-  const key = relationship.definition.key;
-  if (resourceKey === graph._removing) {
-    return;
-  }
-  graph.store.notifyChange(resourceKey, 'relationships', key);
+	if (isBelongsTo(rel)) {
+		if (rel.remoteState) cb(rel.remoteState);
+		if (rel.localState && rel.localState !== rel.remoteState) cb(rel.localState);
+	} else if (isHasMany(rel)) {
+		for (let i = 0; i < rel.remoteState.length; i++) {
+			const inverseIdentifier = rel.remoteState[i];
+			cb(inverseIdentifier);
+		}
+		rel.additions?.forEach(cb);
+	} else {
+		rel.localMembers.forEach(cb);
+		rel.remoteMembers.forEach((inverseIdentifier) => {
+			if (!rel.localMembers.has(inverseIdentifier)) cb(inverseIdentifier);
+		});
+	}
 }
-function isLegacyField(field) {
-  return field.kind === 'belongsTo' || field.kind === 'hasMany';
-}
-function temporaryConvertToLegacy(field) {
-  return {
-    kind: field.kind === 'resource' ? 'belongsTo' : 'hasMany',
-    name: field.name,
-    type: field.type,
-    options: Object.assign({}, {
-      async: false,
-      inverse: null,
-      resetOnRemoteUpdate: false
-    }, field.options)
-  };
-}
-
 /**
- *
- * Given RHS (Right Hand Side)
- *
- * ```ts
- * class User extends Model {
- *   @hasMany('animal', { async: false, inverse: 'owner' }) pets;
- * }
- * ```
- *
- * Given LHS (Left Hand Side)
- *
- * ```ts
- * class Animal extends Model {
- *  @belongsTo('user', { async: false, inverse: 'pets' }) owner;
- * }
- * ```
- *
- * The UpgradedMeta for the RHS would be:
- *
- * ```ts
- * {
- *   kind: 'hasMany',
- *   key: 'pets',
- *   type: 'animal',
- *   isAsync: false,
- *   isImplicit: false,
- *   isCollection: true,
- *   isPolymorphic: false,
- *   inverseKind: 'belongsTo',
- *   inverseKey: 'owner',
- *   inverseType: 'user',
- *   inverseIsAsync: false,
- *   inverseIsImplicit: false,
- *   inverseIsCollection: false,
- *   inverseIsPolymorphic: false,
- * }
- * ```
- *
- * The UpgradeMeta for the LHS would be:
- *
- * ```ts
- * {
- *   kind: 'belongsTo',
- *   key: 'owner',
- *   type: 'user',
- *   isAsync: false,
- *   isImplicit: false,
- *   isCollection: false,
- *   isPolymorphic: false,
- *   inverseKind: 'hasMany',
- *   inverseKey: 'pets',
- *   inverseType: 'animal',
- *   inverseIsAsync: false,
- *   inverseIsImplicit: false,
- *   inverseIsCollection: true,
- *   inverseIsPolymorphic: false,
- * }
- * ```
- *
- * @private
- */
-
-const BOOL_LATER = null;
-const STR_LATER = '';
-const IMPLICIT_KEY_RAND = Date.now();
-function implicitKeyFor(type, key) {
-  return `implicit-${type}:${key}${IMPLICIT_KEY_RAND}`;
-}
-function syncMeta(definition, inverseDefinition) {
-  definition.inverseKind = inverseDefinition.kind;
-  definition.inverseKey = inverseDefinition.key;
-  definition.inverseName = inverseDefinition.name;
-  definition.inverseType = inverseDefinition.type;
-  definition.inverseIsAsync = inverseDefinition.isAsync;
-  definition.inverseIsCollection = inverseDefinition.isCollection;
-  definition.inverseIsPolymorphic = inverseDefinition.isPolymorphic;
-  definition.inverseIsImplicit = inverseDefinition.isImplicit;
-  definition.inverseIsLinksMode = inverseDefinition.isLinksMode;
-  const resetOnRemoteUpdate = definition.resetOnRemoteUpdate === false || inverseDefinition.resetOnRemoteUpdate === false ? false : true;
-  definition.resetOnRemoteUpdate = resetOnRemoteUpdate;
-  inverseDefinition.resetOnRemoteUpdate = resetOnRemoteUpdate;
-}
-function upgradeMeta(meta) {
-  if (!isLegacyField(meta)) {
-    meta = temporaryConvertToLegacy(meta);
-  }
-  const niceMeta = {};
-  const options = meta.options;
-  niceMeta.kind = meta.kind;
-  niceMeta.key = meta.sourceKey ?? meta.name;
-  niceMeta.name = meta.name;
-  niceMeta.type = meta.type;
-  niceMeta.isAsync = options.async;
-  niceMeta.isImplicit = false;
-  niceMeta.isCollection = meta.kind === 'hasMany';
-  niceMeta.isPolymorphic = options && !!options.polymorphic;
-  niceMeta.isLinksMode = options.linksMode ?? false;
-  niceMeta.inverseKey = options && options.inverse || STR_LATER;
-  niceMeta.inverseName = options && options.inverse || STR_LATER;
-  niceMeta.inverseType = STR_LATER;
-  niceMeta.inverseIsAsync = BOOL_LATER;
-  niceMeta.inverseIsImplicit = options && options.inverse === null || BOOL_LATER;
-  niceMeta.inverseIsCollection = BOOL_LATER;
-  niceMeta.inverseIsLinksMode = BOOL_LATER;
-
-  // prettier-ignore
-  niceMeta.resetOnRemoteUpdate = !isLegacyField(meta) ? false : meta.options?.linksMode ? false : meta.options?.resetOnRemoteUpdate === false ? false : true;
-  return niceMeta;
-}
-function isLHS(info, type, key) {
-  const isSelfReferential = info.isSelfReferential;
-  const isRelationship = key === info.lhs_relationshipName;
-  if (isRelationship === true) {
-    return isSelfReferential === true ||
-    // itself
-    type === info.lhs_baseModelName ||
-    // base or non-polymorphic
-    // if the other side is polymorphic then we need to scan our modelNames
-    info.rhs_isPolymorphic && info.lhs_modelNames.includes(type) // polymorphic
-    ;
-  }
-  return false;
-}
-function upgradeDefinition(graph, key, propertyName, isImplicit = false) {
-  const cache = graph._definitionCache;
-  const storeWrapper = graph.store;
-  const polymorphicLookup = graph._potentialPolymorphicTypes;
-  const {
-    type
-  } = key;
-  let cached = /*#__NOINLINE__*/expandingGet(cache, type, propertyName);
-
-  // CASE: We have a cached resolution (null if no relationship exists)
-  if (cached !== undefined) {
-    return cached;
-  }
-  const relationships = storeWrapper.schema.fields(key);
-  const relationshipsBySourceKey = storeWrapper.schema.cacheFields?.(key) ?? relationships;
-  const meta = relationshipsBySourceKey.get(propertyName);
-  if (!meta) {
-    // TODO potentially we should just be permissive here since this is an implicit relationship
-    // and not require the lookup table to be populated
-    if (polymorphicLookup[type]) {
-      const altTypes = Object.keys(polymorphicLookup[type]);
-      for (let i = 0; i < altTypes.length; i++) {
-        const _cached = expandingGet(cache, altTypes[i], propertyName);
-        if (_cached) {
-          /*#__NOINLINE__*/expandingSet(cache, type, propertyName, _cached);
-          _cached.rhs_modelNames.push(type);
-          return _cached;
-        }
-      }
-    }
-    cache[type][propertyName] = null;
-    return null;
-  }
-  const definition = /*#__NOINLINE__*/upgradeMeta(meta);
-  let inverseDefinition;
-  let inverseKey;
-  const inverseType = definition.type;
-
-  // CASE: Inverse is explicitly null
-  if (definition.inverseKey === null) {
-    inverseDefinition = null;
-  } else {
-    inverseKey = /*#__NOINLINE__*/inverseForRelationship(getStore(storeWrapper), key, propertyName);
-
-    // CASE: If we are polymorphic, and we declared an inverse that is non-null
-    // we must assume that the lack of inverseKey means that there is no
-    // concrete type as the baseType, so we must construct and artificial
-    // placeholder
-    if (!inverseKey && definition.isPolymorphic && definition.inverseKey) {
-      inverseDefinition = {
-        kind: 'belongsTo',
-        // this must be updated when we find the first belongsTo or hasMany definition that matches
-        key: definition.inverseKey,
-        name: definition.inverseName,
-        type: type,
-        isAsync: false,
-        // this must be updated when we find the first belongsTo or hasMany definition that matches
-        isImplicit: false,
-        isCollection: false,
-        // this must be updated when we find the first belongsTo or hasMany definition that matches
-        isPolymorphic: false
-      }; // the rest of the fields are populated by syncMeta
-
-      // CASE: Inverse resolves to null
-    } else if (!inverseKey) {
-      inverseDefinition = null;
-    } else {
-      // CASE: We have an explicit inverse or were able to resolve one
-      // for the inverse we use "name" for lookup not "sourceKey"
-      const inverseDefinitions = storeWrapper.schema.fields({
-        type: inverseType
-      });
-      const metaFromInverse = inverseDefinitions.get(inverseKey);
-      inverseDefinition = upgradeMeta(metaFromInverse);
-    }
-  }
-
-  // CASE: We have no inverse
-  if (!inverseDefinition) {
-    // polish off meta
-    inverseKey = /*#__NOINLINE__*/implicitKeyFor(type, propertyName);
-    inverseDefinition = {
-      kind: 'implicit',
-      key: inverseKey,
-      type: type,
-      isAsync: false,
-      isImplicit: true,
-      isCollection: true,
-      // with implicits any number of records could point at us
-      isPolymorphic: false
-    }; // the rest of the fields are populated by syncMeta
-
-    syncMeta(definition, inverseDefinition);
-    syncMeta(inverseDefinition, definition);
-    const info = {
-      lhs_key: `${type}:${propertyName}`,
-      lhs_modelNames: [type],
-      lhs_baseModelName: type,
-      lhs_relationshipName: propertyName,
-      lhs_definition: definition,
-      lhs_isPolymorphic: definition.isPolymorphic,
-      rhs_key: inverseDefinition.key,
-      rhs_modelNames: [inverseType],
-      rhs_baseModelName: inverseType,
-      rhs_relationshipName: inverseDefinition.key,
-      rhs_definition: inverseDefinition,
-      rhs_isPolymorphic: false,
-      hasInverse: false,
-      isSelfReferential: type === inverseType,
-      // this could be wrong if we are self-referential but also polymorphic
-      isReflexive: false // we can't be reflexive if we don't define an inverse
-    };
-    expandingSet(cache, inverseType, inverseKey, info);
-    expandingSet(cache, type, propertyName, info);
-    return info;
-  }
-
-  // CASE: We do have an inverse
-  const baseType = inverseDefinition.type;
-  cached = expandingGet(cache, baseType, propertyName) || expandingGet(cache, inverseType, inverseKey);
-  if (cached) {
-    const _isLHS = cached.lhs_baseModelName === baseType;
-    const modelNames = _isLHS ? cached.lhs_modelNames : cached.rhs_modelNames;
-    // make this lookup easier in the future by caching the key
-    modelNames.push(type);
-    expandingSet(cache, type, propertyName, cached);
-    return cached;
-  }
-
-  // this is our first time so polish off the metas
-  syncMeta(definition, inverseDefinition);
-  syncMeta(inverseDefinition, definition);
-  const lhs_modelNames = [type];
-  if (type !== baseType) {
-    lhs_modelNames.push(baseType);
-  }
-  const isSelfReferential = baseType === inverseType;
-  const info = {
-    lhs_key: `${baseType}:${propertyName}`,
-    lhs_modelNames,
-    lhs_baseModelName: baseType,
-    lhs_relationshipName: propertyName,
-    lhs_definition: definition,
-    lhs_isPolymorphic: definition.isPolymorphic,
-    rhs_key: `${inverseType}:${inverseKey}`,
-    rhs_modelNames: [inverseType],
-    rhs_baseModelName: inverseType,
-    rhs_relationshipName: inverseKey,
-    rhs_definition: inverseDefinition,
-    rhs_isPolymorphic: inverseDefinition.isPolymorphic,
-    hasInverse: true,
-    isSelfReferential,
-    isReflexive: isSelfReferential && propertyName === inverseKey
-  };
-
-  // Create entries for the baseModelName as well as modelName to speed up
-  //  inverse lookups
-  expandingSet(cache, baseType, propertyName, info);
-  expandingSet(cache, type, propertyName, info);
-
-  // Greedily populate the inverse
-  expandingSet(cache, inverseType, inverseKey, info);
-  return info;
-}
-function inverseForRelationship(store, resourceKey, key) {
-  const fields = store.schema.fields(resourceKey);
-  const definition = fields.get(key);
-  if (!definition) {
-    return null;
-  }
-  return definition.options.inverse;
-}
-
-/*
-    case many:1
-    ========
-    In a bi-directional graph with Many:1 edges, adding a value
-    results in up-to 3 discrete value transitions, while removing
-    a value is only 2 transitions.
-
-    For adding C to A
-    If: A <<-> B, C <->> D is the initial state,
-    and: B <->> A <<-> C, D is the final state
-
-    then we would undergo the following transitions.
-
-    add C to A
-    remove C from D
-    add A to C
-
-    For removing B from A
-    If: A <<-> B, C <->> D is the initial state,
-    and: A, B, C <->> D is the final state
-
-    then we would undergo the following transitions.
-
-    remove B from A
-    remove A from B
-
-    case many:many
-    ===========
-    In a bi-directional graph with Many:Many edges, adding or
-    removing a value requires only 2 value transitions.
-
-    For Adding
-    If: A<<->>B, C<<->>D is the initial state (double arrows representing the many side)
-    And: D<<->>C<<->>A<<->>B is the final state
-
-    Then we would undergo two transitions.
-
-    add C to A.
-    add A to C
-
-    For Removing
-    If: A<<->>B, C<<->>D is the initial state (double arrows representing the many side)
-    And: A, B, C<<->>D is the final state
-
-    Then we would undergo two transitions.
-
-    remove B from A
-    remove A from B
-
-    case many:?
-    ========
-    In a uni-directional graph with Many:? edges (modeled in WarpDrive with `inverse:null`) with
-    artificial (implicit) inverses, replacing a value results in 2 discrete value transitions.
-    This is because a Many:? relationship is effectively Many:Many.
-  */
+* Removes the given identifier from BOTH remote AND local state.
+*
+* This method is useful when either a deletion or a rollback on a new record
+* needs to entirely purge itself from an inverse relationship.
+*/
+function removeIdentifierCompletelyFromRelationship(graph, relationship, value, silenceNotifications) {
+	if (isBelongsTo(relationship)) {
+		if (relationship.remoteState === value) relationship.remoteState = null;
+		if (relationship.localState === value) {
+			relationship.localState = null;
+			if (!silenceNotifications) notifyChange(graph, relationship);
+		}
+	} else if (isHasMany(relationship)) {
+		relationship.remoteMembers.delete(value);
+		relationship.additions?.delete(value);
+		const wasInRemovals = relationship.removals?.delete(value);
+		const canonicalIndex = relationship.remoteState.indexOf(value);
+		if (canonicalIndex !== -1) relationship.remoteState.splice(canonicalIndex, 1);
+		if (!wasInRemovals) {
+			const currentIndex = relationship.localState?.indexOf(value);
+			if (currentIndex !== -1 && currentIndex !== void 0) {
+				relationship.localState.splice(currentIndex, 1);
+				if (!silenceNotifications) notifyChange(graph, relationship);
+			}
+		}
+	} else {
+		relationship.remoteMembers.delete(value);
+		relationship.localMembers.delete(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, channel) {
+	if (!relationship.accessed) return;
+	const resourceKey = relationship.identifier;
+	const key = relationship.definition.key;
+	if (resourceKey === graph._removing) return;
+	graph.store.notifyChange(resourceKey, "relationships", key, channel);
+}
+
+//#endregion
+//#region src/graph/-private/operations/replace-related-records.ts
 function replaceRelatedRecords(graph, op, isRemote) {
-  if (isRemote) {
-    replaceRelatedRecordsRemote(graph, op, isRemote);
-  } else {
-    replaceRelatedRecordsLocal(graph, op, isRemote);
-  }
+	if (isRemote) replaceRelatedRecordsRemote(graph, op, isRemote);
+	else replaceRelatedRecordsLocal(graph, op, isRemote);
 }
 function replaceRelatedRecordsLocal(graph, op, isRemote) {
-  const resourceKeys = op.value;
-  const relationship = graph.get(op.record, op.field);
-  relationship.state.hasReceivedData = true;
-  const {
-    additions,
-    removals
-  } = relationship;
-  const {
-    inverseKey,
-    type
-  } = relationship.definition;
-  const {
-    record
-  } = op;
-  const wasDirty = relationship.isDirty;
-  let localBecameDirty = false;
-  const onAdd = resourceKey => {
-    // Since we are diffing against the remote state, we check
-    // if our previous local state did not contain this ResourceKey
-    const removalsHas = removals?.has(resourceKey);
-    if (removalsHas || !additions?.has(resourceKey)) {
-      if (type !== resourceKey.type) {
-        graph.registerPolymorphicType(type, resourceKey.type);
-      }
-
-      // we've added a record locally that wasn't in the local state before
-      localBecameDirty = true;
-      addToInverse(graph, resourceKey, inverseKey, op.record, isRemote);
-      if (removalsHas) {
-        removals.delete(resourceKey);
-      }
-    }
-  };
-  const onRemove = resourceKey => {
-    // Since we are diffing against the remote state, we check
-    // if our previous local state had contained this ResourceKey
-    const additionsHas = additions?.has(resourceKey);
-    if (additionsHas || !removals?.has(resourceKey)) {
-      // we've removed a record locally that was in the local state before
-      localBecameDirty = true;
-      removeFromInverse(graph, resourceKey, inverseKey, record, isRemote);
-      if (additionsHas) {
-        additions.delete(resourceKey);
-      }
-    }
-  };
-  const diff = diffCollection(resourceKeys, relationship, onAdd, onRemove);
-
-  // any additions no longer in the local state
-  // also need to be removed from the inverse
-  if (additions && additions.size > 0) {
-    additions.forEach(resourceKey => {
-      if (!diff.add.has(resourceKey)) {
-        localBecameDirty = true;
-        onRemove(resourceKey);
-      }
-    });
-  }
-
-  // any removals no longer in the local state
-  // also need to be added back to the inverse
-  if (removals && removals.size > 0) {
-    removals.forEach(resourceKey => {
-      if (!diff.del.has(resourceKey)) {
-        localBecameDirty = true;
-        onAdd(resourceKey);
-      }
-    });
-  }
-  const becameDirty = diff.changed || localBecameDirty;
-  relationship.additions = diff.add;
-  relationship.removals = diff.del;
-  relationship.localState = diff.finalState;
-
-  // we only notify if the localState changed and were not already dirty before
-  // because if we were already dirty then we have already notified
-  if (becameDirty && !wasDirty) {
-    notifyChange(graph, relationship);
-  }
+	const resourceKeys = op.value;
+	const relationship = graph.get(op.record, op.field);
+	relationship.state.hasReceivedData = true;
+	const { additions, removals } = relationship;
+	const { inverseKey, type } = relationship.definition;
+	const { record } = op;
+	const wasDirty = relationship.isDirty;
+	let localBecameDirty = false;
+	const onAdd = (resourceKey) => {
+		const removalsHas = removals?.has(resourceKey);
+		if (removalsHas || !additions?.has(resourceKey)) {
+			if (type !== resourceKey.type) graph.registerPolymorphicType(type, resourceKey.type);
+			localBecameDirty = true;
+			addToInverse(graph, resourceKey, inverseKey, op.record, isRemote);
+			if (removalsHas) removals.delete(resourceKey);
+		}
+	};
+	const onRemove = (resourceKey) => {
+		const additionsHas = additions?.has(resourceKey);
+		if (additionsHas || !removals?.has(resourceKey)) {
+			localBecameDirty = true;
+			removeFromInverse(graph, resourceKey, inverseKey, record, isRemote);
+			if (additionsHas) additions.delete(resourceKey);
+		}
+	};
+	const diff = diffCollection(resourceKeys, relationship, onAdd, onRemove);
+	if (additions && additions.size > 0) additions.forEach((resourceKey) => {
+		if (!diff.add.has(resourceKey)) {
+			localBecameDirty = true;
+			onRemove(resourceKey);
+		}
+	});
+	if (removals && removals.size > 0) removals.forEach((resourceKey) => {
+		if (!diff.del.has(resourceKey)) {
+			localBecameDirty = true;
+			onAdd(resourceKey);
+		}
+	});
+	const becameDirty = diff.changed || localBecameDirty;
+	relationship.additions = diff.add;
+	relationship.removals = diff.del;
+	relationship.localState = diff.finalState;
+	if (becameDirty && !wasDirty) notifyChange(graph, relationship, "local");
 }
 function replaceRelatedRecordsRemote(graph, op, isRemote) {
-  const resourceKeys = op.value;
-  const relationship = graph.get(op.record, op.field);
-  if (isRemote) {
-    graph._addToTransaction(relationship);
-  }
-  const wasDirty = relationship.isDirty;
-  // if this is our first time receiving data
-  // we need to mark the relationship as dirty
-  // so that non-materializing APIs like `hasManyReference.value()`
-  // will get notified and updated.
-  if (!relationship.state.hasReceivedData) {
-    relationship.isDirty = true;
-  }
-  relationship.state.hasReceivedData = true;
-
-  // cache existing state
-  const {
-    definition
-  } = relationship;
-  const {
-    type
-  } = relationship.definition;
-  const diff = diffCollection(resourceKeys, relationship, resourceKey => {
-    if (type !== resourceKey.type) {
-      graph.registerPolymorphicType(type, resourceKey.type);
-    }
-    // commit additions
-    // TODO build this into the diff?
-    // because we are not dirty if this was a committed local addition
-    if (relationship.additions?.has(resourceKey)) {
-      relationship.additions.delete(resourceKey);
-    }
-    addToInverse(graph, resourceKey, definition.inverseKey, op.record, isRemote);
-  }, resourceKey => {
-    // commit removals
-    // TODO build this into the diff?
-    // because we are not dirty if this was a committed local addition
-    if (relationship.removals?.has(resourceKey)) {
-      relationship.removals.delete(resourceKey);
-    }
-    removeFromInverse(graph, resourceKey, definition.inverseKey, op.record, isRemote);
-  });
-
-  // replace existing state
-  relationship.remoteMembers = diff.finalSet;
-  relationship.remoteState = diff.finalState;
-
-  // changed also indicates a change in order
-  if (diff.changed) {
-    relationship.isDirty = true;
-  }
-
-  // TODO unsure if we need this but it
-  // may allow us to more efficiently patch
-  // the associated ManyArray
-  relationship._diff = diff;
-  if (relationship.isDirty && !wasDirty) {
-    flushCanonical(graph, relationship);
-  }
+	const resourceKeys = op.value;
+	const relationship = graph.get(op.record, op.field);
+	if (isRemote) graph._addToTransaction(relationship);
+	relationship.isDirty;
+	if (!relationship.state.hasReceivedData) relationship.isDirty = true;
+	relationship.state.hasReceivedData = true;
+	const { definition } = relationship;
+	const { type } = relationship.definition;
+	const diff = diffCollection(resourceKeys, relationship, (resourceKey) => {
+		if (type !== resourceKey.type) graph.registerPolymorphicType(type, resourceKey.type);
+		if (relationship.additions?.has(resourceKey)) relationship.additions.delete(resourceKey);
+		addToInverse(graph, resourceKey, definition.inverseKey, op.record, isRemote);
+	}, (resourceKey) => {
+		if (relationship.removals?.has(resourceKey)) relationship.removals.delete(resourceKey);
+		removeFromInverse(graph, resourceKey, definition.inverseKey, op.record, isRemote);
+	});
+	relationship.remoteMembers = diff.finalSet;
+	relationship.remoteState = diff.finalState;
+	if (diff.changed) relationship.isDirty = true;
+	relationship._diff = diff;
+	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);
-  const {
-    type
-  } = relationship.definition;
-  if (type !== value.type) {
-    graph.registerPolymorphicType(type, value.type);
-  }
-  if (isBelongsTo(relationship)) {
-    relationship.state.hasReceivedData = true;
-    relationship.state.isEmpty = false;
-    if (isRemote) {
-      graph._addToTransaction(relationship);
-      if (relationship.remoteState !== null) {
-        removeFromInverse(graph, relationship.remoteState, relationship.definition.inverseKey, resourceKey, isRemote);
-      }
-      relationship.remoteState = value;
-    }
-    if (relationship.localState !== value) {
-      if (!isRemote && relationship.localState) {
-        removeFromInverse(graph, relationship.localState, relationship.definition.inverseKey, resourceKey, isRemote);
-      }
-      relationship.localState = value;
-      notifyChange(graph, relationship);
-    }
-  } else if (isHasMany(relationship)) {
-    if (isRemote) {
-      // TODO this needs to alert stuffs
-      // And patch state better
-      // This is almost definitely wrong
-      // WARNING WARNING WARNING
-
-      if (!relationship.remoteMembers.has(value)) {
-        graph._addToTransaction(relationship);
-        relationship.remoteState.push(value);
-        relationship.remoteMembers.add(value);
-        if (relationship.additions?.has(value)) {
-          relationship.additions.delete(value);
-        } else {
-          relationship.isDirty = true;
-          relationship.state.hasReceivedData = true;
-          flushCanonical(graph, relationship);
-        }
-      }
-    } else {
-      // if we are not dirty but have a null localState then we
-      // are mutating a relationship that has never been fetched
-      // so we initialize localState to an empty array
-      if (!relationship.isDirty && !relationship.localState) {
-        relationship.localState = [];
-      }
-      if (_add(graph, resourceKey, relationship, value, null, isRemote)) {
-        notifyChange(graph, relationship);
-      }
-    }
-  } else {
-    if (isRemote) {
-      if (!relationship.remoteMembers.has(value)) {
-        relationship.remoteMembers.add(value);
-        relationship.localMembers.add(value);
-      }
-    } else {
-      if (!relationship.localMembers.has(value)) {
-        relationship.localMembers.add(value);
-      }
-    }
-  }
+	const relationship = graph.get(resourceKey, key);
+	const { type } = relationship.definition;
+	if (type !== value.type) graph.registerPolymorphicType(type, value.type);
+	if (isBelongsTo(relationship)) {
+		relationship.state.hasReceivedData = true;
+		relationship.state.isEmpty = false;
+		if (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;
+			if (!isRemote) notifyChange(graph, relationship, "local");
+		}
+	} else if (isHasMany(relationship)) {
+		if (isRemote) {
+			if (!relationship.remoteMembers.has(value)) {
+				graph._addToTransaction(relationship);
+				relationship.remoteState.push(value);
+				relationship.remoteMembers.add(value);
+				if (relationship.additions?.has(value)) relationship.additions.delete(value);
+				else {
+					relationship.isDirty = true;
+					relationship.state.hasReceivedData = true;
+					flushCanonical(graph, relationship);
+				}
+			}
+		} else {
+			if (!relationship.isDirty && !relationship.localState) relationship.localState = [];
+			if (_add(graph, resourceKey, relationship, value, null, isRemote)) notifyChange(graph, relationship, "local");
+		}
+	} else if (isRemote) {
+		if (!relationship.remoteMembers.has(value)) {
+			relationship.remoteMembers.add(value);
+			relationship.localMembers.add(value);
+		}
+	} else if (!relationship.localMembers.has(value)) relationship.localMembers.add(value);
 }
 function notifyInverseOfPotentialMaterialization(graph, resourceKey, key, value, isRemote) {
-  const relationship = graph.get(resourceKey, key);
-  if (isHasMany(relationship) && isRemote && relationship.remoteMembers.has(value)) {
-    notifyChange(graph, relationship);
-  }
+	const relationship = graph.get(resourceKey, key);
+	if (isHasMany(relationship) && isRemote && relationship.remoteMembers.has(value)) notifyChange(graph, relationship);
 }
 function removeFromInverse(graph, resourceKey, key, value, isRemote) {
-  const relationship = graph.get(resourceKey, key);
-  if (isBelongsTo(relationship)) {
-    relationship.state.isEmpty = true;
-    if (isRemote) {
-      graph._addToTransaction(relationship);
-      relationship.remoteState = null;
-    }
-    if (relationship.localState === value) {
-      relationship.localState = null;
-      notifyChange(graph, relationship);
-    }
-  } 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 (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);
-  }
-}
+	const relationship = graph.get(resourceKey, key);
+	if (isBelongsTo(relationship)) {
+		relationship.state.isEmpty = true;
+		if (isRemote) {
+			graph._addToTransaction(relationship);
+			relationship.remoteState = null;
+			notifyChange(graph, relationship);
+		}
+		if (relationship.localState === value) {
+			relationship.localState = null;
+			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, "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, channel) {
+	if (rel.accessed) graph._scheduleLocalSync(rel, channel);
+}
+
+//#endregion
+//#region src/graph/-private/operations/replace-related-record.ts
 function replaceRelatedRecord(graph, op, isRemote = false) {
-  const relationship = graph.get(op.record, op.field);
-  if (isRemote) {
-    graph._addToTransaction(relationship);
-  }
-  const {
-    definition,
-    state
-  } = relationship;
-  const prop = isRemote ? 'remoteState' : 'localState';
-  const existingState = relationship[prop];
-
-  /*
-    case 1:1
-    ========
-    In a bi-directional graph with 1:1 edges, replacing a value
-    results in up-to 4 discrete value transitions.
-     If: A <-> B, C <-> D is the initial state,
-    and: A <-> C, B, D is the final state
-     then we would undergo the following 4 transitions.
-     remove A from B
-    add C to A
-    remove C from D
-    add A to C
-     case 1:many
-    ===========
-    In a bi-directional graph with 1:Many edges, replacing a value
-    results in up-to 3 discrete value transitions.
-     If: A<->>B<<->D, C<<->D is the initial state (double arrows representing the many side)
-    And: A<->>C<<->D, B<<->D is the final state
-     Then we would undergo three transitions.
-     remove A from B
-    add C to A.
-    add A to C
-     case 1:?
-    ========
-    In a uni-directional graph with 1:? edges (modeled in WarpDrive with `inverse:null`) with
-    artificial (implicit) inverses, replacing a value results in up-to 3 discrete value transitions.
-    This is because a 1:? relationship is effectively 1:many.
-     If: A->B, C->B is the initial state
-    And: A->C, C->B is the final state
-     Then we would undergo three transitions.
-     Remove A from B
-    Add C to A
-    Add A to C
-  */
-
-  // nothing for us to do
-  if (op.value === existingState) {
-    // if we were empty before but now know we are empty this needs to be true
-    state.hasReceivedData = true;
-    // if this is a remote update we still sync
-    if (isRemote) {
-      const {
-        localState
-      } = relationship;
-      // don't sync if localState is a new record and our remoteState is null
-      if (localState && checkIfNew(graph._realStore, localState) && !existingState) {
-        return;
-      }
-      if (existingState && localState === existingState) {
-        notifyInverseOfPotentialMaterialization(graph, existingState, definition.inverseKey, op.record, isRemote);
-      }
-    }
-    return;
-  }
-
-  // remove this value from the inverse if required
-  if (existingState) {
-    removeFromInverse(graph, existingState, definition.inverseKey, op.record, isRemote);
-  }
-
-  // update value to the new value
-  relationship[prop] = op.value;
-  state.hasReceivedData = true;
-  state.isEmpty = op.value === null;
-  state.isStale = false;
-  state.hasFailedLoadAttempt = false;
-  if (op.value) {
-    if (definition.type !== op.value.type) {
-      // assert(
-      //   `The '<${definition.inverseType}>.${op.field}' relationship expects only '${definition.type}' records since it is not polymorphic. Received a Record of type '${op.value.type}'`,
-      //   definition.isPolymorphic
-      // );
-
-      // TODO this should now handle the deprecation warning if isPolymorphic is not set
-      // but the record does turn out to be polymorphic
-      // this should still assert if the user is relying on legacy inheritance/mixins to
-      // provide polymorphic behavior and has not yet added the polymorphic flags
-
-      graph.registerPolymorphicType(definition.type, op.value.type);
-    }
-    addToInverse(graph, op.value, definition.inverseKey, op.record, isRemote);
-  }
-  if (isRemote) {
-    const {
-      localState,
-      remoteState
-    } = relationship;
-    if (localState && checkIfNew(graph._realStore, localState) && !remoteState) {
-      return;
-    }
-    // when localState does not match the new remoteState and
-    // localState === existingState then we had no local mutation
-    // and we can safely sync the new remoteState to local
-    if (localState !== remoteState && localState === existingState) {
-      relationship.localState = remoteState;
-      notifyChange(graph, relationship);
-      // But when localState does not match the new remoteState and
-      // and localState !== existingState then we know we have a local mutation
-      // that has not been persisted yet.
-    }
-  } else {
-    notifyChange(graph, relationship);
-  }
-}
+	const relationship = graph.get(op.record, op.field);
+	if (isRemote) graph._addToTransaction(relationship);
+	const { definition, state } = relationship;
+	const prop = isRemote ? "remoteState" : "localState";
+	const existingState = relationship[prop];
+	if (op.value === existingState) {
+		state.hasReceivedData = true;
+		if (isRemote) {
+			state.hasReceivedRemoteData = true;
+			const { localState } = relationship;
+			if (localState && checkIfNew(graph._realStore, localState) && !existingState) return;
+			if (existingState && localState === existingState) notifyInverseOfPotentialMaterialization(graph, existingState, definition.inverseKey, op.record, isRemote);
+		}
+		return;
+	}
+	if (existingState) removeFromInverse(graph, existingState, definition.inverseKey, op.record, isRemote);
+	relationship[prop] = op.value;
+	state.hasReceivedData = true;
+	/**
+	* Local mutations never give us additional information about
+	* whether the relationship has received *remote* data. This is
+	* what `getRemoteRelationship` relies on to avoid reflecting
+	* local-only edits.
+	*/
+	if (isRemote) state.hasReceivedRemoteData = true;
+	state.isEmpty = op.value === null;
+	state.isStale = false;
+	state.hasFailedLoadAttempt = false;
+	if (op.value) {
+		if (definition.type !== op.value.type) graph.registerPolymorphicType(definition.type, op.value.type);
+		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;
+	} else notifyChange(graph, relationship, "local");
+}
+
+//#endregion
+//#region src/graph/-private/-diff.ts
 function _compare(priorLocalState, finalState, finalSet, prevState, prevSet, onAdd, onDel, remoteClearsLocal) {
-  const finalLength = finalState.length;
-  const prevLength = prevState.length;
-  const iterationLength = Math.max(finalLength, prevLength);
-  const equalLength = priorLocalState ? finalLength === priorLocalState.length : finalLength === prevLength;
-  let remoteOrderChanged = finalSet.size !== prevSet.size;
-  let changed = priorLocalState ? finalSet.size !== priorLocalState.length : remoteOrderChanged;
-  const added = new Set();
-  const removed = new Set();
-  const priorLocalLength = priorLocalState?.length ?? 0;
-  for (let i = 0; i < iterationLength; i++) {
-    let member;
-
-    // accumulate anything added
-    if (i < finalLength) {
-      member = finalState[i];
-      if (!prevSet.has(member)) {
-        // Avoid unnecessarily notifying a change that already exists locally
-        if (i < priorLocalLength) {
-          const priorLocalMember = priorLocalState[i];
-          if (priorLocalMember !== member) {
-            changed = true;
-          }
-        }
-        added.add(member);
-        onAdd(member);
-      }
-    }
-
-    // accumulate anything removed
-    if (i < prevLength) {
-      const prevMember = prevState[i];
-
-      // detect reordering
-      if (equalLength && member !== prevMember) {
-        // the new remote order does not match the current remote order
-        // indicating a change in membership or reordering
-        remoteOrderChanged = true;
-        // however: if the new remote order matches the current local order
-        // we can disregard the change notification generation so long as
-        // we are not configured to reset on remote update (which is deprecated)
-
-        if (i < priorLocalLength) {
-          const priorLocalMember = priorLocalState[i];
-          if (priorLocalMember !== member) {
-            changed = true;
-          }
-        } else if (i < finalLength) {
-          // if we have exceeded the length of priorLocalState and we are within the range
-          // of the finalState then we must have changed
-
-          changed = true;
-        }
-
-        // if remote order hasn't changed but local order differs
-        // and we are configured to reset on remote update (which is deprecated)
-        // then we still need to mark the relationship as changed
-      }
-      if (!finalSet.has(prevMember)) {
-        // if we are within finalLength, we can only be "changed" if we've already exceeded
-        // the index range of priorLocalState, as otherwise the previous member may still
-        // be removed.
-        //
-        // prior local: [1, 2, 3, 4]
-        // final state: [1, 2, 3]
-        // prev remote state: [1, 2, 5, 3, 4]
-        // i === 2
-        // prevMember === 5
-        // !finalSet.has(prevMember) === true
-        //
-        // because we will become changed at i===3,
-        // we do not need to worry about becoming changed at i===2
-        // as the arrays until now are still the same
-        //
-        // prior local: [1, 2, 3]
-        // final state: [1, 2, 3, 4]
-        // prev remote state: [1, 2, 5, 3, 4]
-        // i === 2
-        // prevMember === 5
-        // !finalSet.has(prevMember) === true
-        //
-        // because we will become changed at i===3
-        // we do not need to worry about becoming changed at i===2
-        //
-        // prior local: [1, 2, 3]
-        // final state: [1, 2, 3]
-        // prev remote state: [1, 2, 5, 3, 4]
-        // i === 2
-        // prevMember === 5
-        // !finalSet.has(prevMember) === true
-        //
-        // because we have same length and same membership order
-        // we do not need to worry about becoming changed at i===2
-        //
-        // if you do not have a priorLocalState you can't be changed
-        // ergo, we never need to set changed in this branch.
-        // this log can still be useful for debugging.
-
-        //
-        // we do still set remoteOrderChanged as it has
-        remoteOrderChanged = true;
-        removed.add(prevMember);
-        onDel(prevMember);
-      }
-    }
-  }
-  return {
-    add: added,
-    del: removed,
-    finalState,
-    finalSet,
-    changed,
-    remoteOrderChanged
-  };
+	const finalLength = finalState.length;
+	const prevLength = prevState.length;
+	const iterationLength = Math.max(finalLength, prevLength);
+	const equalLength = priorLocalState ? finalLength === priorLocalState.length : finalLength === prevLength;
+	let remoteOrderChanged = finalSet.size !== prevSet.size;
+	let changed = priorLocalState ? finalSet.size !== priorLocalState.length : remoteOrderChanged;
+	const added = /* @__PURE__ */ new Set();
+	const removed = /* @__PURE__ */ new Set();
+	const priorLocalLength = priorLocalState?.length ?? 0;
+	for (let i = 0; i < iterationLength; i++) {
+		let member;
+		if (i < finalLength) {
+			member = finalState[i];
+			if (!prevSet.has(member)) {
+				if (i < priorLocalLength) {
+					if (priorLocalState[i] !== member) changed = true;
+				}
+				added.add(member);
+				onAdd(member);
+			}
+		}
+		if (i < prevLength) {
+			const prevMember = prevState[i];
+			if (equalLength && member !== prevMember) {
+				remoteOrderChanged = true;
+				if (i < priorLocalLength) {
+					if (priorLocalState[i] !== member) changed = true;
+				} else if (i < finalLength) changed = true;
+			}
+			if (!finalSet.has(prevMember)) {
+				remoteOrderChanged = true;
+				removed.add(prevMember);
+				onDel(prevMember);
+			}
+		}
+	}
+	return {
+		add: added,
+		del: removed,
+		finalState,
+		finalSet,
+		changed,
+		remoteOrderChanged
+	};
 }
 function diffCollection(finalState, relationship, onAdd, onDel) {
-  const finalSet = new Set(finalState);
-  const {
-    localState: priorLocalState,
-    remoteState,
-    remoteMembers
-  } = relationship;
-  return _compare(priorLocalState, finalState, finalSet, remoteState, remoteMembers, onAdd, onDel, relationship.definition.resetOnRemoteUpdate);
+	const finalSet = new Set(finalState);
+	const { localState: priorLocalState, remoteState, remoteMembers } = relationship;
+	return _compare(priorLocalState, finalState, finalSet, remoteState, remoteMembers, onAdd, onDel, relationship.definition.resetOnRemoteUpdate);
 }
 function computeLocalState(storage) {
-  if (!storage.isDirty) {
-    return storage.localState;
-  }
-  const state = storage.remoteState.slice();
-  storage.removals?.forEach(v => {
-    const index = state.indexOf(v);
-    state.splice(index, 1);
-  });
-  storage.additions?.forEach(v => {
-    state.push(v);
-  });
-  storage.localState = state;
-  storage.isDirty = false;
-  return state;
+	if (!storage.isDirty && storage.localState) return storage.localState;
+	const state = storage.remoteState.slice();
+	storage.removals?.forEach((v) => {
+		const index = state.indexOf(v);
+		state.splice(index, 1);
+	});
+	storage.additions?.forEach((v) => {
+		state.push(v);
+	});
+	storage.localState = state;
+	storage.isDirty = false;
+	return state;
 }
-
 /**
- * A function which attempts to add a value to the local state of a collection
- * relationship, and returns true if the value was added, or false if it was
- * already present.
- *
- * It will not generate a notification, will not update the relationships to dirty,
- * and will not update the inverse relationships, making it suitable for use as
- * an internal util to perform the just the addition to a specific side of a
- * relationship.
- *
- * @internal
- */
+* A function which attempts to add a value to the local state of a collection
+* relationship, and returns true if the value was added, or false if it was
+* already present.
+*
+* It will not generate a notification, will not update the relationships to dirty,
+* and will not update the inverse relationships, making it suitable for use as
+* an internal util to perform the just the addition to a specific side of a
+* relationship.
+*
+* @internal
+*/
 function _add(graph, record, relationship, value, index, isRemote) {
-  return !isRemote ? _addLocal(graph, record, relationship, value, index) : _addRemote(graph, record, relationship, value, index);
+	return !isRemote ? _addLocal(graph, record, relationship, value, index) : _addRemote(graph, record, relationship, value, index);
 }
 function _addRemote(graph, record, relationship, value, index) {
-  const {
-    remoteMembers,
-    additions,
-    removals,
-    remoteState
-  } = relationship;
-  if (remoteMembers.has(value)) {
-    return false;
-  }
-
-  // add to the remote state
-  remoteMembers.add(value);
-  const hasValidIndex = index !== null && index >= 0 && index < remoteState.length;
-  if (hasValidIndex) {
-    remoteState.splice(index, 0, value);
-  } else {
-    remoteState.push(value);
-  }
-
-  // remove from additions if present
-  if (additions?.has(value)) {
-    additions.delete(value);
-
-    // nothing more to do this was our state already
-    return false;
-  }
-
-  // if the relationship already needs to recalc, we don't bother
-  // attempting to patch the localState
-  if (relationship.isDirty) {
-    return true;
-  }
-
-  // if we have existing localState
-  // we attempt to patch it without blowing it away
-  // as this is more efficient than recomputing
-  // it allows us to preserve local ordering
-  // to a small extent. Local ordering should not
-  // be relied upon as any remote change could blow it away
-  if (relationship.localState) {
-    if (!hasValidIndex) {
-      relationship.localState.push(value);
-    } else if (index === 0) {
-      relationship.localState.unshift(value);
-    } else if (!removals?.size) {
-      relationship.localState.splice(index, 0, value);
-    } else {
-      relationship.isDirty = true;
-    }
-  }
-  return true;
+	const { remoteMembers, additions, removals, remoteState } = relationship;
+	if (remoteMembers.has(value)) return false;
+	remoteMembers.add(value);
+	const hasValidIndex = index !== null && index >= 0 && index < remoteState.length;
+	if (hasValidIndex) remoteState.splice(index, 0, value);
+	else remoteState.push(value);
+	if (additions?.has(value)) {
+		additions.delete(value);
+		return false;
+	}
+	if (relationship.isDirty) return true;
+	if (relationship.localState) {
+		if (!hasValidIndex) relationship.localState.push(value);
+		else if (index === 0) relationship.localState.unshift(value);
+		else if (!removals?.size) relationship.localState.splice(index, 0, value);
+		else relationship.isDirty = true;
+	}
+	return true;
 }
 function _addLocal(graph, record, relationship, value, index) {
-  const {
-    remoteMembers,
-    removals
-  } = relationship;
-  let additions = relationship.additions;
-  const hasPresence = remoteMembers.has(value) || additions?.has(value);
-  if (hasPresence && !removals?.has(value)) {
-    return false;
-  }
-  if (removals?.has(value)) {
-    removals.delete(value);
-  } else {
-    if (!additions) {
-      additions = relationship.additions = new Set();
-    }
-    relationship.state.hasReceivedData = true;
-    additions.add(value);
-    const {
-      type
-    } = relationship.definition;
-    if (type !== value.type) {
-      graph.registerPolymorphicType(value.type, type);
-    }
-  }
-
-  // if we have existing localState
-  // and we have an index
-  // apply the change, as this is more efficient
-  // than recomputing localState and
-  // it allows us to preserve local ordering
-  // to a small extend. Local ordering should not
-  // be relied upon as any remote change will blow it away
-  if (relationship.localState) {
-    if (index !== null) {
-      relationship.localState.splice(index, 0, value);
-    } else {
-      relationship.localState.push(value);
-    }
-  }
-  return true;
+	const { remoteMembers, removals } = relationship;
+	let additions = relationship.additions;
+	if ((remoteMembers.has(value) || additions?.has(value)) && !removals?.has(value)) return false;
+	if (removals?.has(value)) removals.delete(value);
+	else {
+		if (!additions) additions = relationship.additions = /* @__PURE__ */ new Set();
+		relationship.state.hasReceivedData = true;
+		additions.add(value);
+		const { type } = relationship.definition;
+		if (type !== value.type) graph.registerPolymorphicType(value.type, type);
+	}
+	if (relationship.localState) {
+		if (index !== null) relationship.localState.splice(index, 0, value);
+		else relationship.localState.push(value);
+	}
+	return true;
 }
 function _remove(graph, record, relationship, value, index, isRemote) {
-  return !isRemote ? _removeLocal(relationship, value) : _removeRemote(relationship, value);
+	return !isRemote ? _removeLocal(relationship, value) : _removeRemote(relationship, value);
 }
 function _removeLocal(relationship, value) {
-  const {
-    remoteMembers,
-    additions
-  } = relationship;
-  let removals = relationship.removals;
-  const hasPresence = remoteMembers.has(value) || additions?.has(value);
-  if (!hasPresence || removals?.has(value)) {
-    return false;
-  }
-  if (additions?.has(value)) {
-    additions.delete(value);
-  } else {
-    if (!removals) {
-      removals = relationship.removals = new Set();
-    }
-    removals.add(value);
-  }
-
-  // if we have existing localState
-  // apply the change, as this is more efficient
-  // than recomputing localState and
-  // it allows us to preserve local ordering
-  // to a small extend. Local ordering should not
-  // be relied upon as any remote change will blow it away
-  if (relationship.localState) {
-    const index = relationship.localState.indexOf(value);
-    relationship.localState.splice(index, 1);
-  }
-  return true;
+	const { remoteMembers, additions } = relationship;
+	let removals = relationship.removals;
+	if (!(remoteMembers.has(value) || additions?.has(value)) || removals?.has(value)) return false;
+	if (additions?.has(value)) additions.delete(value);
+	else {
+		if (!removals) removals = relationship.removals = /* @__PURE__ */ new Set();
+		removals.add(value);
+	}
+	if (relationship.localState) {
+		const index = relationship.localState.indexOf(value);
+		relationship.localState.splice(index, 1);
+	}
+	return true;
 }
 function _removeRemote(relationship, value) {
-  const {
-    remoteMembers,
-    additions,
-    removals,
-    remoteState
-  } = relationship;
-  if (!remoteMembers.has(value)) {
-    return false;
-  }
-
-  // remove from remote state
-  remoteMembers.delete(value);
-  let index = remoteState.indexOf(value);
-  remoteState.splice(index, 1);
-
-  // remove from removals if present
-  if (removals?.has(value)) {
-    removals.delete(value);
-
-    // nothing more to do this was our state already
-    return false;
-  }
-
-  // if we have existing localState
-  // and we have an index
-  // apply the change, as this is more efficient
-  // than recomputing localState and
-  // it allows us to preserve local ordering
-  // to a small extend. Local ordering should not
-  // be relied upon as any remote change will blow it away
-  if (relationship.localState) {
-    index = relationship.localState.indexOf(value);
-    relationship.localState.splice(index, 1);
-  }
-  return true;
+	const { remoteMembers, additions, removals, remoteState } = relationship;
+	if (!remoteMembers.has(value)) return false;
+	remoteMembers.delete(value);
+	let index = remoteState.indexOf(value);
+	remoteState.splice(index, 1);
+	if (removals?.has(value)) {
+		removals.delete(value);
+		return false;
+	}
+	if (relationship.localState) {
+		index = relationship.localState.indexOf(value);
+		relationship.localState.splice(index, 1);
+	}
+	return true;
 }
 function rollbackRelationship(graph, key, field, relationship) {
-  if (isBelongsTo(relationship)) {
-    replaceRelatedRecord(graph, {
-      record: key,
-      field,
-      value: relationship.remoteState
-    }, false);
-  } else {
-    replaceRelatedRecords(graph, {
-      record: key,
-      field,
-      value: relationship.remoteState.slice()
-    }, false);
-
-    // when the change was a "reorder" only we wont have generated
-    // a notification yet.
-    // if we give rollback a unique operation we can use the ability of
-    // diff to report a separate `remoteOrderChanged` flag to trigger this
-    // if needed to avoid the duplicate.
-    notifyChange(graph, relationship);
-  }
+	if (isBelongsTo(relationship)) replaceRelatedRecord(graph, {
+		op: "replaceRelatedRecord",
+		record: key,
+		field,
+		value: relationship.remoteState
+	}, false);
+	else {
+		replaceRelatedRecords(graph, {
+			op: "replaceRelatedRecords",
+			record: key,
+			field,
+			value: relationship.remoteState.slice()
+		}, false);
+		notifyChange(graph, relationship);
+	}
+}
+
+//#endregion
+//#region src/graph/-private/-edge-definition.ts
+function isLegacyField(field) {
+	return field.kind === "belongsTo" || field.kind === "hasMany";
 }
-function createState() {
-  return {
-    hasReceivedData: false,
-    isEmpty: true,
-    isStale: false,
-    hasFailedLoadAttempt: false,
-    shouldForceReload: false,
-    hasDematerializedInverse: false
-  };
+function temporaryConvertToLegacy(field) {
+	return {
+		kind: field.kind === "resource" ? "belongsTo" : "hasMany",
+		name: field.name,
+		type: field.type,
+		options: Object.assign({}, {
+			async: false,
+			inverse: null,
+			resetOnRemoteUpdate: false
+		}, field.options)
+	};
 }
+/**
+*
+* Given RHS (Right Hand Side)
+*
+* ```ts
+* class User extends Model {
+*   @hasMany('animal', { async: false, inverse: 'owner' }) pets;
+* }
+* ```
+*
+* Given LHS (Left Hand Side)
+*
+* ```ts
+* class Animal extends Model {
+*  @belongsTo('user', { async: false, inverse: 'pets' }) owner;
+* }
+* ```
+*
+* The UpgradedMeta for the RHS would be:
+*
+* ```ts
+* {
+*   kind: 'hasMany',
+*   key: 'pets',
+*   type: 'animal',
+*   isAsync: false,
+*   isImplicit: false,
+*   isCollection: true,
+*   isPolymorphic: false,
+*   inverseKind: 'belongsTo',
+*   inverseKey: 'owner',
+*   inverseType: 'user',
+*   inverseIsAsync: false,
+*   inverseIsImplicit: false,
+*   inverseIsCollection: false,
+*   inverseIsPolymorphic: false,
+* }
+* ```
+*
+* The UpgradeMeta for the LHS would be:
+*
+* ```ts
+* {
+*   kind: 'belongsTo',
+*   key: 'owner',
+*   type: 'user',
+*   isAsync: false,
+*   isImplicit: false,
+*   isCollection: false,
+*   isPolymorphic: false,
+*   inverseKind: 'hasMany',
+*   inverseKey: 'pets',
+*   inverseType: 'animal',
+*   inverseIsAsync: false,
+*   inverseIsImplicit: false,
+*   inverseIsCollection: true,
+*   inverseIsPolymorphic: false,
+* }
+* ```
+*
+* @private
+*/
+const BOOL_LATER = null;
+const STR_LATER = "";
+const IMPLICIT_KEY_RAND = Date.now();
+function implicitKeyFor(type, key) {
+	return `implicit-${type}:${key}${IMPLICIT_KEY_RAND}`;
+}
+function syncMeta(definition, inverseDefinition) {
+	definition.inverseKind = inverseDefinition.kind;
+	definition.inverseKey = inverseDefinition.key;
+	definition.inverseName = inverseDefinition.name;
+	definition.inverseType = inverseDefinition.type;
+	definition.inverseIsAsync = inverseDefinition.isAsync;
+	definition.inverseIsCollection = inverseDefinition.isCollection;
+	definition.inverseIsPolymorphic = inverseDefinition.isPolymorphic;
+	definition.inverseIsImplicit = inverseDefinition.isImplicit;
+	definition.inverseIsLinksMode = inverseDefinition.isLinksMode;
+	const resetOnRemoteUpdate = definition.resetOnRemoteUpdate === false || inverseDefinition.resetOnRemoteUpdate === false ? false : true;
+	definition.resetOnRemoteUpdate = resetOnRemoteUpdate;
+	inverseDefinition.resetOnRemoteUpdate = resetOnRemoteUpdate;
+}
+function upgradeMeta(meta) {
+	if (!isLegacyField(meta)) meta = temporaryConvertToLegacy(meta);
+	const niceMeta = {};
+	const options = meta.options;
+	niceMeta.kind = meta.kind;
+	niceMeta.key = meta.sourceKey ?? meta.name;
+	niceMeta.name = meta.name;
+	niceMeta.type = meta.type;
+	niceMeta.isAsync = options.async;
+	niceMeta.isImplicit = false;
+	niceMeta.isCollection = meta.kind === "hasMany";
+	niceMeta.isPolymorphic = options && !!options.polymorphic;
+	niceMeta.isLinksMode = options.linksMode ?? false;
+	niceMeta.inverseKey = options && options.inverse || STR_LATER;
+	niceMeta.inverseName = options && options.inverse || STR_LATER;
+	niceMeta.inverseType = STR_LATER;
+	niceMeta.inverseIsAsync = BOOL_LATER;
+	niceMeta.inverseIsImplicit = options && options.inverse === null || BOOL_LATER;
+	niceMeta.inverseIsCollection = BOOL_LATER;
+	niceMeta.inverseIsLinksMode = BOOL_LATER;
+	niceMeta.resetOnRemoteUpdate = !isLegacyField(meta) ? false : meta.options?.linksMode ? false : meta.options?.resetOnRemoteUpdate === false ? false : true;
+	return niceMeta;
+}
+function isLHS(info, type, key) {
+	const isSelfReferential = info.isSelfReferential;
+	if (key === info.lhs_relationshipName === true) return isSelfReferential === true || type === info.lhs_baseModelName || info.rhs_isPolymorphic && info.lhs_modelNames.includes(type);
+	return false;
+}
+function upgradeDefinition(graph, key, propertyName, isImplicit = false) {
+	const cache = graph._definitionCache;
+	const storeWrapper = graph.store;
+	const polymorphicLookup = graph._potentialPolymorphicTypes;
+	const { type } = key;
+	let cached = expandingGet(cache, type, propertyName);
+	if (cached !== void 0) return cached;
+	const relationships = storeWrapper.schema.fields(key);
+	const meta = (storeWrapper.schema.cacheFields?.(key) ?? relationships).get(propertyName);
+	if (!meta) {
+		if (polymorphicLookup[type]) {
+			const altTypes = Object.keys(polymorphicLookup[type]);
+			for (let i = 0; i < altTypes.length; i++) {
+				const _cached = expandingGet(cache, altTypes[i], propertyName);
+				if (_cached) {
+					expandingSet(cache, type, propertyName, _cached);
+					_cached.rhs_modelNames.push(type);
+					return _cached;
+				}
+			}
+		}
+		cache[type][propertyName] = null;
+		return null;
+	}
+	const definition = upgradeMeta(meta);
+	let inverseDefinition;
+	let inverseKey;
+	const inverseType = definition.type;
+	if (definition.inverseKey === null) inverseDefinition = null;
+	else {
+		inverseKey = inverseForRelationship(getStore(storeWrapper), key, propertyName);
+		if (!inverseKey && definition.isPolymorphic && definition.inverseKey) inverseDefinition = {
+			kind: "belongsTo",
+			key: definition.inverseKey,
+			name: definition.inverseName,
+			type,
+			isAsync: false,
+			isImplicit: false,
+			isCollection: false,
+			isPolymorphic: false
+		};
+		else if (!inverseKey) inverseDefinition = null;
+		else inverseDefinition = upgradeMeta(storeWrapper.schema.fields({ type: inverseType }).get(inverseKey));
+	}
+	if (!inverseDefinition) {
+		inverseKey = implicitKeyFor(type, propertyName);
+		inverseDefinition = {
+			kind: "implicit",
+			key: inverseKey,
+			type,
+			isAsync: false,
+			isImplicit: true,
+			isCollection: true,
+			isPolymorphic: false
+		};
+		syncMeta(definition, inverseDefinition);
+		syncMeta(inverseDefinition, definition);
+		const info = {
+			lhs_key: `${type}:${propertyName}`,
+			lhs_modelNames: [type],
+			lhs_baseModelName: type,
+			lhs_relationshipName: propertyName,
+			lhs_definition: definition,
+			lhs_isPolymorphic: definition.isPolymorphic,
+			rhs_key: inverseDefinition.key,
+			rhs_modelNames: [inverseType],
+			rhs_baseModelName: inverseType,
+			rhs_relationshipName: inverseDefinition.key,
+			rhs_definition: inverseDefinition,
+			rhs_isPolymorphic: false,
+			hasInverse: false,
+			isSelfReferential: type === inverseType,
+			isReflexive: false
+		};
+		expandingSet(cache, inverseType, inverseKey, info);
+		expandingSet(cache, type, propertyName, info);
+		return info;
+	}
+	const baseType = inverseDefinition.type;
+	cached = expandingGet(cache, baseType, propertyName) || expandingGet(cache, inverseType, inverseKey);
+	if (cached) {
+		const _isLHS = cached.lhs_baseModelName === baseType;
+		_isLHS ? cached.lhs_relationshipName : cached.rhs_relationshipName;
+		cached.lhs_baseModelName === baseType && cached.lhs_relationshipName === propertyName || cached.rhs_baseModelName === baseType && cached.rhs_relationshipName;
+		(_isLHS ? cached.lhs_modelNames : cached.rhs_modelNames).push(type);
+		expandingSet(cache, type, propertyName, cached);
+		return cached;
+	}
+	syncMeta(definition, inverseDefinition);
+	syncMeta(inverseDefinition, definition);
+	const lhs_modelNames = [type];
+	if (type !== baseType) lhs_modelNames.push(baseType);
+	const isSelfReferential = baseType === inverseType;
+	const info = {
+		lhs_key: `${baseType}:${propertyName}`,
+		lhs_modelNames,
+		lhs_baseModelName: baseType,
+		lhs_relationshipName: propertyName,
+		lhs_definition: definition,
+		lhs_isPolymorphic: definition.isPolymorphic,
+		rhs_key: `${inverseType}:${inverseKey}`,
+		rhs_modelNames: [inverseType],
+		rhs_baseModelName: inverseType,
+		rhs_relationshipName: inverseKey,
+		rhs_definition: inverseDefinition,
+		rhs_isPolymorphic: inverseDefinition.isPolymorphic,
+		hasInverse: true,
+		isSelfReferential,
+		isReflexive: isSelfReferential && propertyName === inverseKey
+	};
+	expandingSet(cache, baseType, propertyName, info);
+	expandingSet(cache, type, propertyName, info);
+	expandingSet(cache, inverseType, inverseKey, info);
+	return info;
+}
+function inverseForRelationship(store, resourceKey, key) {
+	const definition = store.schema.fields(resourceKey).get(key);
+	if (!definition) return null;
+	return definition.options.inverse;
+}
+
+//#endregion
+//#region src/graph/-private/-state.ts
+function createState() {
+	return {
+		hasReceivedData: false,
+		hasReceivedRemoteData: false,
+		isEmpty: true,
+		isStale: false,
+		hasFailedLoadAttempt: false,
+		shouldForceReload: false,
+		hasDematerializedInverse: false
+	};
+}
+
+//#endregion
+//#region src/graph/-private/edges/collection.ts
+/**
+* Stores the graph's internal state for one side of a collection (`hasMany`) relationship.
+*/
+/** Creates a new {@link CollectionEdge} for the given definition and identifier. */
 function createCollectionEdge(definition, identifier) {
-  return {
-    definition,
-    identifier,
-    state: createState(),
-    remoteMembers: new Set(),
-    remoteState: [],
-    additions: null,
-    removals: null,
-    meta: null,
-    links: null,
-    localState: null,
-    isDirty: false,
-    transactionRef: 0,
-    accessed: false,
-    _diff: undefined
-  };
+	return {
+		definition,
+		identifier,
+		state: createState(),
+		remoteMembers: /* @__PURE__ */ new Set(),
+		remoteState: [],
+		additions: null,
+		removals: null,
+		meta: null,
+		links: null,
+		localState: null,
+		isDirty: false,
+		transactionRef: 0,
+		accessed: false,
+		_diff: void 0
+	};
 }
 const cp = structuredClone;
+/**
+* Builds a legacy `{ data, links, meta }` {@link CollectionRelationship} payload for this edge,
+* using either the remote or the computed local state, and marks the edge as accessed.
+*/
 function legacyGetCollectionRelationshipData(source, getRemoteState) {
-  source.accessed = true;
-  const payload = {};
-  if (source.state.hasReceivedData) {
-    payload.data = getRemoteState ? source.remoteState.slice() : computeLocalState(source);
-  }
-  if (source.links) {
-    payload.links = cp(source.links);
-  }
-  if (source.meta) {
-    payload.meta = cp(source.meta);
-  }
-  return payload;
+	source.accessed = true;
+	const payload = {};
+	if (source.state.hasReceivedData) payload.data = getRemoteState ? source.remoteState.slice() : computeLocalState(source);
+	if (source.links) payload.links = cp(source.links);
+	if (source.meta) payload.meta = cp(source.meta);
+	return payload;
 }
 
+//#endregion
+//#region src/graph/-private/edges/implicit.ts
+/**
+* The relationship definition (schema metadata) backing an {@link ImplicitEdge}, tagging
+* the {@link UpgradedMeta} as belonging to an implicit inverse relationship.
+*/
 /**
-   Implicit relationships are relationships which have not been declared but the inverse side exists on
-   another record somewhere
+Implicit relationships are relationships which have not been declared but the inverse side exists on
+another record somewhere
 
-   For example consider the following two models
+For example consider the following two models
 
-   ::: code-group
+::: code-group
 
-   ```js [./models/comment.js]
-   import { Model, attr } from '@warp-drive/legacy/model';
+```js [./models/comment.js]
+import { Model, attr } from '@warp-drive/legacy/model';
 
-   export default class Comment extends Model {
-     @attr text;
-   }
-   ```
+export default class Comment extends Model {
+@attr text;
+}
+```
 
-   ```js [./models/post.js]
-    import { Model, attr, hasMany } from '@warp-drive/legacy/model';
+```js [./models/post.js]
+import { Model, attr, hasMany } from '@warp-drive/legacy/model';
 
-   export default class Post extends Model {
-     @attr title;
-     @hasMany('comment', { async: true, inverse: null }) comments;
-   }
-   ```
+export default class Post extends Model {
+@attr title;
+@hasMany('comment', { async: true, inverse: null }) comments;
+}
+```
 
-   :::
+:::
 
-   Then we would have a implicit 'post' relationship for the comment record in order
-   to be do things like remove the comment from the post if the comment were to be deleted.
+Then we would have a implicit 'post' relationship for the comment record in order
+to be do things like remove the comment from the post if the comment were to be deleted.
 */
-
+/** Creates a new {@link ImplicitEdge} for the given definition and identifier. */
 function createImplicitEdge(definition, identifier) {
-  return {
-    definition,
-    identifier,
-    localMembers: new Set(),
-    remoteMembers: new Set()
-  };
+	return {
+		definition,
+		identifier,
+		localMembers: /* @__PURE__ */ new Set(),
+		remoteMembers: /* @__PURE__ */ new Set()
+	};
 }
 
-/**
- * Stores the data for one side of a "single" resource relationship.
- *
- * @private
- */
-
+//#endregion
+//#region src/graph/-private/edges/resource.ts
 function createResourceEdge(definition, identifier) {
-  return {
-    definition,
-    identifier,
-    state: createState(),
-    transactionRef: 0,
-    localState: null,
-    remoteState: null,
-    meta: null,
-    links: null,
-    accessed: false
-  };
+	return {
+		definition,
+		identifier,
+		state: createState(),
+		transactionRef: 0,
+		localState: null,
+		remoteState: null,
+		meta: null,
+		links: null,
+		accessed: false
+	};
 }
 function legacyGetResourceRelationshipData(source, getRemoteState) {
-  source.accessed = true;
-  let data;
-  const payload = {};
-  if (getRemoteState && source.remoteState) {
-    data = source.remoteState;
-  } else if (!getRemoteState && source.localState) {
-    data = source.localState;
-  }
-  if ((getRemoteState && source.remoteState === null || source.localState === null) && source.state.hasReceivedData) {
-    data = null;
-  }
-  if (source.links) {
-    payload.links = source.links;
-  }
-  if (data !== undefined) {
-    payload.data = data;
-  }
-  if (source.meta) {
-    payload.meta = source.meta;
-  }
-  return payload;
-}
+	source.accessed = true;
+	let data;
+	const payload = {};
+	if (getRemoteState && (source.remoteState || source.state.hasReceivedRemoteData)) data = source.remoteState ?? null;
+	else if (!getRemoteState && (source.localState || source.state.hasReceivedData)) data = source.localState ?? null;
+	if (source.links) payload.links = source.links;
+	if (data !== void 0) payload.data = data;
+	if (source.meta) payload.meta = source.meta;
+	return payload;
+}
+
+//#endregion
+//#region src/graph/-private/operations/add-to-related-records.ts
 function addToRelatedRecords(graph, op, isRemote) {
-  const {
-    record,
-    value,
-    index
-  } = op;
-  const relationship = graph.get(record, op.field);
-  const _isBelongsTo = isBelongsTo(relationship);
-  if (isRemote && _isBelongsTo) {
-    if (value !== relationship.remoteState) {
-      const newOp = {
-        record,
-        field: op.field,
-        value: value
-      };
-      return replaceRelatedRecord(graph, newOp, isRemote);
-    }
-    return;
-  }
-
-  // if we are not dirty but have a null localState then we
-  // are mutating a relationship that has never been fetched
-  // so we initialize localState to an empty array
-  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 !== undefined ? index + i : null, isRemote);
-    }
-  } else {
-    addRelatedRecord(graph, relationship, record, value, index ?? null, isRemote);
-  }
-  notifyChange(graph, relationship);
+	const { record, value, index } = op;
+	const relationship = graph.get(record, op.field);
+	const _isBelongsTo = isBelongsTo(relationship);
+	if (isRemote && _isBelongsTo) {
+		if (value !== relationship.remoteState) {
+			const newOp = {
+				op: "replaceRelatedRecord",
+				record,
+				field: op.field,
+				value
+			};
+			return replaceRelatedRecord(graph, newOp, isRemote);
+		}
+		return;
+	}
+	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, isRemote ? void 0 : "local");
 }
 function addRelatedRecord(graph, relationship, record, value, index, isRemote) {
-  if (_add(graph, record, relationship, value, index, isRemote)) {
-    addToInverse(graph, value, relationship.definition.inverseKey, record, isRemote);
-  }
+	if (_add(graph, record, relationship, value, index, isRemote)) addToInverse(graph, value, relationship.definition.inverseKey, record, isRemote);
 }
+
+//#endregion
+//#region src/graph/-private/operations/merge-identifier.ts
 function mergeIdentifier(graph, op, relationships) {
-  Object.keys(relationships).forEach(key => {
-    const rel = relationships[key];
-    if (!rel) {
-      return;
-    }
-    mergeIdentifierForRelationship(graph, op, rel);
-  });
+	Object.keys(relationships).forEach((key) => {
+		const rel = relationships[key];
+		if (!rel) return;
+		mergeIdentifierForRelationship(graph, op, rel);
+	});
 }
 function mergeIdentifierForRelationship(graph, op, rel) {
-  rel.identifier = op.value;
-  forAllRelatedIdentifiers(rel, identifier => {
-    const inverse = graph.get(identifier, rel.definition.inverseKey);
-    mergeInRelationship(graph, inverse, op);
-  });
+	rel.identifier = op.value;
+	forAllRelatedIdentifiers(rel, (identifier) => {
+		mergeInRelationship(graph, graph.get(identifier, rel.definition.inverseKey), op);
+	});
 }
 function mergeInRelationship(graph, rel, op) {
-  if (isBelongsTo(rel)) {
-    mergeBelongsTo(graph, rel, op);
-  } else if (isHasMany(rel)) {
-    mergeHasMany(graph, rel, op);
-  } else {
-    mergeImplicit(graph, rel, op);
-  }
+	if (isBelongsTo(rel)) mergeBelongsTo(graph, rel, op);
+	else if (isHasMany(rel)) mergeHasMany(graph, rel, op);
+	else mergeImplicit(graph, rel, op);
 }
 function mergeBelongsTo(graph, rel, op) {
-  if (rel.remoteState === op.record) {
-    rel.remoteState = op.value;
-  }
-  if (rel.localState === op.record) {
-    rel.localState = op.value;
-    notifyChange(graph, rel);
-  }
+	let changed = false;
+	if (rel.remoteState === op.record) {
+		rel.remoteState = op.value;
+		changed = true;
+	}
+	if (rel.localState === op.record) {
+		rel.localState = op.value;
+		changed = true;
+	}
+	if (changed) notifyChange(graph, rel);
 }
 function mergeHasMany(graph, rel, op) {
-  if (rel.remoteMembers.has(op.record)) {
-    rel.remoteMembers.delete(op.record);
-    rel.remoteMembers.add(op.value);
-    const index = rel.remoteState.indexOf(op.record);
-    rel.remoteState.splice(index, 1, op.value);
-    rel.isDirty = true;
-  }
-  if (rel.additions?.has(op.record)) {
-    rel.additions.delete(op.record);
-    rel.additions.add(op.value);
-    rel.isDirty = true;
-  }
-  if (rel.removals?.has(op.record)) {
-    rel.removals.delete(op.record);
-    rel.removals.add(op.value);
-    rel.isDirty = true;
-  }
-  if (rel.isDirty) {
-    notifyChange(graph, rel);
-  }
+	if (rel.remoteMembers.has(op.record)) {
+		rel.remoteMembers.delete(op.record);
+		rel.remoteMembers.add(op.value);
+		const index = rel.remoteState.indexOf(op.record);
+		rel.remoteState.splice(index, 1, op.value);
+		rel.isDirty = true;
+	}
+	if (rel.additions?.has(op.record)) {
+		rel.additions.delete(op.record);
+		rel.additions.add(op.value);
+		rel.isDirty = true;
+	}
+	if (rel.removals?.has(op.record)) {
+		rel.removals.delete(op.record);
+		rel.removals.add(op.value);
+		rel.isDirty = true;
+	}
+	if (rel.isDirty) notifyChange(graph, rel);
 }
 function mergeImplicit(graph, rel, op) {
-  if (rel.remoteMembers.has(op.record)) {
-    rel.remoteMembers.delete(op.record);
-    rel.remoteMembers.add(op.value);
-  }
-  if (rel.localMembers.has(op.record)) {
-    rel.localMembers.delete(op.record);
-    rel.localMembers.add(op.value);
-  }
-}
+	if (rel.remoteMembers.has(op.record)) {
+		rel.remoteMembers.delete(op.record);
+		rel.remoteMembers.add(op.value);
+	}
+	if (rel.localMembers.has(op.record)) {
+		rel.localMembers.delete(op.record);
+		rel.localMembers.add(op.value);
+	}
+}
+
+//#endregion
+//#region src/graph/-private/operations/remove-from-related-records.ts
 function removeFromRelatedRecords(graph, op, isRemote) {
-  const {
-    record,
-    value
-  } = op;
-  const relationship = graph.get(record, op.field);
-  const _isBelongsTo = isBelongsTo(relationship);
-  if (isRemote && _isBelongsTo) {
-    if (value === relationship.remoteState) {
-      const newOp = {
-        record,
-        field: op.field,
-        value: null
-      };
-      return replaceRelatedRecord(graph, newOp, isRemote);
-    }
-    return;
-  }
-  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);
+	const { record, value } = op;
+	const relationship = graph.get(record, op.field);
+	const _isBelongsTo = isBelongsTo(relationship);
+	if (isRemote && _isBelongsTo) {
+		if (value === relationship.remoteState) {
+			const newOp = {
+				op: "replaceRelatedRecord",
+				record,
+				field: op.field,
+				value: null
+			};
+			return replaceRelatedRecord(graph, newOp, isRemote);
+		}
+		return;
+	}
+	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, isRemote ? void 0 : "local");
 }
 function removeRelatedRecord(graph, record, relationship, value, index, isRemote) {
-  if (_remove(graph, record, relationship, value, index, isRemote)) {
-    removeFromInverse(graph, value, relationship.definition.inverseKey, record, isRemote);
-  }
+	if (_remove(graph, record, relationship, value, index, isRemote)) removeFromInverse(graph, value, relationship.definition.inverseKey, record, isRemote);
 }
 
-/*
-  This method normalizes a link to an "links object". If the passed link is
-  already an object it's returned without any modifications.
-
-  See http://jsonapi.org/format/#document-links for more information.
-*/
+//#endregion
+//#region src/graph/-private/normalize-link.ts
 function _normalizeLink(link) {
-  switch (typeof link) {
-    case 'object':
-      return link;
-    case 'string':
-      return {
-        href: link
-      };
-  }
+	switch (typeof link) {
+		case "object": return link;
+		case "string": return { href: link };
+	}
 }
 
-/*
-    Updates the "canonical" or "remote" state of a relationship, replacing any existing
-    state and blowing away any local changes (excepting new records).
-*/
+//#endregion
+//#region src/graph/-private/operations/update-relationship.ts
 function updateRelationshipOperation(graph, op) {
-  const relationship = graph.get(op.record, op.field);
-  const {
-    definition,
-    state,
-    identifier
-  } = relationship;
-  const {
-    isCollection
-  } = definition;
-  const payload = op.value;
-  let hasRelationshipDataProperty = false;
-  let hasUpdatedLink = false;
-  if (payload.meta) {
-    relationship.meta = payload.meta;
-  }
-  if (payload.data !== undefined) {
-    hasRelationshipDataProperty = true;
-    if (isCollection) {
-      // TODO deprecate this case. We
-      // have tests saying we support it.
-      if (payload.data === null) {
-        payload.data = [];
-      }
-      const cache = graph.store.cacheKeyManager;
-      graph.update({
-        op: 'replaceRelatedRecords',
-        record: identifier,
-        field: op.field,
-        value: upgradeIdentifiers(payload.data, cache)
-      }, true);
-    } else {
-      graph.update({
-        op: 'replaceRelatedRecord',
-        record: identifier,
-        field: op.field,
-        value: payload.data ? graph.store.cacheKeyManager.upgradeIdentifier(payload.data) : null
-      }, true);
-    }
-  } else if (definition.isAsync === false && !state.hasReceivedData) {
-    hasRelationshipDataProperty = true;
-    if (isCollection) {
-      graph.update({
-        op: 'replaceRelatedRecords',
-        record: identifier,
-        field: op.field,
-        value: []
-      }, true);
-    } else {
-      graph.update({
-        op: 'replaceRelatedRecord',
-        record: identifier,
-        field: op.field,
-        value: null
-      }, true);
-    }
-  }
-  if (payload.links) {
-    const originalLinks = relationship.links;
-    relationship.links = payload.links;
-    if (payload.links.related) {
-      const relatedLink = _normalizeLink(payload.links.related);
-      const currentLink = originalLinks && originalLinks.related ? _normalizeLink(originalLinks.related) : null;
-      const currentLinkHref = currentLink ? currentLink.href : null;
-      if (relatedLink && relatedLink.href && relatedLink.href !== currentLinkHref) {
-        hasUpdatedLink = true;
-      }
-    }
-  }
-
-  /*
-       Data being pushed into the relationship might contain only data or links,
-       or a combination of both.
-        IF contains only data
-       IF contains both links and data
-        state.isEmpty -> true if is empty array (has-many) or is null (belongs-to)
-        state.hasReceivedData -> true
-        hasDematerializedInverse -> false
-        state.isStale -> false
-        allInverseRecordsAreLoaded -> run-check-to-determine
-        IF contains only links
-        state.isStale -> true
-       */
-  relationship.state.hasFailedLoadAttempt = false;
-  if (hasRelationshipDataProperty) {
-    const relationshipIsEmpty = payload.data === null || Array.isArray(payload.data) && payload.data.length === 0;
-
-    // we don't need to notify here as the update op we pushed in above will notify once
-    // membership is in the correct state.
-    relationship.state.hasReceivedData = true;
-    relationship.state.isStale = false;
-    relationship.state.hasDematerializedInverse = false;
-    relationship.state.isEmpty = relationshipIsEmpty;
-  } else if (hasUpdatedLink) {
-    // only notify stale if we have not previously received membership data.
-    // within this same transaction
-    // this prevents refetching when only one side of the relationship in the
-    // payload contains the info while the other side contains just a link
-    // this only works when the side with just a link is a belongsTo, as we
-    // don't know if a hasMany has full information or not.
-    // see #7049 for context.
-    if (isCollection || !relationship.state.hasReceivedData || isStaleTransaction(relationship.transactionRef, graph._transaction)) {
-      relationship.state.isStale = true;
-      notifyChange(graph, relationship);
-    } else {
-      relationship.state.isStale = false;
-    }
-  }
+	const relationship = graph.get(op.record, op.field);
+	const { definition, identifier } = relationship;
+	const { isCollection } = definition;
+	const payload = op.value;
+	let hasRelationshipDataProperty = false;
+	let hasUpdatedLink = false;
+	if (payload.meta) relationship.meta = payload.meta;
+	if (payload.data !== void 0) {
+		hasRelationshipDataProperty = true;
+		if (isCollection) {
+			if (payload.data === null) payload.data = [];
+			const cache = graph.store.cacheKeyManager;
+			graph.update({
+				op: "replaceRelatedRecords",
+				record: identifier,
+				field: op.field,
+				value: upgradeIdentifiers(payload.data, cache)
+			}, true);
+		} else graph.update({
+			op: "replaceRelatedRecord",
+			record: identifier,
+			field: op.field,
+			value: payload.data ? graph.store.cacheKeyManager.upgradeIdentifier(payload.data) : null
+		}, true);
+	}
+	if (payload.links) {
+		const originalLinks = relationship.links;
+		relationship.links = payload.links;
+		if (payload.links.related) {
+			const relatedLink = _normalizeLink(payload.links.related);
+			const currentLink = originalLinks && originalLinks.related ? _normalizeLink(originalLinks.related) : null;
+			const currentLinkHref = currentLink ? currentLink.href : null;
+			if (relatedLink && relatedLink.href && relatedLink.href !== currentLinkHref) hasUpdatedLink = true;
+		}
+	}
+	relationship.state.hasFailedLoadAttempt = false;
+	if (hasRelationshipDataProperty) {
+		const relationshipIsEmpty = payload.data === null || Array.isArray(payload.data) && payload.data.length === 0;
+		relationship.state.hasReceivedData = true;
+		relationship.state.hasReceivedRemoteData = true;
+		relationship.state.isStale = false;
+		relationship.state.hasDematerializedInverse = false;
+		relationship.state.isEmpty = relationshipIsEmpty;
+	} else if (hasUpdatedLink) {
+		if (isCollection || !relationship.state.hasReceivedData || isStaleTransaction(relationship.transactionRef, graph._transaction)) {
+			relationship.state.isStale = true;
+			notifyChange(graph, relationship);
+		} else relationship.state.isStale = false;
+	}
 }
 function isStaleTransaction(relationshipTransactionId, graphTransactionId) {
-  return relationshipTransactionId === 0 ||
-  // relationship has never notified
-  graphTransactionId === null ||
-  // we are not in a transaction
-  relationshipTransactionId < graphTransactionId // we are not part of the current transaction
-  ;
+	return relationshipTransactionId === 0 || graphTransactionId === null || relationshipTransactionId < graphTransactionId;
 }
 function upgradeIdentifiers(arr, cache) {
-  for (let i = 0; i < arr.length; i++) {
-    arr[i] = cache.upgradeIdentifier(arr[i]);
-  }
-  return arr;
-}
-const Graphs = getOrSetGlobal('Graphs', new Map());
-/*
- * Graph acts as the cache for relationship data. It allows for
- * us to ask about and update relationships for a given Identifier
- * without requiring other objects for that Identifier to be
- * instantiated (such as `RecordData` or a `Record`)
- *
- * This also allows for us to make more substantive changes to relationships
- * with increasingly minor alterations to other portions of the internals
- * over time.
- *
- * The graph is made up of nodes and edges. Each unique identifier gets
- * its own node, which is a dictionary with a list of that node's edges
- * (or connections) to other nodes. In `Model` terms, a node represents a
- * record instance, with each key (an edge) in the dictionary correlating
- * to either a `hasMany` or `belongsTo` field on that record instance.
- *
- * The value for each key, or `edge` is the identifier(s) the node relates
- * to in the graph from that key.
- */
-class Graph {
-  constructor(store) {
-    this._definitionCache = Object.create(null);
-    this._metaCache = Object.create(null);
-    this._potentialPolymorphicTypes = Object.create(null);
-    this.identifiers = new Map();
-    this.store = store;
-    this._realStore = store._store;
-    this.isDestroyed = false;
-    this._willSyncRemote = false;
-    this._willSyncLocal = false;
-    this._pushedUpdates = {
-      belongsTo: undefined,
-      hasMany: undefined,
-      deletions: []
-    };
-    this._updatedRelationships = new Set();
-    this._transaction = null;
-    this._removing = null;
-    this.silenceNotifications = false;
-  }
-  has(resourceKey, propertyName) {
-    const relationships = this.identifiers.get(resourceKey);
-    if (!relationships) {
-      return false;
-    }
-    return relationships[propertyName] !== undefined;
-  }
-  getDefinition(resourceKey, propertyName) {
-    let defs = this._metaCache[resourceKey.type];
-    let meta = defs?.[propertyName];
-    if (!meta) {
-      const info = /*#__NOINLINE__*/upgradeDefinition(this, resourceKey, propertyName);
-
-      // if (info.rhs_definition?.kind === 'implicit') {
-      // we should possibly also do this
-      // but it would result in being extremely permissive for other relationships by accident
-      // this.registerPolymorphicType(info.rhs_baseModelName, identifier.type);
-      // }
-
-      meta = /*#__NOINLINE__*/isLHS(info, resourceKey.type, propertyName) ? info.lhs_definition : info.rhs_definition;
-      defs = this._metaCache[resourceKey.type] = defs || {};
-      defs[propertyName] = meta;
-    }
-    return meta;
-  }
-  get(resourceKey, propertyName) {
-    let relationships = this.identifiers.get(resourceKey);
-    if (!relationships) {
-      relationships = Object.create(null);
-      this.identifiers.set(resourceKey, relationships);
-    }
-    let relationship = relationships[propertyName];
-    if (!relationship) {
-      const meta = this.getDefinition(resourceKey, propertyName);
-      if (meta.kind === 'belongsTo') {
-        relationship = relationships[propertyName] = createResourceEdge(meta, resourceKey);
-      } else if (meta.kind === 'hasMany') {
-        relationship = relationships[propertyName] = createCollectionEdge(meta, resourceKey);
-      } else {
-        relationship = relationships[propertyName] = createImplicitEdge(meta, resourceKey);
-      }
-    }
-    return relationship;
-  }
-  getData(resourceKey, propertyName) {
-    const relationship = this.get(resourceKey, propertyName);
-    if (isBelongsTo(relationship)) {
-      return legacyGetResourceRelationshipData(relationship, false);
-    }
-    return legacyGetCollectionRelationshipData(relationship, false);
-  }
-  getRemoteData(resourceKey, propertyName) {
-    const relationship = this.get(resourceKey, propertyName);
-    if (isBelongsTo(relationship)) {
-      return legacyGetResourceRelationshipData(relationship, true);
-    }
-    return legacyGetCollectionRelationshipData(relationship, true);
-  }
-
-  /*
-   * Allows for the graph to dynamically discover polymorphic connections
-   * without needing to walk prototype chains.
-   *
-   * Used by edges when an added `type` does not match the expected `type`
-   * for that edge.
-   *
-   * Currently we assert before calling this. For a public API we will want
-   * to call out to the schema manager to ask if we should consider these
-   * types as equivalent for a given relationship.
-   */
-  registerPolymorphicType(type1, type2) {
-    const typeCache = this._potentialPolymorphicTypes;
-    let t1 = typeCache[type1];
-    if (!t1) {
-      t1 = typeCache[type1] = Object.create(null);
-    }
-    t1[type2] = true;
-    let t2 = typeCache[type2];
-    if (!t2) {
-      t2 = typeCache[type2] = Object.create(null);
-    }
-    t2[type1] = true;
-  }
-  isReleasable(resourceKey) {
-    const relationships = this.identifiers.get(resourceKey);
-    if (!relationships) {
-      return true;
-    }
-    const keys = Object.keys(relationships);
-    for (let i = 0; i < keys.length; i++) {
-      const relationship = relationships[keys[i]];
-      // account for previously unloaded relationships
-      // typically from a prior deletion of a record that pointed to this one implicitly
-      if (relationship === undefined) {
-        continue;
-      }
-      if (relationship.definition.inverseIsAsync && !checkIfNew(this._realStore, resourceKey)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  unload(resourceKey, silenceNotifications) {
-    const relationships = this.identifiers.get(resourceKey);
-    if (relationships) {
-      // cleans up the graph but retains some nodes
-      // to allow for rematerialization
-      Object.keys(relationships).forEach(key => {
-        const rel = relationships[key];
-        if (!rel) {
-          return;
-        }
-        /*#__NOINLINE__*/
-        destroyRelationship(this, rel, silenceNotifications);
-        if (/*#__NOINLINE__*/isImplicit(rel)) {
-          // @ts-expect-error
-          relationships[key] = undefined;
-        }
-      });
-    }
-  }
-  _isDirty(resourceKey, field) {
-    const relationships = this.identifiers.get(resourceKey);
-    if (!relationships) {
-      return false;
-    }
-    const relationship = relationships[field];
-    if (!relationship) {
-      return false;
-    }
-    if (isBelongsTo(relationship)) {
-      return relationship.localState !== relationship.remoteState;
-    } else if (isHasMany(relationship)) {
-      const hasAdditions = relationship.additions !== null && relationship.additions.size > 0;
-      const hasRemovals = relationship.removals !== null && relationship.removals.size > 0;
-      return hasAdditions || hasRemovals || isReordered(relationship);
-    }
-    return false;
-  }
-  getChanged(resourceKey) {
-    const relationships = this.identifiers.get(resourceKey);
-    const changed = new Map();
-    if (!relationships) {
-      return changed;
-    }
-    const keys = Object.keys(relationships);
-    for (let i = 0; i < keys.length; i++) {
-      const field = keys[i];
-      const relationship = relationships[field];
-      if (!relationship) {
-        continue;
-      }
-      if (isBelongsTo(relationship)) {
-        if (relationship.localState !== relationship.remoteState) {
-          changed.set(field, {
-            kind: 'resource',
-            remoteState: relationship.remoteState,
-            localState: relationship.localState
-          });
-        }
-      } else if (isHasMany(relationship)) {
-        const hasAdditions = relationship.additions !== null && relationship.additions.size > 0;
-        const hasRemovals = relationship.removals !== null && relationship.removals.size > 0;
-        const reordered = isReordered(relationship);
-        if (hasAdditions || hasRemovals || reordered) {
-          changed.set(field, {
-            kind: 'collection',
-            additions: new Set(relationship.additions),
-            removals: new Set(relationship.removals),
-            remoteState: relationship.remoteState,
-            localState: legacyGetCollectionRelationshipData(relationship, false).data || [],
-            reordered
-          });
-        }
-      }
-    }
-    return changed;
-  }
-  hasChanged(resourceKey) {
-    const relationships = this.identifiers.get(resourceKey);
-    if (!relationships) {
-      return false;
-    }
-    const keys = Object.keys(relationships);
-    for (let i = 0; i < keys.length; i++) {
-      if (this._isDirty(resourceKey, keys[i])) {
-        return true;
-      }
-    }
-    return false;
-  }
-  rollback(resourceKey) {
-    const relationships = this.identifiers.get(resourceKey);
-    const changed = [];
-    if (!relationships) {
-      return changed;
-    }
-    const keys = Object.keys(relationships);
-    for (let i = 0; i < keys.length; i++) {
-      const field = keys[i];
-      const relationship = relationships[field];
-      if (!relationship) {
-        continue;
-      }
-      if (this._isDirty(resourceKey, field)) {
-        rollbackRelationship(this, resourceKey, field, relationship);
-        changed.push(field);
-      }
-    }
-    return changed;
-  }
-  remove(resourceKey) {
-    this._removing = resourceKey;
-    this.unload(resourceKey);
-    this.identifiers.delete(resourceKey);
-    this._removing = null;
-  }
-
-  /*
-   * Remote state changes
-   */
-  push(op) {
-    if (op.op === 'deleteRecord') {
-      this._pushedUpdates.deletions.push(op);
-    } else {
-      const definition = this.getDefinition(op.record, op.field);
-      addPending(this._pushedUpdates, definition, op);
-    }
-    if (!this._willSyncRemote) {
-      this._willSyncRemote = true;
-      const store = getStore(this.store);
-      if (!store._cbs) {
-        store._run(() => this._flushRemoteQueue());
-      } else {
-        store._schedule('coalesce', () => this._flushRemoteQueue());
-      }
-    }
-  }
-
-  /*
-   * Local state changes
-   */
-
-  update(op, isRemote = false) {
-    switch (op.op) {
-      case 'mergeIdentifiers':
-        {
-          const relationships = this.identifiers.get(op.record);
-          if (relationships) {
-            /*#__NOINLINE__*/mergeIdentifier(this, op, relationships);
-          }
-          break;
-        }
-      case 'update':
-      case 'updateRelationship':
-        /*#__NOINLINE__*/updateRelationshipOperation(this, op);
-        break;
-      case 'deleteRecord':
-        {
-          const identifier = op.record;
-          const relationships = this.identifiers.get(identifier);
-          if (relationships) {
-            Object.keys(relationships).forEach(key => {
-              const rel = relationships[key];
-              if (!rel) {
-                return;
-              }
-              // works together with the has check
-              // @ts-expect-error
-              relationships[key] = undefined;
-              /*#__NOINLINE__*/
-              removeCompletelyFromInverse(this, rel);
-            });
-            this.identifiers.delete(identifier);
-          }
-          break;
-        }
-      case 'replaceRelatedRecord':
-        /*#__NOINLINE__*/replaceRelatedRecord(this, op, isRemote);
-        break;
-      case 'add':
-        /*#__NOINLINE__*/addToRelatedRecords(this, op, isRemote);
-        break;
-      case 'remove':
-        /*#__NOINLINE__*/removeFromRelatedRecords(this, op, isRemote);
-        break;
-      case 'replaceRelatedRecords':
-        /*#__NOINLINE__*/replaceRelatedRecords(this, op, isRemote);
-        break;
-    }
-  }
-  _scheduleLocalSync(relationship) {
-    this._updatedRelationships.add(relationship);
-    if (!this._willSyncLocal) {
-      this._willSyncLocal = true;
-      getStore(this.store)._schedule('sync', () => this._flushLocalQueue());
-    }
-  }
-  _flushRemoteQueue() {
-    if (!this._willSyncRemote) {
-      return;
-    }
-    let transactionRef = peekTransient('transactionRef') ?? 0;
-    this._transaction = ++transactionRef;
-    setTransient('transactionRef', transactionRef);
-    this._willSyncRemote = false;
-    const updates = this._pushedUpdates;
-    const {
-      deletions,
-      hasMany,
-      belongsTo
-    } = updates;
-    updates.deletions = [];
-    updates.hasMany = undefined;
-    updates.belongsTo = undefined;
-    for (let i = 0; i < deletions.length; i++) {
-      this.update(deletions[i], true);
-    }
-    if (hasMany) {
-      flushPending(this, hasMany);
-    }
-    if (belongsTo) {
-      flushPending(this, belongsTo);
-    }
-    this._transaction = null;
-  }
-  _addToTransaction(relationship) {
-    relationship.transactionRef = this._transaction;
-  }
-  _flushLocalQueue() {
-    if (!this._willSyncLocal) {
-      return;
-    }
-    if (this.silenceNotifications) {
-      this.silenceNotifications = false;
-      this._updatedRelationships = new Set();
-      return;
-    }
-    this._willSyncLocal = false;
-    const updated = this._updatedRelationships;
-    this._updatedRelationships = new Set();
-    updated.forEach(rel => notifyChange(this, rel));
-  }
-  destroy() {
-    Graphs.delete(this.store);
-    this.identifiers.clear();
-    this.store = null;
-    this.isDestroyed = true;
-  }
+	for (let i = 0; i < arr.length; i++) arr[i] = cache.upgradeIdentifier(arr[i]);
+	return arr;
 }
+
+//#endregion
+//#region src/graph/-private/graph.ts
+/**
+* A single edge (relationship field) tracked by the {@link Graph} for a resource. Which kind of edge
+* a field is depends on its relationship definition:
+*
+* - {@link ResourceEdge}: the "one" side of a `belongsTo`/resource relationship
+* - {@link CollectionEdge}: the "many" side of a `hasMany`/collection relationship
+* - {@link ImplicitEdge}: a synthesized inverse used when a relationship has no field defined for its inverse
+*/
+const Graphs = getOrSetGlobal("Graphs", /* @__PURE__ */ new Map());
+/**
+* Graph is WarpDrive's internal, private cache of all resource relationships.
+*
+* It acts as the cache for relationship data, allowing us to ask about and update
+* relationships for a given Identifier without requiring other objects for that
+* Identifier to be instantiated (such as `RecordData` or a `Record`).
+*
+* This also allows for us to make more substantive changes to relationships
+* with increasingly minor alterations to other portions of the internals
+* over time.
+*
+* The graph is made up of nodes and edges. Each unique identifier gets
+* its own node, which is a dictionary with a list of that node's edges
+* (or connections) to other nodes. In `Model` terms, a node represents a
+* record instance, with each key (an edge) in the dictionary correlating
+* to either a `hasMany` or `belongsTo` field on that record instance.
+*
+* The value for each key, or `edge` is the identifier(s) the node relates
+* to in the graph from that key.
+*/
+var Graph = class {
+	/**
+	* Cache of resolved {@link EdgeDefinition}s (the paired LHS/RHS relationship definitions
+	* for a `type` + `key`), keyed by resource `type` and then field name. Populated lazily by
+	* `upgradeDefinition` and consulted by {@link Graph.getDefinition}.
+	*/
+	/**
+	* Cache of the resolved {@link UpgradedMeta} for a given resource `type` and field name, as
+	* returned by {@link Graph.getDefinition}. Derived from `_definitionCache` the first time a
+	* field's definition is looked up.
+	*/
+	/**
+	* Tracks pairs of resource types that have been discovered to be polymorphically related, so
+	* that the graph can recognize this connection without needing to walk prototype/schema
+	* inheritance chains. Populated by {@link Graph.registerPolymorphicType}.
+	*/
+	/**
+	* The nodes of the graph. Each {@link ResourceKey} maps to a dictionary of its relationship
+	* fields (edges), keyed by field name.
+	*/
+	/**
+	* The `CacheCapabilitiesManager` (store wrapper) this graph was created for. Used to schedule
+	* work and to notify of relationship changes.
+	*/
+	/**
+	* The real underlying `Store` instance backing {@link Graph.store}, used for capabilities
+	* (such as checking whether a resource is a new/unsaved client-side record) that are not
+	* exposed on `CacheCapabilitiesManager`.
+	*/
+	/**
+	* `true` once {@link Graph.destroy} has been called. After this point the graph should no
+	* longer be used.
+	*/
+	/**
+	* `true` when a flush of the remote-update queue has been scheduled but has not yet run.
+	* Set by {@link Graph.push} and cleared by {@link Graph._flushRemoteQueue}.
+	*/
+	/**
+	* `true` when a flush of the local-update notification queue has been scheduled but has not
+	* yet run. Set by {@link Graph._scheduleLocalSync} and cleared by
+	* {@link Graph._flushLocalQueue}.
+	*/
+	/**
+	* When `true`, the next scheduled local sync will be dropped without notifying subscribers of
+	* the relationships that changed. Consumed and reset by {@link Graph._flushLocalQueue}.
+	*/
+	/**
+	* Remote relationship operations and record deletions that have been pushed via
+	* {@link Graph.push} but not yet flushed into the graph by {@link Graph._flushRemoteQueue}.
+	*/
+	/**
+	* 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
+	* in progress. Set by {@link Graph._flushRemoteQueue} and stamped onto edges via
+	* {@link Graph._addToTransaction}.
+	*/
+	/**
+	* The {@link ResourceKey} currently being removed via {@link Graph.remove}, or `null`. Used to
+	* guard against re-entrant removal of the same resource.
+	*/
+	constructor(store) {
+		this._definitionCache = Object.create(null);
+		this._metaCache = Object.create(null);
+		this._potentialPolymorphicTypes = Object.create(null);
+		this.identifiers = /* @__PURE__ */ new Map();
+		this.store = store;
+		this._realStore = store._store;
+		this.isDestroyed = false;
+		this._willSyncRemote = false;
+		this._willSyncLocal = false;
+		this._pushedUpdates = {
+			belongsTo: void 0,
+			hasMany: void 0,
+			deletions: []
+		};
+		this._updatedRelationships = /* @__PURE__ */ new Map();
+		this._transaction = null;
+		this._removing = null;
+		this.silenceNotifications = false;
+	}
+	/**
+	* Returns `true` if an edge has already been created in the graph for the given resource and
+	* field name, without creating one if it does not yet exist.
+	*/
+	has(resourceKey, propertyName) {
+		const relationships = this.identifiers.get(resourceKey);
+		if (!relationships) return false;
+		return relationships[propertyName] !== void 0;
+	}
+	/**
+	* Returns the resolved {@link UpgradedMeta} (relationship definition) for the given resource
+	* `type` and field name, computing and caching it via `upgradeDefinition` on first access.
+	*/
+	getDefinition(resourceKey, propertyName) {
+		let defs = this._metaCache[resourceKey.type];
+		let meta = defs?.[propertyName];
+		if (!meta) {
+			const info = upgradeDefinition(this, resourceKey, propertyName);
+			meta = isLHS(info, resourceKey.type, propertyName) ? info.lhs_definition : info.rhs_definition;
+			defs = this._metaCache[resourceKey.type] = defs || {};
+			defs[propertyName] = meta;
+		}
+		return meta;
+	}
+	/**
+	* Returns the {@link GraphEdge} for the given resource and field name, creating it (as a
+	* {@link ResourceEdge}, {@link CollectionEdge}, or {@link ImplicitEdge} depending on the
+	* field's kind) if it does not already exist.
+	*/
+	get(resourceKey, propertyName) {
+		let relationships = this.identifiers.get(resourceKey);
+		if (!relationships) {
+			relationships = Object.create(null);
+			this.identifiers.set(resourceKey, relationships);
+		}
+		let relationship = relationships[propertyName];
+		if (!relationship) {
+			const meta = this.getDefinition(resourceKey, propertyName);
+			if (meta.kind === "belongsTo") relationship = relationships[propertyName] = createResourceEdge(meta, resourceKey);
+			else if (meta.kind === "hasMany") relationship = relationships[propertyName] = createCollectionEdge(meta, resourceKey);
+			else relationship = relationships[propertyName] = createImplicitEdge(meta, resourceKey);
+		}
+		return relationship;
+	}
+	/**
+	* Returns the local (current, potentially dirty) JSON:API relationship data for a `belongsTo`
+	* or `hasMany` field. Asserts if the field is an implicit relationship.
+	*/
+	getData(resourceKey, propertyName) {
+		const relationship = this.get(resourceKey, propertyName);
+		if (isBelongsTo(relationship)) return legacyGetResourceRelationshipData(relationship, false);
+		return legacyGetCollectionRelationshipData(relationship, false);
+	}
+	/**
+	* Returns the remote (last known server-confirmed) JSON:API relationship data for a
+	* `belongsTo` or `hasMany` field. Asserts if the field is an implicit relationship.
+	*/
+	getRemoteData(resourceKey, propertyName) {
+		const relationship = this.get(resourceKey, propertyName);
+		if (isBelongsTo(relationship)) return legacyGetResourceRelationshipData(relationship, true);
+		return legacyGetCollectionRelationshipData(relationship, true);
+	}
+	/**
+	* Allows for the graph to dynamically discover polymorphic connections
+	* without needing to walk prototype chains.
+	*
+	* Used by edges when an added `type` does not match the expected `type`
+	* for that edge.
+	*
+	* Currently we assert before calling this. For a public API we will want
+	* to call out to the schema manager to ask if we should consider these
+	* types as equivalent for a given relationship.
+	*/
+	registerPolymorphicType(type1, type2) {
+		const typeCache = this._potentialPolymorphicTypes;
+		let t1 = typeCache[type1];
+		if (!t1) t1 = typeCache[type1] = Object.create(null);
+		t1[type2] = true;
+		let t2 = typeCache[type2];
+		if (!t2) t2 = typeCache[type2] = Object.create(null);
+		t2[type1] = true;
+	}
+	/**
+	* Determines whether a resource is safe to fully release from memory. A resource is not
+	* releasable if it has a relationship whose inverse is async and the resource itself is not a
+	* new (unsaved, client-only) record, since the inverse may still need to reference it.
+	*/
+	isReleasable(resourceKey) {
+		const relationships = this.identifiers.get(resourceKey);
+		if (!relationships) return true;
+		const keys = Object.keys(relationships);
+		for (let i = 0; i < keys.length; i++) {
+			const relationship = relationships[keys[i]];
+			if (relationship === void 0) continue;
+			if (relationship.definition.inverseIsAsync && !checkIfNew(this._realStore, resourceKey)) return false;
+		}
+		return true;
+	}
+	/**
+	* Cleans up all relationships for a resource that is being dematerialized, notifying inverses
+	* so they can update their own state. This retains the graph's node structure (so it can be
+	* rematerialized later) except for implicit edges, which are discarded outright.
+	*/
+	unload(resourceKey, silenceNotifications) {
+		const relationships = this.identifiers.get(resourceKey);
+		if (relationships) Object.keys(relationships).forEach((key) => {
+			const rel = relationships[key];
+			if (!rel) return;
+			destroyRelationship(this, rel, silenceNotifications);
+			if (isImplicit(rel)) relationships[key] = void 0;
+		});
+	}
+	/**
+	* Returns `true` if the given field on a resource has uncommitted local changes: for a
+	* `belongsTo` this means local and remote state differ; for a `hasMany` this means there are
+	* pending additions, removals, or a reordering relative to remote state.
+	*/
+	_isDirty(resourceKey, field) {
+		const relationships = this.identifiers.get(resourceKey);
+		if (!relationships) return false;
+		const relationship = relationships[field];
+		if (!relationship) return false;
+		if (isBelongsTo(relationship)) return relationship.localState !== relationship.remoteState;
+		else if (isHasMany(relationship)) {
+			const hasAdditions = relationship.additions !== null && relationship.additions.size > 0;
+			const hasRemovals = relationship.removals !== null && relationship.removals.size > 0;
+			return hasAdditions || hasRemovals || isReordered(relationship);
+		}
+		return false;
+	}
+	/**
+	* Builds a map, keyed by field name, of every relationship on a resource that has uncommitted
+	* local changes, describing each change as a {@link RelationshipDiff}.
+	*/
+	getChanged(resourceKey) {
+		const relationships = this.identifiers.get(resourceKey);
+		const changed = /* @__PURE__ */ new Map();
+		if (!relationships) return changed;
+		const keys = Object.keys(relationships);
+		for (let i = 0; i < keys.length; i++) {
+			const field = keys[i];
+			const relationship = relationships[field];
+			if (!relationship) continue;
+			if (isBelongsTo(relationship)) {
+				if (relationship.localState !== relationship.remoteState) changed.set(field, {
+					kind: "resource",
+					remoteState: relationship.remoteState,
+					localState: relationship.localState
+				});
+			} else if (isHasMany(relationship)) {
+				const hasAdditions = relationship.additions !== null && relationship.additions.size > 0;
+				const hasRemovals = relationship.removals !== null && relationship.removals.size > 0;
+				const reordered = isReordered(relationship);
+				if (hasAdditions || hasRemovals || reordered) changed.set(field, {
+					kind: "collection",
+					additions: new Set(relationship.additions),
+					removals: new Set(relationship.removals),
+					remoteState: relationship.remoteState,
+					localState: legacyGetCollectionRelationshipData(relationship, false).data || [],
+					reordered
+				});
+			}
+		}
+		return changed;
+	}
+	/**
+	* Returns `true` if any relationship field on the resource has uncommitted local changes.
+	*/
+	hasChanged(resourceKey) {
+		const relationships = this.identifiers.get(resourceKey);
+		if (!relationships) return false;
+		const keys = Object.keys(relationships);
+		for (let i = 0; i < keys.length; i++) if (this._isDirty(resourceKey, keys[i])) return true;
+		return false;
+	}
+	/**
+	* Reverts all locally dirty relationships on a resource back to their remote state, returning
+	* the list of field names that were rolled back.
+	*/
+	rollback(resourceKey) {
+		const relationships = this.identifiers.get(resourceKey);
+		const changed = [];
+		if (!relationships) return changed;
+		const keys = Object.keys(relationships);
+		for (let i = 0; i < keys.length; i++) {
+			const field = keys[i];
+			const relationship = relationships[field];
+			if (!relationship) continue;
+			if (this._isDirty(resourceKey, field)) {
+				rollbackRelationship(this, resourceKey, field, relationship);
+				changed.push(field);
+			}
+		}
+		return changed;
+	}
+	/**
+	* Fully removes a resource and all of its relationships from the graph, unloading its edges
+	* first so inverses are properly notified/cleaned up.
+	*/
+	remove(resourceKey) {
+		this._removing = resourceKey;
+		this.unload(resourceKey);
+		this.identifiers.delete(resourceKey);
+		this._removing = null;
+	}
+	/**
+	* Queues a remote relationship operation (or record deletion) to be applied to the graph.
+	* Pushed operations are batched and flushed asynchronously (see {@link Graph._flushRemoteQueue})
+	* rather than applied immediately.
+	*/
+	push(op) {
+		if (op.op === "deleteRecord") this._pushedUpdates.deletions.push(op);
+		else {
+			const definition = this.getDefinition(op.record, op.field);
+			addPending(this._pushedUpdates, definition, op);
+		}
+		if (!this._willSyncRemote) {
+			this._willSyncRemote = true;
+			const store = getStore(this.store);
+			if (!store._cbs) store._run(() => this._flushRemoteQueue());
+			else store._schedule("coalesce", () => this._flushRemoteQueue());
+		}
+	}
+	/**
+	* Applies a remote relationship operation or identifier merge directly to the graph. Pass
+	* `isRemote: true` to indicate the operation represents confirmed server state rather than a
+	* local (client-side) change.
+	*/
+	/**
+	* Applies a local (client-side) relationship operation directly to the graph, such as adding,
+	* removing, or replacing related records before it has been confirmed by the server.
+	*/
+	/**
+	* Implementation for both the remote and local {@link Graph.update} overloads: dispatches the
+	* given operation (`mergeIdentifiers`, `updateRelationship`, `deleteRecord`, `add`, `remove`,
+	* `replaceRelatedRecord`, or `replaceRelatedRecords`) to the appropriate handler.
+	*/
+	update(op, isRemote = false) {
+		switch (op.op) {
+			case "mergeIdentifiers": {
+				const relationships = this.identifiers.get(op.record);
+				if (relationships) mergeIdentifier(this, op, relationships);
+				break;
+			}
+			case "update":
+			case "updateRelationship":
+				updateRelationshipOperation(this, op);
+				break;
+			case "deleteRecord": {
+				const identifier = op.record;
+				const relationships = this.identifiers.get(identifier);
+				if (relationships) {
+					Object.keys(relationships).forEach((key) => {
+						const rel = relationships[key];
+						if (!rel) return;
+						relationships[key] = void 0;
+						removeCompletelyFromInverse(this, rel);
+					});
+					this.identifiers.delete(identifier);
+				}
+				break;
+			}
+			case "replaceRelatedRecord":
+				replaceRelatedRecord(this, op, isRemote);
+				break;
+			case "add":
+				addToRelatedRecords(this, op, isRemote);
+				break;
+			case "remove":
+				removeFromRelatedRecords(this, op, isRemote);
+				break;
+			case "replaceRelatedRecords": replaceRelatedRecords(this, op, isRemote);
+		}
+	}
+	/**
+	* 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, 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());
+		}
+	}
+	/**
+	* Flushes all remote operations queued via {@link Graph.push}, applying them within a single
+	* transaction (see {@link Graph._transaction} and {@link Graph._addToTransaction}) so that
+	* dependent edges updated during the flush can be distinguished from those that were not.
+	*/
+	_flushRemoteQueue() {
+		if (!this._willSyncRemote) return;
+		let transactionRef = peekTransient("transactionRef") ?? 0;
+		this._transaction = ++transactionRef;
+		setTransient("transactionRef", transactionRef);
+		this._willSyncRemote = false;
+		const updates = this._pushedUpdates;
+		const { deletions, hasMany, belongsTo } = updates;
+		updates.deletions = [];
+		updates.hasMany = void 0;
+		updates.belongsTo = void 0;
+		for (let i = 0; i < deletions.length; i++) this.update(deletions[i], true);
+		if (hasMany) flushPending(this, hasMany);
+		if (belongsTo) flushPending(this, belongsTo);
+		this._transaction = null;
+	}
+	/**
+	* Stamps the current remote-update transaction id onto an edge, marking it as having been
+	* touched during the in-progress {@link Graph._flushRemoteQueue} run. Must only be called while
+	* a transaction is active.
+	*/
+	_addToTransaction(relationship) {
+		relationship.transactionRef = this._transaction;
+	}
+	/**
+	* Flushes the queue of relationships scheduled via {@link Graph._scheduleLocalSync}, notifying
+	* subscribers of each changed relationship — unless {@link Graph.silenceNotifications} is set,
+	* in which case the queue is discarded without notifying.
+	*/
+	_flushLocalQueue() {
+		if (!this._willSyncLocal) return;
+		if (this.silenceNotifications) {
+			this.silenceNotifications = false;
+			this._updatedRelationships = /* @__PURE__ */ new Map();
+			return;
+		}
+		this._willSyncLocal = false;
+		const updated = this._updatedRelationships;
+		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
+	* {@link Graphs} registry, and marks it as destroyed. In debug builds this also asserts that no
+	* other live, non-destroying graphs remain registered, to help catch memory leaks from
+	* improperly torn down store instances.
+	*/
+	destroy() {
+		Graphs.delete(this.store);
+		this.identifiers.clear();
+		this.store = null;
+		this.isDestroyed = true;
+	}
+};
 function flushPending(graph, ops) {
-  for (const type of ops.values()) {
-    for (const opList of type.values()) {
-      flushPendingList(graph, opList);
-    }
-  }
+	for (const type of ops.values()) for (const opList of type.values()) flushPendingList(graph, opList);
 }
 function flushPendingList(graph, opList) {
-  for (let i = 0; i < opList.length; i++) {
-    graph.update(opList[i], true);
-  }
+	for (let i = 0; i < opList.length; i++) graph.update(opList[i], true);
 }
-
-// Handle dematerialization for relationship `rel`.  In all cases, notify the
-// relationship of the dematerialization: this is done so the relationship can
-// notify its inverse which needs to update state
-//
-// If the inverse is sync, unloading this record is treated as a client-side
-// delete, so we remove the inverse records from this relationship to
-// disconnect the graph.  Because it's not async, we don't need to keep around
-// the identifier as an id-wrapper for references
 function destroyRelationship(graph, rel, silenceNotifications) {
-  if (isImplicit(rel)) {
-    if (graph.isReleasable(rel.identifier)) {
-      /*#__NOINLINE__*/removeCompletelyFromInverse(graph, rel);
-    }
-    return;
-  }
-  const {
-    identifier
-  } = rel;
-  const {
-    inverseKey
-  } = rel.definition;
-  if (!rel.definition.inverseIsImplicit) {
-    /*#__NOINLINE__*/forAllRelatedIdentifiers(rel, inverseIdentifer => /*#__NOINLINE__*/notifyInverseOfDematerialization(graph, inverseIdentifer, inverseKey, identifier, silenceNotifications));
-  }
-  if (!rel.definition.inverseIsImplicit && !rel.definition.inverseIsAsync) {
-    rel.state.isStale = true;
-    /*#__NOINLINE__*/
-    clearRelationship(rel);
-
-    // necessary to clear relationships in the ui from dematerialized records
-    // hasMany is managed by Model which calls `retreiveLatest` after
-    // dematerializing the resource-cache instance.
-    // but sync belongsTo requires this since they don't have a proxy to update.
-    // so we have to notify so it will "update" to null.
-    // we should discuss whether we still care about this, probably fine to just
-    // leave the ui relationship populated since the record is destroyed and
-    // internally we've fully cleaned up.
-    if (!rel.definition.isAsync && !silenceNotifications) {
-      /*#__NOINLINE__*/notifyChange(graph, rel);
-    }
-  }
+	if (isImplicit(rel)) {
+		if (graph.isReleasable(rel.identifier)) removeCompletelyFromInverse(graph, rel);
+		return;
+	}
+	const { identifier } = rel;
+	const { inverseKey } = rel.definition;
+	if (!rel.definition.inverseIsImplicit) forAllRelatedIdentifiers(rel, (inverseIdentifer) => notifyInverseOfDematerialization(graph, inverseIdentifer, inverseKey, identifier, silenceNotifications));
+	if (!rel.definition.inverseIsImplicit && !rel.definition.inverseIsAsync) {
+		rel.state.isStale = true;
+		clearRelationship(rel);
+		if (!rel.definition.isAsync && !silenceNotifications) notifyChange(graph, rel);
+	}
 }
 function notifyInverseOfDematerialization(graph, inverseIdentifier, inverseKey, resourceKey, silenceNotifications) {
-  if (!graph.has(inverseIdentifier, inverseKey)) {
-    return;
-  }
-  const relationship = graph.get(inverseIdentifier, inverseKey);
-
-  // For remote members, it is possible that inverseRecordData has already been associated to
-  // to another record. For such cases, do not dematerialize the inverseRecordData
-  if (!isBelongsTo(relationship) || !relationship.localState || resourceKey === relationship.localState) {
-    /*#__NOINLINE__*/removeDematerializedInverse(graph, relationship, resourceKey, silenceNotifications);
-  }
+	if (!graph.has(inverseIdentifier, inverseKey)) return;
+	const relationship = graph.get(inverseIdentifier, inverseKey);
+	if (!isBelongsTo(relationship) || !relationship.localState || resourceKey === relationship.localState) removeDematerializedInverse(graph, relationship, resourceKey, silenceNotifications);
 }
 function clearRelationship(relationship) {
-  if (isBelongsTo(relationship)) {
-    relationship.localState = null;
-    relationship.remoteState = null;
-    relationship.state.hasReceivedData = false;
-    relationship.state.isEmpty = true;
-  } else {
-    relationship.remoteMembers.clear();
-    relationship.remoteState = [];
-    relationship.additions = null;
-    relationship.removals = null;
-    relationship.localState = null;
-  }
+	if (isBelongsTo(relationship)) {
+		relationship.localState = null;
+		relationship.remoteState = null;
+		relationship.state.hasReceivedData = false;
+		relationship.state.isEmpty = true;
+	} else {
+		relationship.remoteMembers.clear();
+		relationship.remoteState = [];
+		relationship.additions = null;
+		relationship.removals = null;
+		relationship.localState = null;
+	}
 }
 function removeDematerializedInverse(graph, relationship, inverseIdentifier, silenceNotifications) {
-  if (isBelongsTo(relationship)) {
-    const localInverse = relationship.localState;
-    if (!relationship.definition.isAsync || localInverse && checkIfNew(graph._realStore, localInverse)) {
-      // unloading inverse of a sync relationship is treated as a client-side
-      // delete, so actually remove the models don't merely invalidate the cp
-      // cache.
-      // if the record being unloaded only exists on the client, we similarly
-      // treat it as a client side delete
-      if (relationship.localState === localInverse && localInverse !== null) {
-        relationship.localState = null;
-      }
-      if (relationship.remoteState === localInverse && localInverse !== null) {
-        relationship.remoteState = null;
-        relationship.state.hasReceivedData = true;
-        relationship.state.isEmpty = true;
-        if (relationship.localState && !checkIfNew(graph._realStore, relationship.localState)) {
-          relationship.localState = null;
-        }
-      }
-    } else {
-      relationship.state.hasDematerializedInverse = true;
-    }
-    if (!silenceNotifications) {
-      notifyChange(graph, relationship);
-    }
-  } else {
-    if (!relationship.definition.isAsync || inverseIdentifier && checkIfNew(graph._realStore, inverseIdentifier)) {
-      // unloading inverse of a sync relationship is treated as a client-side
-      // delete, so actually remove the models don't merely invalidate the cp
-      // cache.
-      // if the record being unloaded only exists on the client, we similarly
-      // treat it as a client side delete
-      /*#__NOINLINE__*/
-      removeIdentifierCompletelyFromRelationship(graph, relationship, inverseIdentifier);
-    } else {
-      relationship.state.hasDematerializedInverse = true;
-    }
-    if (!silenceNotifications) {
-      notifyChange(graph, relationship);
-    }
-  }
+	if (isBelongsTo(relationship)) {
+		const localInverse = relationship.localState;
+		if (!relationship.definition.isAsync || localInverse && checkIfNew(graph._realStore, localInverse)) {
+			if (relationship.localState === localInverse && localInverse !== null) relationship.localState = null;
+			if (relationship.remoteState === localInverse && localInverse !== null) {
+				relationship.remoteState = null;
+				relationship.state.hasReceivedData = true;
+				relationship.state.isEmpty = true;
+				if (relationship.localState && !checkIfNew(graph._realStore, relationship.localState)) relationship.localState = null;
+			}
+		} else relationship.state.hasDematerializedInverse = true;
+		if (!silenceNotifications) notifyChange(graph, relationship);
+	} else {
+		if (!relationship.definition.isAsync || inverseIdentifier && checkIfNew(graph._realStore, inverseIdentifier)) removeIdentifierCompletelyFromRelationship(graph, relationship, inverseIdentifier);
+		else relationship.state.hasDematerializedInverse = true;
+		if (!silenceNotifications) notifyChange(graph, relationship);
+	}
 }
 function removeCompletelyFromInverse(graph, relationship) {
-  const {
-    identifier
-  } = relationship;
-  const {
-    inverseKey
-  } = relationship.definition;
-  forAllRelatedIdentifiers(relationship, inverseIdentifier => {
-    if (graph.has(inverseIdentifier, inverseKey)) {
-      removeIdentifierCompletelyFromRelationship(graph, graph.get(inverseIdentifier, inverseKey), identifier);
-    }
-  });
-  if (isBelongsTo(relationship)) {
-    if (!relationship.definition.isAsync) {
-      clearRelationship(relationship);
-    }
-    relationship.localState = null;
-  } else if (isHasMany(relationship)) {
-    if (!relationship.definition.isAsync) {
-      clearRelationship(relationship);
-      notifyChange(graph, relationship);
-    }
-  } else {
-    relationship.remoteMembers.clear();
-    relationship.localMembers.clear();
-  }
+	const { identifier } = relationship;
+	const { inverseKey } = relationship.definition;
+	forAllRelatedIdentifiers(relationship, (inverseIdentifier) => {
+		if (graph.has(inverseIdentifier, inverseKey)) removeIdentifierCompletelyFromRelationship(graph, graph.get(inverseIdentifier, inverseKey), identifier);
+	});
+	if (isBelongsTo(relationship)) {
+		if (!relationship.definition.isAsync) clearRelationship(relationship);
+		relationship.localState = null;
+	} else if (isHasMany(relationship)) {
+		if (!relationship.definition.isAsync) {
+			clearRelationship(relationship);
+			notifyChange(graph, relationship);
+		}
+	} else {
+		relationship.remoteMembers.clear();
+		relationship.localMembers.clear();
+	}
 }
 function addPending(cache, definition, op) {
-  const cacheForKind = cache[definition.kind] = cache[definition.kind] || new Map();
-  let cacheForType = cacheForKind.get(definition.inverseType);
-  if (!cacheForType) {
-    cacheForType = new Map();
-    cacheForKind.set(definition.inverseType, cacheForType);
-  }
-  let cacheForField = cacheForType.get(op.field);
-  if (!cacheForField) {
-    cacheForField = [];
-    cacheForType.set(op.field, cacheForField);
-  }
-  cacheForField.push(op);
+	const cacheForKind = cache[definition.kind] = cache[definition.kind] || /* @__PURE__ */ new Map();
+	let cacheForType = cacheForKind.get(definition.inverseType);
+	if (!cacheForType) {
+		cacheForType = /* @__PURE__ */ new Map();
+		cacheForKind.set(definition.inverseType, cacheForType);
+	}
+	let cacheForField = cacheForType.get(op.field);
+	if (!cacheForField) {
+		cacheForField = [];
+		cacheForType.set(op.field, cacheForField);
+	}
+	cacheForField.push(op);
 }
 function isReordered(relationship) {
-  // if we are dirty we are never re-ordered because accessing
-  // the state would flush away any reordering.
-  if (relationship.isDirty) {
-    return false;
-  }
-  const {
-    remoteState,
-    localState,
-    additions,
-    removals
-  } = relationship;
-  if (localState === null) {
-    // the relationship has never been accessed, so it hasn't been reordered either
-    return false;
-  }
-  for (let i = 0, j = 0; i < remoteState.length; i++) {
-    const member = remoteState[i];
-    const localMember = localState[j];
-    if (member !== localMember) {
-      if (removals && removals.has(member)) {
-        // dont increment j because we want to skip this
-        continue;
-      }
-      if (additions && additions.has(localMember)) {
-        // increment j to skip this localMember
-        // decrement i to repeat this remoteMember
-        j++;
-        i--;
-        continue;
-      }
-      return true;
-    }
-
-    // if we made it here, increment j
-    j++;
-  }
-  return false;
-}
-
+	if (relationship.isDirty) return false;
+	const { remoteState, localState, additions, removals } = relationship;
+	if (localState === null) return false;
+	for (let i = 0, j = 0; i < remoteState.length; i++) {
+		const member = remoteState[i];
+		const localMember = localState[j];
+		if (member !== localMember) {
+			if (removals && removals.has(member)) continue;
+			if (additions && additions.has(localMember)) {
+				j++;
+				i--;
+				continue;
+			}
+			return true;
+		}
+		j++;
+	}
+	return false;
+}
+
+//#endregion
+//#region src/graph/-private.ts
 /**
 Provides a performance tuned normalized graph for intelligently managing relationships between resources based on identity
 
@@ -2210,26 +1598,31 @@ While this Graph is abstract, it currently is a private implementation required
 
 We intend to make this Graph public API after some additional iteration during the 5.x timeframe, until then all APIs should be considered experimental and unstable, not fit for direct application or 3rd party library usage.
 
-  @module
+@module
 */
-
 function isStore(maybeStore) {
-  return maybeStore._instanceCache !== undefined;
+	return maybeStore._instanceCache !== void 0;
 }
 function getWrapper(store) {
-  return isStore(store) ? store._instanceCache._storeWrapper : store;
+	return isStore(store) ? store._instanceCache._storeWrapper : store;
 }
+/** Returns the {@link Graph} associated with the given store or capabilities manager, if one has been created. */
 function peekGraph(store) {
-  return Graphs.get(getWrapper(store));
+	return Graphs.get(getWrapper(store));
 }
+/** The type of the {@link peekGraph} function. */
+/** Returns the {@link Graph} for the given store, creating (and caching) one first if it does not yet exist. */
 function graphFor(store) {
-  const wrapper = getWrapper(store);
-  let graph = Graphs.get(wrapper);
-  if (!graph) {
-    graph = new Graph(wrapper);
-    Graphs.set(wrapper, graph);
-    getStore(wrapper)._graph = graph;
-  }
-  return graph;
-}
-export { graphFor, isBelongsTo, peekGraph };
+	const wrapper = getWrapper(store);
+	let graph = Graphs.get(wrapper);
+	if (!graph) {
+		graph = new Graph(wrapper);
+		Graphs.set(wrapper, graph);
+		getStore(wrapper)._graph = graph;
+	}
+	return graph;
+}
+
+//#endregion
+export { graphFor, isBelongsTo, peekGraph };
+//# sourceMappingURL=-private.js.map