@warp-drive/json-api 5.9.0-beta.0 → 5.9.0-beta.2

package/dist/unpkg/prod-deprecated/index.js

@@ -1,1884 +1,1333 @@
-import { graphFor, peekGraph, isBelongsTo } from '@warp-drive/core/graph/-private';
-import { assertPrivateCapabilities, isResourceKey, isRequestKey } from '@warp-drive/core/store/-private';
-import 'fuse.js';
-import 'json-to-ast';
+import { graphFor, isBelongsTo, peekGraph } from "@warp-drive/core/graph/-private";
+import { assertPrivateCapabilities, isRequestKey, isResourceKey } from "@warp-drive/core/store/-private";
+import "fuse.js";
+import "json-to-ast";
 
+//#region src/-private/validator/utils.ts
 function isMetaDocument(doc) {
-  return !(doc instanceof Error) && doc.content && !('data' in doc.content) && !('included' in doc.content) && 'meta' in doc.content;
+	return !(doc instanceof Error) && doc.content && !("data" in doc.content) && !("included" in doc.content) && "meta" in doc.content;
 }
 function isErrorDocument(doc) {
-  return doc instanceof Error;
+	return doc instanceof Error;
 }
 
+//#endregion
+//#region src/-private/cache.ts
 function isImplicit(relationship) {
-  return relationship.definition.isImplicit;
+	return relationship.definition.isImplicit;
 }
-const EMPTY_ITERATOR = {
-  iterator() {
-    return {
-      next() {
-        return {
-          done: true,
-          value: undefined
-        };
-      }
-    };
-  }
-};
+const EMPTY_ITERATOR = { iterator() {
+	return { next() {
+		return {
+			done: true,
+			value: void 0
+		};
+	} };
+} };
 function makeCache() {
-  return {
-    id: null,
-    remoteAttrs: null,
-    localAttrs: null,
-    defaultAttrs: null,
-    inflightAttrs: null,
-    changes: null,
-    errors: null,
-    isNew: false,
-    isDeleted: false,
-    isDeletionCommitted: false
-  };
+	return {
+		id: null,
+		remoteAttrs: null,
+		localAttrs: null,
+		defaultAttrs: null,
+		inflightAttrs: null,
+		changes: null,
+		errors: null,
+		isNew: false,
+		isDeleted: false,
+		isDeletionCommitted: false
+	};
 }
-
 /**
- * ```ts
- * import { JSONAPICache } from '@warp-drive/json-api';
- * ```
- *
- * A {@link Cache} implementation tuned for [{json:api}](https://jsonapi.org/)
- *
- * @categoryDescription Cache Management
- * APIs for primary cache management functionality
- * @categoryDescription Cache Forking
- * APIs that support Cache Forking
- * @categoryDescription SSR Support
- * APIs that support SSR functionality
- * @categoryDescription Resource Lifecycle
- * APIs that support management of resource data
- * @categoryDescription Resource Data
- * APIs that support granular field level management of resource data
- * @categoryDescription Resource State
- * APIs that support managing Resource states
- *
- * @public
- */
-class JSONAPICache {
-  /**
-   * The Cache Version that this implementation implements.
-   *
-   * @public
-   */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  constructor(capabilities) {
-    this.version = '2';
-    this._capabilities = capabilities;
-    this.__cache = new Map();
-    this.__graph = graphFor(capabilities);
-    this.__destroyedCache = new Map();
-    this.__documents = new Map();
-  }
-
-  ////////// ================ //////////
-  ////////// Cache Management //////////
-  ////////// ================ //////////
-
-  /**
-   * Cache the response to a request
-   *
-   * Implements `Cache.put`.
-   *
-   * Expects a StructuredDocument whose `content` member is a JsonApiDocument.
-   *
-   * ```js
-   * cache.put({
-   *   request: { url: 'https://api.example.com/v1/user/1' },
-   *   content: {
-   *     data: {
-   *       type: 'user',
-   *       id: '1',
-   *       attributes: {
-   *         name: 'Chris'
-   *       }
-   *     }
-   *   }
-   * })
-   * ```
-   *
-   * > **Note**
-   * > The nested `content` and `data` members are not a mistake. This is because
-   * > there are two separate concepts involved here, the `StructuredDocument` which contains
-   * > the context of a given Request that has been issued with the returned contents as its
-   * > `content` property, and a `JSON:API Document` which is the json contents returned by
-   * > this endpoint and which uses its `data` property to signify which resources are the
-   * > primary resources associated with the request.
-   *
-   * StructuredDocument's with urls will be cached as full documents with
-   * associated resource membership order and contents preserved but linked
-   * into the cache.
-   *
-   * @category Cache Management
-   * @public
-   */
-
-  put(doc) {
-    if (isErrorDocument(doc)) {
-      return this._putDocument(doc, undefined, undefined);
-    } else if (isMetaDocument(doc)) {
-      return this._putDocument(doc, undefined, undefined);
-    }
-    const jsonApiDoc = doc.content;
-    const included = jsonApiDoc.included;
-    let i, length;
-    const {
-      cacheKeyManager
-    } = this._capabilities;
-    if (included) {
-      for (i = 0, length = included.length; i < length; i++) {
-        included[i] = putOne(this, cacheKeyManager, included[i]);
-      }
-    }
-    if (Array.isArray(jsonApiDoc.data)) {
-      length = jsonApiDoc.data.length;
-      const identifiers = [];
-      for (i = 0; i < length; i++) {
-        identifiers.push(putOne(this, cacheKeyManager, jsonApiDoc.data[i]));
-      }
-      return this._putDocument(doc, identifiers, included);
-    }
-    if (jsonApiDoc.data === null) {
-      return this._putDocument(doc, null, included);
-    }
-    const identifier = putOne(this, cacheKeyManager, jsonApiDoc.data);
-    return this._putDocument(doc, identifier, included);
-  }
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-  _putDocument(doc, data, included) {
-    // @ts-expect-error narrowing within is just horrible  in TS :/
-    const resourceDocument = isErrorDocument(doc) ? fromStructuredError(doc) : fromBaseDocument(doc);
-    if (data !== undefined) {
-      resourceDocument.data = data;
-    }
-    if (included !== undefined) {
-      resourceDocument.included = included;
-    }
-    const request = doc.request;
-    const identifier = request ? this._capabilities.cacheKeyManager.getOrCreateDocumentIdentifier(request) : null;
-    if (identifier) {
-      resourceDocument.lid = identifier.lid;
-
-      // @ts-expect-error
-      doc.content = resourceDocument;
-      const hasExisting = this.__documents.has(identifier.lid);
-      this.__documents.set(identifier.lid, doc);
-      this._capabilities.notifyChange(identifier, hasExisting ? 'updated' : 'added', null);
-    }
-    if (doc.request?.op === 'findHasMany') {
-      const parentIdentifier = doc.request.options?.identifier;
-      const parentField = doc.request.options?.field;
-      if (parentField && parentIdentifier) {
-        this.__graph.push({
-          op: 'updateRelationship',
-          record: parentIdentifier,
-          field: parentField.name,
-          value: resourceDocument
-        });
-      }
-    }
-    return resourceDocument;
-  }
-
-  /**
-   * Update the "remote" or "canonical" (persisted) state of the Cache
-   * by merging new information into the existing state.
-   *
-   * @category Cache Management
-   * @public
-   * @param op the operation or list of operations to perform
-   */
-  patch(op) {
-    if (Array.isArray(op)) {
-      assertPrivateCapabilities(this._capabilities);
-      this._capabilities._store._join(() => {
-        for (const operation of op) {
-          patchCache(this, operation);
-        }
-      });
-    } else {
-      patchCache(this, op);
-    }
-  }
-
-  /**
-   * Update the "local" or "current" (unpersisted) state of the Cache
-   *
-   * @category Cache Management
-   * @public
-   */
-  mutate(mutation) {
-    this.__graph.update(mutation, false);
-  }
-
-  /**
-   * Peek resource data from the Cache.
-   *
-   * In development, if the return value
-   * is JSON the return value
-   * will be deep-cloned and deep-frozen
-   * to prevent mutation thereby enforcing cache
-   * Immutability.
-   *
-   * This form of peek is useful for implementations
-   * that want to feed raw-data from cache to the UI
-   * or which want to interact with a blob of data
-   * directly from the presentation cache.
-   *
-   * An implementation might want to do this because
-   * de-referencing records which read from their own
-   * blob is generally safer because the record does
-   * not require retainining connections to the Store
-   * and Cache to present data on a per-field basis.
-   *
-   * This generally takes the place of `getAttr` as
-   * an API and may even take the place of `getRelationship`
-   * depending on implementation specifics, though this
-   * latter usage is less recommended due to the advantages
-   * of the Graph handling necessary entanglements and
-   * notifications for relational data.
-   *
-   * :::warning
-   * It is not recommended to use the return value as
-   * a serialized representation of the resource both
-   * due to it containing local mutations and because
-   * it may contain additional fields not recognized
-   * by the {json:api} API implementation such as `lid` and
-   * the various internal WarpDrive bookkeeping fields.
-   * :::
-   *
-   * @category Cache Management
-   * @public
-   */
-
-  peek(identifier) {
-    if (isResourceKey(identifier)) {
-      const peeked = this.__safePeek(identifier, false);
-      if (!peeked) {
-        return null;
-      }
-      const {
-        type,
-        id,
-        lid
-      } = identifier;
-      const attributes = structuredClone(Object.assign({}, peeked.remoteAttrs, peeked.inflightAttrs, peeked.localAttrs));
-      const relationships = {};
-      const rels = this.__graph.identifiers.get(identifier);
-      if (rels) {
-        Object.keys(rels).forEach(key => {
-          const rel = rels[key];
-          if (rel.definition.isImplicit) {
-            return;
-          } else {
-            relationships[key] = this.__graph.getData(identifier, key);
-          }
-        });
-      }
-      assertPrivateCapabilities(this._capabilities);
-      const store = this._capabilities._store;
-      const attrs = getCacheFields(this, identifier);
-      attrs.forEach((attr, key) => {
-        if (key in attributes && attributes[key] !== undefined) {
-          return;
-        }
-        const defaultValue = getDefaultValue(attr, identifier, store);
-        if (defaultValue !== undefined) {
-          attributes[key] = defaultValue;
-        }
-      });
-      return {
-        type,
-        id,
-        lid,
-        attributes,
-        relationships
-      };
-    }
-    const document = this.peekRequest(identifier);
-    if (document) {
-      if ('content' in document) return document.content;
-    }
-    return null;
-  }
-
-  /**
-   * Peek the remote resource data from the Cache.
-   *
-   * @category Cache Management
-   * @public
-   */
-
-  peekRemoteState(identifier) {
-    if (isResourceKey(identifier)) {
-      const peeked = this.__safePeek(identifier, false);
-      if (!peeked) {
-        return null;
-      }
-      const {
-        type,
-        id,
-        lid
-      } = identifier;
-      const attributes = structuredClone(peeked.remoteAttrs);
-      const relationships = {};
-      const rels = this.__graph.identifiers.get(identifier);
-      if (rels) {
-        Object.keys(rels).forEach(key => {
-          const rel = rels[key];
-          if (rel.definition.isImplicit) {
-            return;
-          } else {
-            relationships[key] = structuredClone(this.__graph.getData(identifier, key));
-          }
-        });
-      }
-      assertPrivateCapabilities(this._capabilities);
-      const store = this._capabilities._store;
-      const attrs = getCacheFields(this, identifier);
-      attrs.forEach((attr, key) => {
-        if (key in attributes && attributes[key] !== undefined) {
-          return;
-        }
-        const defaultValue = getDefaultValue(attr, identifier, store);
-        if (defaultValue !== undefined) {
-          attributes[key] = defaultValue;
-        }
-      });
-      return {
-        type,
-        id,
-        lid,
-        attributes,
-        relationships
-      };
-    }
-    const document = this.peekRequest(identifier);
-    if (document) {
-      if ('content' in document) return document.content;
-    }
-    return null;
-  }
-
-  /**
-   * Peek the Cache for the existing request data associated with
-   * a cacheable request.
-   *
-   * This is effectively the reverse of `put` for a request in
-   * that it will return the the request, response, and content
-   * whereas `peek` will return just the `content`.
-   *
-   * @category Cache Management
-   * @public
-   */
-  peekRequest(identifier) {
-    return this.__documents.get(identifier.lid) || null;
-  }
-
-  /**
-   * Push resource data from a remote source into the cache for this identifier
-   *
-   * @category Cache Management
-   * @public
-   * @return if `calculateChanges` is true then calculated key changes should be returned
-   */
-  upsert(identifier, data, calculateChanges) {
-    assertPrivateCapabilities(this._capabilities);
-    const store = this._capabilities._store;
-    if (!store._cbs) {
-      let result = undefined;
-      store._run(() => {
-        result = cacheUpsert(this, identifier, data, calculateChanges);
-      });
-      return result;
-    }
-    return cacheUpsert(this, identifier, data, calculateChanges);
-  }
-
-  ////////// ============= //////////
-  ////////// Cache Forking //////////
-  ////////// ============= //////////
-
-  /**
-   * Create a fork of the cache from the current state.
-   *
-   * Applications should typically not call this method themselves,
-   * preferring instead to fork at the Store level, which will
-   * utilize this method to fork the cache.
-   *
-   * @category Cache Forking
-   * @private
-   */
-  fork() {
-    throw new Error(`Not Implemented`);
-  }
-
-  /**
-   * Merge a fork back into a parent Cache.
-   *
-   * Applications should typically not call this method themselves,
-   * preferring instead to merge at the Store level, which will
-   * utilize this method to merge the caches.
-   *
-   * @category Cache Forking
-   * @private
-   */
-  merge(_cache) {
-    throw new Error(`Not Implemented`);
-  }
-
-  /**
-   * Generate the list of changes applied to all
-   * record in the store.
-   *
-   * Each individual resource or document that has
-   * been mutated should be described as an individual
-   * `Change` entry in the returned array.
-   *
-   * A `Change` is described by an object containing up to
-   * three properties: (1) the `identifier` of the entity that
-   * changed; (2) the `op` code of that change being one of
-   * `upsert` or `remove`, and if the op is `upsert` a `patch`
-   * containing the data to merge into the cache for the given
-   * entity.
-   *
-   * This `patch` is opaque to the Store but should be understood
-   * by the Cache and may expect to be utilized by an Adapter
-   * when generating data during a `save` operation.
-   *
-   * It is generally recommended that the `patch` contain only
-   * the updated state, ignoring fields that are unchanged
-   *
-   * ```ts
-   * interface Change {
-   *  identifier: ResourceKey | RequestKey;
-   *  op: 'upsert' | 'remove';
-   *  patch?: unknown;
-   * }
-   * ```
-   *
-   * @category Cache Forking
-   * @private
-   */
-  diff() {
-    throw new Error(`Not Implemented`);
-  }
-
-  ////////// =========== //////////
-  ////////// SSR Support //////////
-  ////////// =========== //////////
-
-  /**
-   * Serialize the entire contents of the Cache into a Stream
-   * which may be fed back into a new instance of the same Cache
-   * via `cache.hydrate`.
-   *
-   * @category SSR Support
-   * @private
-   */
-  dump() {
-    throw new Error(`Not Implemented`);
-  }
-
-  /**
-   * hydrate a Cache from a Stream with content previously serialized
-   * from another instance of the same Cache, resolving when hydration
-   * is complete.
-   *
-   * This method should expect to be called both in the context of restoring
-   * the Cache during application rehydration after SSR **AND** at unknown
-   * times during the lifetime of an already booted application when it is
-   * desired to bulk-load additional information into the cache. This latter
-   * behavior supports optimizing pre/fetching of data for route transitions
-   * via data-only SSR modes.
-   *
-   * @category SSR Support
-   * @private
-   */
-  hydrate(stream) {
-    throw new Error('Not Implemented');
-  }
-
-  ////////// ================== //////////
-  ////////// Resource Lifecycle //////////
-  ////////// ================== //////////
-
-  /**
-   * [LIFECYCLE] Signal to the cache that a new record has been instantiated on the client
-   *
-   * It returns properties from options that should be set on the record during the create
-   * process. This return value behavior is deprecated.
-   *
-   * @category Resource Lifecycle
-   * @public
-   */
-  clientDidCreate(identifier, options) {
-    const cached = this._createCache(identifier);
-    cached.isNew = true;
-    const createOptions = {};
-    if (options !== undefined) {
-      const fields = getCacheFields(this, identifier);
-      const graph = this.__graph;
-      const propertyNames = Object.keys(options);
-      for (let i = 0; i < propertyNames.length; i++) {
-        const name = propertyNames[i];
-        const propertyValue = options[name];
-        if (name === 'id') {
-          continue;
-        }
-        const fieldType = fields.get(name);
-        const kind = fieldType !== undefined ? 'kind' in fieldType ? fieldType.kind : 'attribute' : null;
-        let relationship;
-        switch (kind) {
-          case 'attribute':
-            this.setAttr(identifier, name, propertyValue);
-            createOptions[name] = propertyValue;
-            break;
-          case 'belongsTo':
-            this.mutate({
-              op: 'replaceRelatedRecord',
-              field: name,
-              record: identifier,
-              value: propertyValue
-            });
-            relationship = graph.get(identifier, name);
-            relationship.state.hasReceivedData = true;
-            relationship.state.isEmpty = false;
-            break;
-          case 'hasMany':
-            this.mutate({
-              op: 'replaceRelatedRecords',
-              field: name,
-              record: identifier,
-              value: propertyValue
-            });
-            relationship = graph.get(identifier, name);
-            relationship.state.hasReceivedData = true;
-            relationship.state.isEmpty = false;
-            break;
-          default:
-            // reflect back (pass-thru) unknown properties
-            createOptions[name] = propertyValue;
-        }
-      }
-    }
-    this._capabilities.notifyChange(identifier, 'added', null);
-    return createOptions;
-  }
-
-  /**
-   * [LIFECYCLE] Signals to the cache that a resource
-   * will be part of a save transaction.
-   *
-   * @category Resource Lifecycle
-   * @public
-   */
-  willCommit(identifier, _context) {
-    if (Array.isArray(identifier)) {
-      for (const key of identifier) {
-        willCommit(this, key);
-      }
-    } else {
-      willCommit(this, identifier);
-    }
-  }
-
-  /**
-   * [LIFECYCLE] Signals to the cache that a resource
-   * was successfully updated as part of a save transaction.
-   *
-   * @category Resource Lifecycle
-   * @public
-   */
-
-  didCommit(committedIdentifier, result) {
-    const payload = result ? result.content : null;
-    const operation = result?.request?.op ?? null;
-    const data = payload && payload.data;
-    const responseIsCollection = Array.isArray(data);
-    const hasMultipleIdentifiers = Array.isArray(committedIdentifier) && committedIdentifier.length > 1;
-    if (Array.isArray(committedIdentifier)) {
-      if (responseIsCollection) {
-        for (let i = 0; i < committedIdentifier.length; i++) {
-          const identifier = committedIdentifier[i];
-          didCommit(this, identifier, data[i] ?? null, operation);
-        }
-        // but if we get back no data or a single entry, we apply
-        // the change back to the original identifier
-      } else {
-        for (let i = 0; i < committedIdentifier.length; i++) {
-          const identifier = committedIdentifier[i];
-          didCommit(this, identifier, i === 0 ? data : null, operation);
-        }
-      }
-    } else {
-      didCommit(this, committedIdentifier, data, operation);
-    }
-    const included = payload && payload.included;
-    const {
-      cacheKeyManager
-    } = this._capabilities;
-    if (included) {
-      for (let i = 0, length = included.length; i < length; i++) {
-        putOne(this, cacheKeyManager, included[i]);
-      }
-    }
-    return hasMultipleIdentifiers && responseIsCollection ? {
-      data: committedIdentifier
-    } : {
-      data: Array.isArray(committedIdentifier) ? committedIdentifier[0] : committedIdentifier
-    };
-  }
-
-  /**
-   * [LIFECYCLE] Signals to the cache that a resource
-   * was update via a save transaction failed.
-   *
-   * @category Resource Lifecycle
-   * @public
-   */
-  commitWasRejected(identifier, errors) {
-    if (Array.isArray(identifier)) {
-      for (let i = 0; i < identifier.length; i++) {
-        commitDidError(this, identifier[i], errors && i === 0 ? errors : null);
-      }
-      return;
-    }
-    return commitDidError(this, identifier, errors || null);
-  }
-
-  /**
-   * [LIFECYCLE] Signals to the cache that all data for a resource
-   * should be cleared.
-   *
-   * This method is a candidate to become a mutation
-   *
-   * @category Resource Lifecycle
-   * @public
-   */
-  unloadRecord(identifier) {
-    const storeWrapper = this._capabilities;
-    // TODO this is necessary because
-    // we maintain memebership inside InstanceCache
-    // for peekAll, so even though we haven't created
-    // any data we think this exists.
-    // TODO can we eliminate that membership now?
-    if (!this.__cache.has(identifier)) {
-      // the graph may still need to unload identity
-      peekGraph(storeWrapper)?.unload(identifier);
-      return;
-    }
-    const removeFromRecordArray = !this.isDeletionCommitted(identifier);
-    let removed = false;
-    const cached = this.__peek(identifier, false);
-    if (cached.isNew || cached.isDeletionCommitted) {
-      peekGraph(storeWrapper)?.push({
-        op: 'deleteRecord',
-        record: identifier,
-        isNew: cached.isNew
-      });
-    } else {
-      peekGraph(storeWrapper)?.unload(identifier);
-    }
-
-    // effectively clearing these is ensuring that
-    // we report as `isEmpty` during teardown.
-    cached.localAttrs = null;
-    cached.remoteAttrs = null;
-    cached.defaultAttrs = null;
-    cached.inflightAttrs = null;
-    const relatedIdentifiers = _allRelatedIdentifiers(storeWrapper, identifier);
-    if (areAllModelsUnloaded(storeWrapper, relatedIdentifiers)) {
-      for (let i = 0; i < relatedIdentifiers.length; ++i) {
-        const relatedIdentifier = relatedIdentifiers[i];
-        storeWrapper.notifyChange(relatedIdentifier, 'removed', null);
-        removed = true;
-        storeWrapper.disconnectRecord(relatedIdentifier);
-      }
-    }
-    this.__cache.delete(identifier);
-    this.__destroyedCache.set(identifier, cached);
-
-    /*
-     * The destroy cache is a hack to prevent applications
-     * from blowing up during teardown. Accessing state
-     * on a destroyed record is not safe, but historically
-     * was possible due to a combination of teardown timing
-     * and retention of cached state directly on the
-     * record itself.
-     *
-     * Once we have deprecated accessing state on a destroyed
-     * instance we may remove this. The timing isn't a huge deal
-     * as momentarily retaining the objects outside the bounds
-     * of a test won't cause issues.
-     */
-    if (this.__destroyedCache.size === 1) {
-      // TODO do we still need this?
-      setTimeout(() => {
-        this.__destroyedCache.clear();
-      }, 100);
-    }
-    if (!removed && removeFromRecordArray) {
-      storeWrapper.notifyChange(identifier, 'removed', null);
-    }
-  }
-
-  ////////// ============= //////////
-  ////////// Resource Data //////////
-  ////////// ============= //////////
-
-  /**
-   * Retrieve the data for an attribute from the cache
-   * with local mutations applied.
-   *
-   * @category Resource Data
-   * @public
-   */
-  getAttr(identifier, attr) {
-    const isSimplePath = !Array.isArray(attr) || attr.length === 1;
-    if (Array.isArray(attr) && attr.length === 1) {
-      attr = attr[0];
-    }
-    if (isSimplePath) {
-      const attribute = attr;
-      const cached = this.__peek(identifier, true);
-
-      // in Prod we try to recover when accessing something that
-      // doesn't exist
-      if (!cached) {
-        return undefined;
-      }
-      if (cached.localAttrs && attribute in cached.localAttrs) {
-        return cached.localAttrs[attribute];
-      } else if (cached.inflightAttrs && attribute in cached.inflightAttrs) {
-        return cached.inflightAttrs[attribute];
-      } else if (cached.remoteAttrs && attribute in cached.remoteAttrs) {
-        return cached.remoteAttrs[attribute];
-      } else if (cached.defaultAttrs && attribute in cached.defaultAttrs) {
-        return cached.defaultAttrs[attribute];
-      } else {
-        const attrSchema = getCacheFields(this, identifier).get(attribute);
-        assertPrivateCapabilities(this._capabilities);
-        const defaultValue = getDefaultValue(attrSchema, identifier, this._capabilities._store);
-        if (schemaHasLegacyDefaultValueFn(attrSchema)) {
-          cached.defaultAttrs = cached.defaultAttrs || Object.create(null);
-          cached.defaultAttrs[attribute] = defaultValue;
-        }
-        return defaultValue;
-      }
-    }
-
-    // TODO @runspired consider whether we need a defaultValue cache in ReactiveResource
-    // like we do for the simple case above.
-    const path = attr;
-    const cached = this.__peek(identifier, true);
-    const basePath = path[0];
-    let current = cached.localAttrs && basePath in cached.localAttrs ? cached.localAttrs[basePath] : undefined;
-    if (current === undefined) {
-      current = cached.inflightAttrs && basePath in cached.inflightAttrs ? cached.inflightAttrs[basePath] : undefined;
-    }
-    if (current === undefined) {
-      current = cached.remoteAttrs && basePath in cached.remoteAttrs ? cached.remoteAttrs[basePath] : undefined;
-    }
-    if (current === undefined) {
-      return undefined;
-    }
-    for (let i = 1; i < path.length; i++) {
-      current = current[path[i]];
-      if (current === undefined) {
-        return undefined;
-      }
-    }
-    return current;
-  }
-
-  /**
-   * Retrieve the remote data for an attribute from the cache
-   *
-   * @category Resource Data
-   * @public
-   */
-  getRemoteAttr(identifier, attr) {
-    const isSimplePath = !Array.isArray(attr) || attr.length === 1;
-    if (Array.isArray(attr) && attr.length === 1) {
-      attr = attr[0];
-    }
-    if (isSimplePath) {
-      const attribute = attr;
-      const cached = this.__peek(identifier, true);
-
-      // in Prod we try to recover when accessing something that
-      // doesn't exist
-      if (!cached) {
-        return undefined;
-      }
-      if (cached.remoteAttrs && attribute in cached.remoteAttrs) {
-        return cached.remoteAttrs[attribute];
-
-        // we still show defaultValues in the case of a remoteAttr access
-      } else if (cached.defaultAttrs && attribute in cached.defaultAttrs) {
-        return cached.defaultAttrs[attribute];
-      } else {
-        const attrSchema = getCacheFields(this, identifier).get(attribute);
-        assertPrivateCapabilities(this._capabilities);
-        const defaultValue = getDefaultValue(attrSchema, identifier, this._capabilities._store);
-        if (schemaHasLegacyDefaultValueFn(attrSchema)) {
-          cached.defaultAttrs = cached.defaultAttrs || Object.create(null);
-          cached.defaultAttrs[attribute] = defaultValue;
-        }
-        return defaultValue;
-      }
-    }
-
-    // TODO @runspired consider whether we need a defaultValue cache in ReactiveResource
-    // like we do for the simple case above.
-    const path = attr;
-    const cached = this.__peek(identifier, true);
-    const basePath = path[0];
-    let current = cached.remoteAttrs && basePath in cached.remoteAttrs ? cached.remoteAttrs[basePath] : undefined;
-    if (current === undefined) {
-      return undefined;
-    }
-    for (let i = 1; i < path.length; i++) {
-      current = current[path[i]];
-      if (current === undefined) {
-        return undefined;
-      }
-    }
-    return current;
-  }
-
-  /**
-   * Mutate the data for an attribute in the cache
-   *
-   * This method is a candidate to become a mutation
-   *
-   * @category Resource Data
-   * @public
-   */
-  setAttr(identifier, attr, value) {
-    const isSimplePath = !Array.isArray(attr) || attr.length === 1;
-    if (Array.isArray(attr) && attr.length === 1) {
-      attr = attr[0];
-    }
-    if (isSimplePath) {
-      const cached = this.__peek(identifier, false);
-      const currentAttr = attr;
-      const existing = cached.inflightAttrs && currentAttr in cached.inflightAttrs ? cached.inflightAttrs[currentAttr] : cached.remoteAttrs && currentAttr in cached.remoteAttrs ? cached.remoteAttrs[currentAttr] : undefined;
-      if (existing !== value) {
-        cached.localAttrs = cached.localAttrs || Object.create(null);
-        cached.localAttrs[currentAttr] = value;
-        cached.changes = cached.changes || Object.create(null);
-        cached.changes[currentAttr] = [existing, value];
-      } else if (cached.localAttrs) {
-        delete cached.localAttrs[currentAttr];
-        delete cached.changes[currentAttr];
-      }
-      if (cached.defaultAttrs && currentAttr in cached.defaultAttrs) {
-        delete cached.defaultAttrs[currentAttr];
-      }
-      this._capabilities.notifyChange(identifier, 'attributes', currentAttr);
-      return;
-    }
-
-    // get current value from local else inflight else remote
-    // structuredClone current if not local (or always?)
-    // traverse path, update value at path
-    // notify change at first link in path.
-    // second pass optimization is change notifyChange signature to take an array path
-
-    // guaranteed that we have path of at least 2 in length
-    const path = attr;
-    const cached = this.__peek(identifier, false);
-
-    // get existing cache record for base path
-    const basePath = path[0];
-    const existing = cached.inflightAttrs && basePath in cached.inflightAttrs ? cached.inflightAttrs[basePath] : cached.remoteAttrs && basePath in cached.remoteAttrs ? cached.remoteAttrs[basePath] : undefined;
-    let existingAttr;
-    if (existing) {
-      existingAttr = existing[path[1]];
-      for (let i = 2; i < path.length; i++) {
-        // the specific change we're making is at path[length - 1]
-        existingAttr = existingAttr[path[i]];
-      }
-    }
-    if (existingAttr !== value) {
-      cached.localAttrs = cached.localAttrs || Object.create(null);
-      cached.localAttrs[basePath] = cached.localAttrs[basePath] || structuredClone(existing);
-      cached.changes = cached.changes || Object.create(null);
-      let currentLocal = cached.localAttrs[basePath];
-      let nextLink = 1;
-      while (nextLink < path.length - 1) {
-        currentLocal = currentLocal[path[nextLink++]];
-      }
-      currentLocal[path[nextLink]] = value;
-      cached.changes[basePath] = [existing, cached.localAttrs[basePath]];
-
-      // since we initiaize the value as basePath as a clone of the value at the remote basePath
-      // then in theory we can use JSON.stringify to compare the two values as key insertion order
-      // ought to be consistent.
-      // we try/catch this because users have a habit of doing "Bad Things"TM wherein the cache contains
-      // stateful values that are not JSON serializable correctly such as Dates.
-      // in the case that we error, we fallback to not removing the local value
-      // so that any changes we don't understand are preserved. Thse objects would then sometimes
-      // appear to be dirty unnecessarily, and for folks that open an issue we can guide them
-      // to make their cache data less stateful.
-    } else if (cached.localAttrs) {
-      try {
-        if (!existing) {
-          return;
-        }
-        const existingStr = JSON.stringify(existing);
-        const newStr = JSON.stringify(cached.localAttrs[basePath]);
-        if (existingStr !== newStr) {
-          delete cached.localAttrs[basePath];
-          delete cached.changes[basePath];
-        }
-      } catch {
-        // noop
-      }
-    }
-    this._capabilities.notifyChange(identifier, 'attributes', basePath);
-  }
-
-  /**
-   * Query the cache for the changed attributes of a resource.
-   *
-   * @category Resource Data
-   * @public
-   * @return `{ '<field>': ['<old>', '<new>'] }`
-   */
-  changedAttrs(identifier) {
-    const cached = this.__peek(identifier, false);
-
-    // in Prod we try to recover when accessing something that
-    // doesn't exist
-    if (!cached) {
-      return Object.create(null);
-    }
-
-    // TODO freeze in dev
-    return cached.changes || Object.create(null);
-  }
-
-  /**
-   * Query the cache for whether any mutated attributes exist
-   *
-   * @category Resource Data
-   * @public
-   */
-  hasChangedAttrs(identifier) {
-    const cached = this.__peek(identifier, true);
-
-    // in Prod we try to recover when accessing something that
-    // doesn't exist
-    if (!cached) {
-      return false;
-    }
-    return cached.inflightAttrs !== null && Object.keys(cached.inflightAttrs).length > 0 || cached.localAttrs !== null && Object.keys(cached.localAttrs).length > 0;
-  }
-
-  /**
-   * Tell the cache to discard any uncommitted mutations to attributes
-   *
-   * This method is a candidate to become a mutation
-   *
-   * @category Resource Data
-   * @public
-   * @return the names of fields that were restored
-   */
-  rollbackAttrs(identifier) {
-    const cached = this.__peek(identifier, false);
-    let dirtyKeys;
-    cached.isDeleted = false;
-    if (cached.localAttrs !== null) {
-      dirtyKeys = Object.keys(cached.localAttrs);
-      cached.localAttrs = null;
-      cached.changes = null;
-    }
-    if (cached.isNew) {
-      // > Note: Graph removal handled by unloadRecord
-      cached.isDeletionCommitted = true;
-      cached.isDeleted = true;
-      cached.isNew = false;
-    }
-    cached.inflightAttrs = null;
-    cached.defaultAttrs = null;
-    if (cached.errors) {
-      cached.errors = null;
-      this._capabilities.notifyChange(identifier, 'errors', null);
-    }
-    this._capabilities.notifyChange(identifier, 'state', null);
-    if (dirtyKeys && dirtyKeys.length) {
-      notifyAttributes(this._capabilities, identifier, new Set(dirtyKeys));
-    }
-    return dirtyKeys || [];
-  }
-
-  /**
-   * Query the cache for the changes to relationships of a resource.
-   *
-   * Returns a map of relationship names to RelationshipDiff objects.
-   *
-   * ```ts
-   * type RelationshipDiff =
-     | {
-        kind: 'collection';
-        remoteState: ResourceKey[];
-        additions: Set<ResourceKey>;
-        removals: Set<ResourceKey>;
-        localState: ResourceKey[];
-        reordered: boolean;
-       }
-     | {
-        kind: 'resource';
-        remoteState: ResourceKey | null;
-        localState: ResourceKey | null;
-      };
-      ```
-   *
-   * @category Resource Data
-   * @public
-   */
-  changedRelationships(identifier) {
-    return this.__graph.getChanged(identifier);
-  }
-
-  /**
-   * Query the cache for whether any mutated relationships exist
-   *
-   * @category Resource Data
-   * @public
-   */
-  hasChangedRelationships(identifier) {
-    return this.__graph.hasChanged(identifier);
-  }
-
-  /**
-   * Tell the cache to discard any uncommitted mutations to relationships.
-   *
-   * This will also discard the change on any appropriate inverses.
-   *
-   * This method is a candidate to become a mutation
-   *
-   * @category Resource Data
-   * @public
-   * @return the names of relationships that were restored
-   */
-  rollbackRelationships(identifier) {
-    assertPrivateCapabilities(this._capabilities);
-    let result;
-    this._capabilities._store._join(() => {
-      result = this.__graph.rollback(identifier);
-    });
-    return result;
-  }
-
-  /**
-   * Query the cache for the current state of a relationship property
-   *
-   * @category Resource Data
-   * @public
-   * @return resource relationship object
-   */
-  getRelationship(identifier, field) {
-    return this.__graph.getData(identifier, field);
-  }
-
-  /**
-   * Query the cache for the remote state of a relationship property
-   *
-   * @category Resource Data
-   * @public
-   * @return resource relationship object
-   */
-  getRemoteRelationship(identifier, field) {
-    return this.__graph.getRemoteData(identifier, field);
-  }
-
-  ////////// ============== //////////
-  ////////// Resource State //////////
-  ////////// ============== //////////
-
-  /**
-   * Update the cache state for the given resource to be marked
-   * as locally deleted, or remove such a mark.
-   *
-   * This method is a candidate to become a mutation
-   *
-   * @category Resource State
-   * @public
-   */
-  setIsDeleted(identifier, isDeleted) {
-    const cached = this.__peek(identifier, false);
-    cached.isDeleted = isDeleted;
-    // > Note: Graph removal for isNew handled by unloadRecord
-    this._capabilities.notifyChange(identifier, 'state', null);
-  }
-
-  /**
-   * Query the cache for any validation errors applicable to the given resource.
-   *
-   * @category Resource State
-   * @public
-   */
-  getErrors(identifier) {
-    return this.__peek(identifier, true).errors || [];
-  }
-
-  /**
-   * Query the cache for whether a given resource has any available data
-   *
-   * @category Resource State
-   * @public
-   */
-  isEmpty(identifier) {
-    const cached = this.__safePeek(identifier, true);
-    return cached ? cached.remoteAttrs === null && cached.inflightAttrs === null && cached.localAttrs === null : true;
-  }
-
-  /**
-   * Query the cache for whether a given resource was created locally and not
-   * yet persisted.
-   *
-   * @category Resource State
-   * @public
-   */
-  isNew(identifier) {
-    // TODO can we assert here?
-    return this.__safePeek(identifier, true)?.isNew || false;
-  }
-
-  /**
-   * Query the cache for whether a given resource is marked as deleted (but not
-   * necessarily persisted yet).
-   *
-   * @category Resource State
-   * @public
-   */
-  isDeleted(identifier) {
-    // TODO can we assert here?
-    return this.__safePeek(identifier, true)?.isDeleted || false;
-  }
-
-  /**
-   * Query the cache for whether a given resource has been deleted and that deletion
-   * has also been persisted.
-   *
-   * @category Resource State
-   * @public
-   */
-  isDeletionCommitted(identifier) {
-    // TODO can we assert here?
-    return this.__safePeek(identifier, true)?.isDeletionCommitted || false;
-  }
-
-  /**
-   * Private method used to populate an entry for the identifier
-   *
-   * @internal
-   */
-  _createCache(identifier) {
-    const cache = makeCache();
-    this.__cache.set(identifier, cache);
-    return cache;
-  }
-
-  /**
-   * Peek whether we have cached resource data matching the identifier
-   * without asserting if the resource data is missing.
-   *
-   * @internal
-   */
-  __safePeek(identifier, allowDestroyed) {
-    let resource = this.__cache.get(identifier);
-    if (!resource && allowDestroyed) {
-      resource = this.__destroyedCache.get(identifier);
-    }
-    return resource;
-  }
-
-  /**
-   * Peek whether we have cached resource data matching the identifier
-   * Asserts if the resource data is missing.
-   *
-   * @internal
-   */
-  __peek(identifier, allowDestroyed) {
-    const resource = this.__safePeek(identifier, allowDestroyed);
-    return resource;
-  }
-}
+* ```ts
+* import { JSONAPICache } from '@warp-drive/json-api';
+* ```
+*
+* A {@link Cache} implementation tuned for [{json:api}](https://jsonapi.org/)
+*
+* @categoryDescription Cache Management
+* APIs for primary cache management functionality
+* @categoryDescription Cache Forking
+* APIs that support Cache Forking
+* @categoryDescription SSR Support
+* APIs that support SSR functionality
+* @categoryDescription Resource Lifecycle
+* APIs that support management of resource data
+* @categoryDescription Resource Data
+* APIs that support granular field level management of resource data
+* @categoryDescription Resource State
+* APIs that support managing Resource states
+*
+* @public
+*/
+var JSONAPICache = class {
+	/**
+	* The Cache Version that this implementation implements.
+	*
+	* @public
+	*/
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	constructor(capabilities) {
+		this.version = "2";
+		this._capabilities = capabilities;
+		this.__cache = /* @__PURE__ */ new Map();
+		this.__graph = graphFor(capabilities);
+		this.__destroyedCache = /* @__PURE__ */ new Map();
+		this.__documents = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Cache the response to a request
+	*
+	* Implements `Cache.put`.
+	*
+	* Expects a StructuredDocument whose `content` member is a JsonApiDocument.
+	*
+	* ```js
+	* cache.put({
+	*   request: { url: 'https://api.example.com/v1/user/1' },
+	*   content: {
+	*     data: {
+	*       type: 'user',
+	*       id: '1',
+	*       attributes: {
+	*         name: 'Chris'
+	*       }
+	*     }
+	*   }
+	* })
+	* ```
+	*
+	* > **Note**
+	* > The nested `content` and `data` members are not a mistake. This is because
+	* > there are two separate concepts involved here, the `StructuredDocument` which contains
+	* > the context of a given Request that has been issued with the returned contents as its
+	* > `content` property, and a `JSON:API Document` which is the json contents returned by
+	* > this endpoint and which uses its `data` property to signify which resources are the
+	* > primary resources associated with the request.
+	*
+	* StructuredDocument's with urls will be cached as full documents with
+	* associated resource membership order and contents preserved but linked
+	* into the cache.
+	*
+	* @category Cache Management
+	* @public
+	*/
+	put(doc) {
+		if (isErrorDocument(doc)) return this._putDocument(doc, void 0, void 0);
+		else if (isMetaDocument(doc)) return this._putDocument(doc, void 0, void 0);
+		const jsonApiDoc = doc.content;
+		const included = jsonApiDoc.included;
+		let i, length;
+		const { cacheKeyManager } = this._capabilities;
+		if (included) for (i = 0, length = included.length; i < length; i++) included[i] = putOne(this, cacheKeyManager, included[i]);
+		if (Array.isArray(jsonApiDoc.data)) {
+			length = jsonApiDoc.data.length;
+			const identifiers = [];
+			for (i = 0; i < length; i++) identifiers.push(putOne(this, cacheKeyManager, jsonApiDoc.data[i]));
+			return this._putDocument(doc, identifiers, included);
+		}
+		if (jsonApiDoc.data === null) return this._putDocument(doc, null, included);
+		const identifier = putOne(this, cacheKeyManager, jsonApiDoc.data);
+		return this._putDocument(doc, identifier, included);
+	}
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	_putDocument(doc, data, included) {
+		const resourceDocument = isErrorDocument(doc) ? fromStructuredError(doc) : fromBaseDocument(doc);
+		if (data !== void 0) resourceDocument.data = data;
+		if (included !== void 0) resourceDocument.included = included;
+		const request = doc.request;
+		const identifier = request ? this._capabilities.cacheKeyManager.getOrCreateDocumentIdentifier(request) : null;
+		if (identifier) {
+			resourceDocument.lid = identifier.lid;
+			doc.content = resourceDocument;
+			const hasExisting = this.__documents.has(identifier.lid);
+			this.__documents.set(identifier.lid, doc);
+			this._capabilities.notifyChange(identifier, hasExisting ? "updated" : "added", null);
+		}
+		if (doc.request?.op === "findHasMany") {
+			const parentIdentifier = doc.request.options?.identifier;
+			const parentField = doc.request.options?.field;
+			if (parentField && parentIdentifier) this.__graph.push({
+				op: "updateRelationship",
+				record: parentIdentifier,
+				field: parentField.name,
+				value: resourceDocument
+			});
+		}
+		return resourceDocument;
+	}
+	/**
+	* Update the "remote" or "canonical" (persisted) state of the Cache
+	* by merging new information into the existing state.
+	*
+	* @category Cache Management
+	* @public
+	* @param op the operation or list of operations to perform
+	*/
+	patch(op) {
+		if (Array.isArray(op)) {
+			assertPrivateCapabilities(this._capabilities);
+			this._capabilities._store._join(() => {
+				for (const operation of op) patchCache(this, operation);
+			});
+		} else patchCache(this, op);
+	}
+	/**
+	* Update the "local" or "current" (unpersisted) state of the Cache
+	*
+	* @category Cache Management
+	* @public
+	*/
+	mutate(mutation) {
+		this.__graph.update(mutation, false);
+	}
+	/**
+	* Peek resource data from the Cache.
+	*
+	* In development, if the return value
+	* is JSON the return value
+	* will be deep-cloned and deep-frozen
+	* to prevent mutation thereby enforcing cache
+	* Immutability.
+	*
+	* This form of peek is useful for implementations
+	* that want to feed raw-data from cache to the UI
+	* or which want to interact with a blob of data
+	* directly from the presentation cache.
+	*
+	* An implementation might want to do this because
+	* de-referencing records which read from their own
+	* blob is generally safer because the record does
+	* not require retainining connections to the Store
+	* and Cache to present data on a per-field basis.
+	*
+	* This generally takes the place of `getAttr` as
+	* an API and may even take the place of `getRelationship`
+	* depending on implementation specifics, though this
+	* latter usage is less recommended due to the advantages
+	* of the Graph handling necessary entanglements and
+	* notifications for relational data.
+	*
+	* :::warning
+	* It is not recommended to use the return value as
+	* a serialized representation of the resource both
+	* due to it containing local mutations and because
+	* it may contain additional fields not recognized
+	* by the {json:api} API implementation such as `lid` and
+	* the various internal WarpDrive bookkeeping fields.
+	* :::
+	*
+	* @category Cache Management
+	* @public
+	*/
+	peek(identifier) {
+		if (isResourceKey(identifier)) {
+			const peeked = this.__safePeek(identifier, false);
+			if (!peeked) return null;
+			const { type, id, lid } = identifier;
+			const attributes = structuredClone(Object.assign({}, peeked.remoteAttrs, peeked.inflightAttrs, peeked.localAttrs));
+			const relationships = {};
+			const rels = this.__graph.identifiers.get(identifier);
+			if (rels) Object.keys(rels).forEach((key) => {
+				if (rels[key].definition.isImplicit) return;
+				else relationships[key] = this.__graph.getData(identifier, key);
+			});
+			assertPrivateCapabilities(this._capabilities);
+			const store = this._capabilities._store;
+			getCacheFields(this, identifier).forEach((attr, key) => {
+				if (key in attributes && attributes[key] !== void 0) return;
+				const defaultValue = getDefaultValue(attr, identifier, store);
+				if (defaultValue !== void 0) attributes[key] = defaultValue;
+			});
+			return {
+				type,
+				id,
+				lid,
+				attributes,
+				relationships
+			};
+		}
+		const document = this.peekRequest(identifier);
+		if (document) {
+			if ("content" in document) return document.content;
+		}
+		return null;
+	}
+	/**
+	* Peek the remote resource data from the Cache.
+	*
+	* @category Cache Management
+	* @public
+	*/
+	peekRemoteState(identifier) {
+		if (isResourceKey(identifier)) {
+			const peeked = this.__safePeek(identifier, false);
+			if (!peeked) return null;
+			const { type, id, lid } = identifier;
+			const attributes = structuredClone(peeked.remoteAttrs);
+			const relationships = {};
+			const rels = this.__graph.identifiers.get(identifier);
+			if (rels) Object.keys(rels).forEach((key) => {
+				if (rels[key].definition.isImplicit) return;
+				else relationships[key] = structuredClone(this.__graph.getData(identifier, key));
+			});
+			assertPrivateCapabilities(this._capabilities);
+			const store = this._capabilities._store;
+			getCacheFields(this, identifier).forEach((attr, key) => {
+				if (key in attributes && attributes[key] !== void 0) return;
+				const defaultValue = getDefaultValue(attr, identifier, store);
+				if (defaultValue !== void 0) attributes[key] = defaultValue;
+			});
+			return {
+				type,
+				id,
+				lid,
+				attributes,
+				relationships
+			};
+		}
+		const document = this.peekRequest(identifier);
+		if (document) {
+			if ("content" in document) return document.content;
+		}
+		return null;
+	}
+	/**
+	* Peek the Cache for the existing request data associated with
+	* a cacheable request.
+	*
+	* This is effectively the reverse of `put` for a request in
+	* that it will return the the request, response, and content
+	* whereas `peek` will return just the `content`.
+	*
+	* @category Cache Management
+	* @public
+	*/
+	peekRequest(identifier) {
+		return this.__documents.get(identifier.lid) || null;
+	}
+	/**
+	* Push resource data from a remote source into the cache for this identifier
+	*
+	* @category Cache Management
+	* @public
+	* @return if `calculateChanges` is true then calculated key changes should be returned
+	*/
+	upsert(identifier, data, calculateChanges) {
+		assertPrivateCapabilities(this._capabilities);
+		const store = this._capabilities._store;
+		if (!store._cbs) {
+			let result = void 0;
+			store._run(() => {
+				result = cacheUpsert(this, identifier, data, calculateChanges);
+			});
+			return result;
+		}
+		return cacheUpsert(this, identifier, data, calculateChanges);
+	}
+	/**
+	* Create a fork of the cache from the current state.
+	*
+	* Applications should typically not call this method themselves,
+	* preferring instead to fork at the Store level, which will
+	* utilize this method to fork the cache.
+	*
+	* @category Cache Forking
+	* @private
+	*/
+	fork() {
+		throw new Error(`Not Implemented`);
+	}
+	/**
+	* Merge a fork back into a parent Cache.
+	*
+	* Applications should typically not call this method themselves,
+	* preferring instead to merge at the Store level, which will
+	* utilize this method to merge the caches.
+	*
+	* @category Cache Forking
+	* @private
+	*/
+	merge(_cache) {
+		throw new Error(`Not Implemented`);
+	}
+	/**
+	* Generate the list of changes applied to all
+	* record in the store.
+	*
+	* Each individual resource or document that has
+	* been mutated should be described as an individual
+	* `Change` entry in the returned array.
+	*
+	* A `Change` is described by an object containing up to
+	* three properties: (1) the `identifier` of the entity that
+	* changed; (2) the `op` code of that change being one of
+	* `upsert` or `remove`, and if the op is `upsert` a `patch`
+	* containing the data to merge into the cache for the given
+	* entity.
+	*
+	* This `patch` is opaque to the Store but should be understood
+	* by the Cache and may expect to be utilized by an Adapter
+	* when generating data during a `save` operation.
+	*
+	* It is generally recommended that the `patch` contain only
+	* the updated state, ignoring fields that are unchanged
+	*
+	* ```ts
+	* interface Change {
+	*  identifier: ResourceKey | RequestKey;
+	*  op: 'upsert' | 'remove';
+	*  patch?: unknown;
+	* }
+	* ```
+	*
+	* @category Cache Forking
+	* @private
+	*/
+	diff() {
+		throw new Error(`Not Implemented`);
+	}
+	/**
+	* Serialize the entire contents of the Cache into a Stream
+	* which may be fed back into a new instance of the same Cache
+	* via `cache.hydrate`.
+	*
+	* @category SSR Support
+	* @private
+	*/
+	dump() {
+		throw new Error(`Not Implemented`);
+	}
+	/**
+	* hydrate a Cache from a Stream with content previously serialized
+	* from another instance of the same Cache, resolving when hydration
+	* is complete.
+	*
+	* This method should expect to be called both in the context of restoring
+	* the Cache during application rehydration after SSR **AND** at unknown
+	* times during the lifetime of an already booted application when it is
+	* desired to bulk-load additional information into the cache. This latter
+	* behavior supports optimizing pre/fetching of data for route transitions
+	* via data-only SSR modes.
+	*
+	* @category SSR Support
+	* @private
+	*/
+	hydrate(stream) {
+		throw new Error("Not Implemented");
+	}
+	/**
+	* [LIFECYCLE] Signal to the cache that a new record has been instantiated on the client
+	*
+	* It returns properties from options that should be set on the record during the create
+	* process. This return value behavior is deprecated.
+	*
+	* @category Resource Lifecycle
+	* @public
+	*/
+	clientDidCreate(identifier, options) {
+		const cached = this._createCache(identifier);
+		cached.isNew = true;
+		const createOptions = {};
+		if (options !== void 0) {
+			const fields = getCacheFields(this, identifier);
+			const graph = this.__graph;
+			const propertyNames = Object.keys(options);
+			for (let i = 0; i < propertyNames.length; i++) {
+				const name = propertyNames[i];
+				const propertyValue = options[name];
+				if (name === "id") continue;
+				const fieldType = fields.get(name);
+				const kind = fieldType !== void 0 ? "kind" in fieldType ? fieldType.kind : "attribute" : null;
+				let relationship;
+				switch (kind) {
+					case "attribute":
+						this.setAttr(identifier, name, propertyValue);
+						createOptions[name] = propertyValue;
+						break;
+					case "belongsTo":
+						this.mutate({
+							op: "replaceRelatedRecord",
+							field: name,
+							record: identifier,
+							value: propertyValue
+						});
+						relationship = graph.get(identifier, name);
+						relationship.state.hasReceivedData = true;
+						relationship.state.isEmpty = false;
+						break;
+					case "hasMany":
+						this.mutate({
+							op: "replaceRelatedRecords",
+							field: name,
+							record: identifier,
+							value: propertyValue
+						});
+						relationship = graph.get(identifier, name);
+						relationship.state.hasReceivedData = true;
+						relationship.state.isEmpty = false;
+						break;
+					default: createOptions[name] = propertyValue;
+				}
+			}
+		}
+		this._capabilities.notifyChange(identifier, "added", null);
+		return createOptions;
+	}
+	/**
+	* [LIFECYCLE] Signals to the cache that a resource
+	* will be part of a save transaction.
+	*
+	* @category Resource Lifecycle
+	* @public
+	*/
+	willCommit(identifier, _context) {
+		if (Array.isArray(identifier)) for (const key of identifier) willCommit(this, key);
+		else willCommit(this, identifier);
+	}
+	/**
+	* [LIFECYCLE] Signals to the cache that a resource
+	* was successfully updated as part of a save transaction.
+	*
+	* @category Resource Lifecycle
+	* @public
+	*/
+	didCommit(committedIdentifier, result) {
+		const payload = result ? result.content : null;
+		const operation = result?.request?.op ?? null;
+		const data = payload && payload.data;
+		const responseIsCollection = Array.isArray(data);
+		const hasMultipleIdentifiers = Array.isArray(committedIdentifier) && committedIdentifier.length > 1;
+		if (Array.isArray(committedIdentifier)) {
+			if (responseIsCollection) for (let i = 0; i < committedIdentifier.length; i++) {
+				const identifier = committedIdentifier[i];
+				didCommit(this, identifier, data[i] ?? null, operation);
+			}
+			else for (let i = 0; i < committedIdentifier.length; i++) {
+				const identifier = committedIdentifier[i];
+				didCommit(this, identifier, i === 0 ? data : null, operation);
+			}
+		} else didCommit(this, committedIdentifier, data, operation);
+		const included = payload && payload.included;
+		const { cacheKeyManager } = this._capabilities;
+		if (included) for (let i = 0, length = included.length; i < length; i++) putOne(this, cacheKeyManager, included[i]);
+		return hasMultipleIdentifiers && responseIsCollection ? { data: committedIdentifier } : { data: Array.isArray(committedIdentifier) ? committedIdentifier[0] : committedIdentifier };
+	}
+	/**
+	* [LIFECYCLE] Signals to the cache that a resource
+	* was update via a save transaction failed.
+	*
+	* @category Resource Lifecycle
+	* @public
+	*/
+	commitWasRejected(identifier, errors) {
+		if (Array.isArray(identifier)) {
+			for (let i = 0; i < identifier.length; i++) commitDidError(this, identifier[i], errors && i === 0 ? errors : null);
+			return;
+		}
+		return commitDidError(this, identifier, errors || null);
+	}
+	/**
+	* [LIFECYCLE] Signals to the cache that all data for a resource
+	* should be cleared.
+	*
+	* This method is a candidate to become a mutation
+	*
+	* @category Resource Lifecycle
+	* @public
+	*/
+	unloadRecord(identifier) {
+		const storeWrapper = this._capabilities;
+		if (!this.__cache.has(identifier)) {
+			peekGraph(storeWrapper)?.unload(identifier);
+			return;
+		}
+		const removeFromRecordArray = !this.isDeletionCommitted(identifier);
+		let removed = false;
+		const cached = this.__peek(identifier, false);
+		if (cached.isNew || cached.isDeletionCommitted) peekGraph(storeWrapper)?.push({
+			op: "deleteRecord",
+			record: identifier,
+			isNew: cached.isNew
+		});
+		else peekGraph(storeWrapper)?.unload(identifier);
+		cached.localAttrs = null;
+		cached.remoteAttrs = null;
+		cached.defaultAttrs = null;
+		cached.inflightAttrs = null;
+		const relatedIdentifiers = _allRelatedIdentifiers(storeWrapper, identifier);
+		if (areAllModelsUnloaded(storeWrapper, relatedIdentifiers)) for (let i = 0; i < relatedIdentifiers.length; ++i) {
+			const relatedIdentifier = relatedIdentifiers[i];
+			storeWrapper.notifyChange(relatedIdentifier, "removed", null);
+			removed = true;
+			storeWrapper.disconnectRecord(relatedIdentifier);
+		}
+		this.__cache.delete(identifier);
+		this.__destroyedCache.set(identifier, cached);
+		if (this.__destroyedCache.size === 1) setTimeout(() => {
+			this.__destroyedCache.clear();
+		}, 100);
+		if (!removed && removeFromRecordArray) storeWrapper.notifyChange(identifier, "removed", null);
+	}
+	/**
+	* Retrieve the data for an attribute from the cache
+	* with local mutations applied.
+	*
+	* @category Resource Data
+	* @public
+	*/
+	getAttr(identifier, attr) {
+		const isSimplePath = !Array.isArray(attr) || attr.length === 1;
+		if (Array.isArray(attr) && attr.length === 1) attr = attr[0];
+		if (isSimplePath) {
+			const attribute = attr;
+			const cached = this.__peek(identifier, true);
+			if (!cached) return;
+			if (cached.localAttrs && attribute in cached.localAttrs) return cached.localAttrs[attribute];
+			else if (cached.inflightAttrs && attribute in cached.inflightAttrs) return cached.inflightAttrs[attribute];
+			else if (cached.remoteAttrs && attribute in cached.remoteAttrs) return cached.remoteAttrs[attribute];
+			else if (cached.defaultAttrs && attribute in cached.defaultAttrs) return cached.defaultAttrs[attribute];
+			else {
+				const attrSchema = getCacheFields(this, identifier).get(attribute);
+				assertPrivateCapabilities(this._capabilities);
+				const defaultValue = getDefaultValue(attrSchema, identifier, this._capabilities._store);
+				if (schemaHasLegacyDefaultValueFn(attrSchema)) {
+					cached.defaultAttrs = cached.defaultAttrs || Object.create(null);
+					cached.defaultAttrs[attribute] = defaultValue;
+				}
+				return defaultValue;
+			}
+		}
+		const path = attr;
+		const cached = this.__peek(identifier, true);
+		const basePath = path[0];
+		let current = cached.localAttrs && basePath in cached.localAttrs ? cached.localAttrs[basePath] : void 0;
+		if (current === void 0) current = cached.inflightAttrs && basePath in cached.inflightAttrs ? cached.inflightAttrs[basePath] : void 0;
+		if (current === void 0) current = cached.remoteAttrs && basePath in cached.remoteAttrs ? cached.remoteAttrs[basePath] : void 0;
+		if (current === void 0) return;
+		for (let i = 1; i < path.length; i++) {
+			current = current[path[i]];
+			if (current === void 0) return;
+		}
+		return current;
+	}
+	/**
+	* Retrieve the remote data for an attribute from the cache
+	*
+	* @category Resource Data
+	* @public
+	*/
+	getRemoteAttr(identifier, attr) {
+		const isSimplePath = !Array.isArray(attr) || attr.length === 1;
+		if (Array.isArray(attr) && attr.length === 1) attr = attr[0];
+		if (isSimplePath) {
+			const attribute = attr;
+			const cached = this.__peek(identifier, true);
+			if (!cached) return;
+			if (cached.remoteAttrs && attribute in cached.remoteAttrs) return cached.remoteAttrs[attribute];
+			else if (cached.defaultAttrs && attribute in cached.defaultAttrs) return cached.defaultAttrs[attribute];
+			else {
+				const attrSchema = getCacheFields(this, identifier).get(attribute);
+				assertPrivateCapabilities(this._capabilities);
+				const defaultValue = getDefaultValue(attrSchema, identifier, this._capabilities._store);
+				if (schemaHasLegacyDefaultValueFn(attrSchema)) {
+					cached.defaultAttrs = cached.defaultAttrs || Object.create(null);
+					cached.defaultAttrs[attribute] = defaultValue;
+				}
+				return defaultValue;
+			}
+		}
+		const path = attr;
+		const cached = this.__peek(identifier, true);
+		const basePath = path[0];
+		let current = cached.remoteAttrs && basePath in cached.remoteAttrs ? cached.remoteAttrs[basePath] : void 0;
+		if (current === void 0) return;
+		for (let i = 1; i < path.length; i++) {
+			current = current[path[i]];
+			if (current === void 0) return;
+		}
+		return current;
+	}
+	/**
+	* Mutate the data for an attribute in the cache
+	*
+	* This method is a candidate to become a mutation
+	*
+	* @category Resource Data
+	* @public
+	*/
+	setAttr(identifier, attr, value) {
+		const isSimplePath = !Array.isArray(attr) || attr.length === 1;
+		if (Array.isArray(attr) && attr.length === 1) attr = attr[0];
+		if (isSimplePath) {
+			const cached = this.__peek(identifier, false);
+			const currentAttr = attr;
+			const existing = cached.inflightAttrs && currentAttr in cached.inflightAttrs ? cached.inflightAttrs[currentAttr] : cached.remoteAttrs && currentAttr in cached.remoteAttrs ? cached.remoteAttrs[currentAttr] : void 0;
+			if (existing !== value) {
+				cached.localAttrs = cached.localAttrs || Object.create(null);
+				cached.localAttrs[currentAttr] = value;
+				cached.changes = cached.changes || Object.create(null);
+				cached.changes[currentAttr] = [existing, value];
+			} else if (cached.localAttrs) {
+				delete cached.localAttrs[currentAttr];
+				delete cached.changes[currentAttr];
+			}
+			if (cached.defaultAttrs && currentAttr in cached.defaultAttrs) delete cached.defaultAttrs[currentAttr];
+			this._capabilities.notifyChange(identifier, "attributes", currentAttr, "local");
+			return;
+		}
+		const path = attr;
+		const cached = this.__peek(identifier, false);
+		const basePath = path[0];
+		const existing = cached.inflightAttrs && basePath in cached.inflightAttrs ? cached.inflightAttrs[basePath] : cached.remoteAttrs && basePath in cached.remoteAttrs ? cached.remoteAttrs[basePath] : void 0;
+		let existingAttr;
+		if (existing) {
+			existingAttr = existing[path[1]];
+			for (let i = 2; i < path.length; i++) existingAttr = existingAttr[path[i]];
+		}
+		if (existingAttr !== value) {
+			cached.localAttrs = cached.localAttrs || Object.create(null);
+			cached.localAttrs[basePath] = cached.localAttrs[basePath] || structuredClone(existing);
+			cached.changes = cached.changes || Object.create(null);
+			let currentLocal = cached.localAttrs[basePath];
+			let nextLink = 1;
+			while (nextLink < path.length - 1) currentLocal = currentLocal[path[nextLink++]];
+			currentLocal[path[nextLink]] = value;
+			cached.changes[basePath] = [existing, cached.localAttrs[basePath]];
+		} else if (cached.localAttrs) try {
+			if (!existing) return;
+			if (JSON.stringify(existing) !== JSON.stringify(cached.localAttrs[basePath])) {
+				delete cached.localAttrs[basePath];
+				delete cached.changes[basePath];
+			}
+		} catch {}
+		this._capabilities.notifyChange(identifier, "attributes", basePath, "local");
+	}
+	/**
+	* Query the cache for the changed attributes of a resource.
+	*
+	* @category Resource Data
+	* @public
+	* @return `{ '<field>': ['<old>', '<new>'] }`
+	*/
+	changedAttrs(identifier) {
+		const cached = this.__peek(identifier, false);
+		if (!cached) return Object.create(null);
+		return cached.changes || Object.create(null);
+	}
+	/**
+	* Query the cache for whether any mutated attributes exist
+	*
+	* @category Resource Data
+	* @public
+	*/
+	hasChangedAttrs(identifier) {
+		const cached = this.__peek(identifier, true);
+		if (!cached) return false;
+		return cached.inflightAttrs !== null && Object.keys(cached.inflightAttrs).length > 0 || cached.localAttrs !== null && Object.keys(cached.localAttrs).length > 0;
+	}
+	/**
+	* Tell the cache to discard any uncommitted mutations to attributes
+	*
+	* This method is a candidate to become a mutation
+	*
+	* @category Resource Data
+	* @public
+	* @return the names of fields that were restored
+	*/
+	rollbackAttrs(identifier) {
+		const cached = this.__peek(identifier, false);
+		let dirtyKeys;
+		cached.isDeleted = false;
+		if (cached.localAttrs !== null) {
+			dirtyKeys = Object.keys(cached.localAttrs);
+			cached.localAttrs = null;
+			cached.changes = null;
+		}
+		if (cached.isNew) {
+			cached.isDeletionCommitted = true;
+			cached.isDeleted = true;
+			cached.isNew = false;
+		}
+		cached.inflightAttrs = null;
+		cached.defaultAttrs = null;
+		if (cached.errors) {
+			cached.errors = null;
+			this._capabilities.notifyChange(identifier, "errors", null);
+		}
+		this._capabilities.notifyChange(identifier, "state", null);
+		if (dirtyKeys && dirtyKeys.length) this._capabilities.notifyChange(identifier, "attributes", new Set(dirtyKeys));
+		return dirtyKeys || [];
+	}
+	/**
+	* Query the cache for the changes to relationships of a resource.
+	*
+	* Returns a map of relationship names to RelationshipDiff objects.
+	*
+	* ```ts
+	* type RelationshipDiff =
+	| {
+	kind: 'collection';
+	remoteState: ResourceKey[];
+	additions: Set<ResourceKey>;
+	removals: Set<ResourceKey>;
+	localState: ResourceKey[];
+	reordered: boolean;
+	}
+	| {
+	kind: 'resource';
+	remoteState: ResourceKey | null;
+	localState: ResourceKey | null;
+	};
+	```
+	*
+	* @category Resource Data
+	* @public
+	*/
+	changedRelationships(identifier) {
+		return this.__graph.getChanged(identifier);
+	}
+	/**
+	* Query the cache for whether any mutated relationships exist
+	*
+	* @category Resource Data
+	* @public
+	*/
+	hasChangedRelationships(identifier) {
+		return this.__graph.hasChanged(identifier);
+	}
+	/**
+	* Tell the cache to discard any uncommitted mutations to relationships.
+	*
+	* This will also discard the change on any appropriate inverses.
+	*
+	* This method is a candidate to become a mutation
+	*
+	* @category Resource Data
+	* @public
+	* @return the names of relationships that were restored
+	*/
+	rollbackRelationships(identifier) {
+		assertPrivateCapabilities(this._capabilities);
+		let result;
+		this._capabilities._store._join(() => {
+			result = this.__graph.rollback(identifier);
+		});
+		return result;
+	}
+	/**
+	* Query the cache for the current state of a relationship property
+	*
+	* @category Resource Data
+	* @public
+	* @return resource relationship object
+	*/
+	getRelationship(identifier, field) {
+		return this.__graph.getData(identifier, field);
+	}
+	/**
+	* Query the cache for the remote state of a relationship property
+	*
+	* @category Resource Data
+	* @public
+	* @return resource relationship object
+	*/
+	getRemoteRelationship(identifier, field) {
+		return this.__graph.getRemoteData(identifier, field);
+	}
+	/**
+	* Update the cache state for the given resource to be marked
+	* as locally deleted, or remove such a mark.
+	*
+	* This method is a candidate to become a mutation
+	*
+	* @category Resource State
+	* @public
+	*/
+	setIsDeleted(identifier, isDeleted) {
+		const cached = this.__peek(identifier, false);
+		cached.isDeleted = isDeleted;
+		this._capabilities.notifyChange(identifier, "state", null);
+	}
+	/**
+	* Query the cache for any validation errors applicable to the given resource.
+	*
+	* @category Resource State
+	* @public
+	*/
+	getErrors(identifier) {
+		return this.__peek(identifier, true).errors || [];
+	}
+	/**
+	* Query the cache for whether a given resource has any available data
+	*
+	* @category Resource State
+	* @public
+	*/
+	isEmpty(identifier) {
+		const cached = this.__safePeek(identifier, true);
+		return cached ? cached.remoteAttrs === null && cached.inflightAttrs === null && cached.localAttrs === null : true;
+	}
+	/**
+	* Query the cache for whether a given resource was created locally and not
+	* yet persisted.
+	*
+	* @category Resource State
+	* @public
+	*/
+	isNew(identifier) {
+		return this.__safePeek(identifier, true)?.isNew || false;
+	}
+	/**
+	* Query the cache for whether a given resource is marked as deleted (but not
+	* necessarily persisted yet).
+	*
+	* @category Resource State
+	* @public
+	*/
+	isDeleted(identifier) {
+		return this.__safePeek(identifier, true)?.isDeleted || false;
+	}
+	/**
+	* Query the cache for whether a given resource has been deleted and that deletion
+	* has also been persisted.
+	*
+	* @category Resource State
+	* @public
+	*/
+	isDeletionCommitted(identifier) {
+		return this.__safePeek(identifier, true)?.isDeletionCommitted || false;
+	}
+	/**
+	* Private method used to populate an entry for the identifier
+	*
+	* @internal
+	*/
+	_createCache(identifier) {
+		const cache = makeCache();
+		this.__cache.set(identifier, cache);
+		return cache;
+	}
+	/**
+	* Peek whether we have cached resource data matching the identifier
+	* without asserting if the resource data is missing.
+	*
+	* @internal
+	*/
+	__safePeek(identifier, allowDestroyed) {
+		let resource = this.__cache.get(identifier);
+		if (!resource && allowDestroyed) resource = this.__destroyedCache.get(identifier);
+		return resource;
+	}
+	/**
+	* Peek whether we have cached resource data matching the identifier
+	* Asserts if the resource data is missing.
+	*
+	* @internal
+	*/
+	__peek(identifier, allowDestroyed) {
+		return this.__safePeek(identifier, allowDestroyed);
+	}
+};
 function addResourceToDocument(cache, op) {
-  const doc = cache.__documents.get(op.record.lid);
-  const {
-    content
-  } = doc;
-  if (op.field === 'data') {
-    let shouldNotify = false;
-
-    // if data is not an array, we set the data property directly
-    if (!Array.isArray(content.data)) {
-      shouldNotify = content.data !== op.value;
-      if (shouldNotify) content.data = op.value;
-    } else {
-      if (Array.isArray(op.value)) {
-        if (op.index !== undefined) {
-          // for collections, because we allow duplicates we are always changed.
-          shouldNotify = true;
-          content.data.splice(op.index, 0, ...op.value);
-        } else {
-          // for collections, because we allow duplicates we are always changed.
-          shouldNotify = true;
-          content.data.push(...op.value);
-        }
-      } else {
-        if (op.index !== undefined) {
-          // for collections, because we allow duplicates we are always changed.
-          shouldNotify = true;
-          content.data.splice(op.index, 0, op.value);
-        } else {
-          // for collections, because we allow duplicates we are always changed.
-          shouldNotify = true;
-          content.data.push(op.value);
-        }
-      }
-    }
-
-    // notify
-    if (shouldNotify) cache._capabilities.notifyChange(op.record, 'updated', null);
-    return;
-  }
-  content.included = content.included || [];
-  if (Array.isArray(op.value)) {
-    content.included = content.included.concat(op.value);
-  } else {
-    content.included.push(op.value);
-  }
-
-  // we don't notify in the included case because this is not reactively
-  // exposed. We should possibly consider doing so though for subscribers
+	const { content } = cache.__documents.get(op.record.lid);
+	if (op.field === "data") {
+		let shouldNotify;
+		if (!Array.isArray(content.data)) {
+			shouldNotify = content.data !== op.value;
+			if (shouldNotify) content.data = op.value;
+		} else if (Array.isArray(op.value)) {
+			if (op.index !== void 0) {
+				shouldNotify = true;
+				content.data.splice(op.index, 0, ...op.value);
+			} else {
+				shouldNotify = true;
+				content.data.push(...op.value);
+			}
+		} else if (op.index !== void 0) {
+			shouldNotify = true;
+			content.data.splice(op.index, 0, op.value);
+		} else {
+			shouldNotify = true;
+			content.data.push(op.value);
+		}
+		if (shouldNotify) cache._capabilities.notifyChange(op.record, "updated", null);
+		return;
+	}
+	content.included = content.included || [];
+	if (Array.isArray(op.value)) content.included = content.included.concat(op.value);
+	else content.included.push(op.value);
 }
 function removeResourceFromDocument(cache, op) {
-  const doc = cache.__documents.get(op.record.lid);
-  const {
-    content
-  } = doc;
-  if (op.field === 'data') {
-    let shouldNotify = false;
-
-    // if data is not an array, we set the data property directly
-    if (!Array.isArray(content.data)) {
-      shouldNotify = content.data === op.value;
-      // we only remove the value if it was our existing value
-      if (shouldNotify) content.data = null;
-    } else {
-      const toRemove = Array.isArray(op.value) ? op.value : [op.value];
-      for (let i = 0; i < toRemove.length; i++) {
-        const value = toRemove[i];
-        if (op.index !== undefined) {
-          // in production we want to recover gracefully
-          // so we fallback to first-index-of
-          const index = op.index < content.data.length && content.data[op.index] === value ? op.index : content.data.indexOf(value);
-          if (index !== -1) {
-            // we remove the first occurrence of the value
-            shouldNotify = true;
-            content.data.splice(index, 1);
-          }
-        } else {
-          // we remove the first occurrence of the value
-          const index = content.data.indexOf(value);
-          if (index !== -1) {
-            shouldNotify = true;
-            content.data.splice(index, 1);
-          }
-        }
-      }
-    }
-
-    // notify
-    if (shouldNotify) cache._capabilities.notifyChange(op.record, 'updated', null);
-  } else {
-    content.included = content.included || [];
-    const toRemove = Array.isArray(op.value) ? op.value : [op.value];
-    for (const identifier of toRemove) {
-      const index = content.included.indexOf(identifier);
-      if (index !== -1) {
-        content.included.splice(index, 1);
-      }
-    }
-
-    // we don't notify in the included case because this is not reactively
-    // exposed. We should possibly consider doing so though for subscribers
-  }
+	const { content } = cache.__documents.get(op.record.lid);
+	if (op.field === "data") {
+		let shouldNotify = false;
+		if (!Array.isArray(content.data)) {
+			shouldNotify = content.data === op.value;
+			if (shouldNotify) content.data = null;
+		} else {
+			const toRemove = Array.isArray(op.value) ? op.value : [op.value];
+			for (let i = 0; i < toRemove.length; i++) {
+				const value = toRemove[i];
+				if (op.index !== void 0) {
+					const index = op.index < content.data.length && content.data[op.index] === value ? op.index : content.data.indexOf(value);
+					if (index !== -1) {
+						shouldNotify = true;
+						content.data.splice(index, 1);
+					}
+				} else {
+					const index = content.data.indexOf(value);
+					if (index !== -1) {
+						shouldNotify = true;
+						content.data.splice(index, 1);
+					}
+				}
+			}
+		}
+		if (shouldNotify) cache._capabilities.notifyChange(op.record, "updated", null);
+	} else {
+		content.included = content.included || [];
+		const toRemove = Array.isArray(op.value) ? op.value : [op.value];
+		for (const identifier of toRemove) {
+			const index = content.included.indexOf(identifier);
+			if (index !== -1) content.included.splice(index, 1);
+		}
+	}
 }
 function areAllModelsUnloaded(wrapper, identifiers) {
-  for (let i = 0; i < identifiers.length; ++i) {
-    const identifier = identifiers[i];
-    if (wrapper.hasRecord(identifier)) {
-      return false;
-    }
-  }
-  return true;
+	for (let i = 0; i < identifiers.length; ++i) {
+		const identifier = identifiers[i];
+		if (wrapper.hasRecord(identifier)) return false;
+	}
+	return true;
 }
 function getLocalState(rel) {
-  if (isBelongsTo(rel)) {
-    return rel.localState ? [rel.localState] : [];
-  }
-  return rel.additions ? [...rel.additions] : [];
+	if (isBelongsTo(rel)) return rel.localState ? [rel.localState] : [];
+	return rel.additions ? [...rel.additions] : [];
 }
 function getRemoteState(rel) {
-  if (isBelongsTo(rel)) {
-    return rel.remoteState ? [rel.remoteState] : [];
-  }
-  return rel.remoteState;
+	if (isBelongsTo(rel)) return rel.remoteState ? [rel.remoteState] : [];
+	return rel.remoteState;
 }
 function schemaHasLegacyDefaultValueFn(schema) {
-  if (!schema) return false;
-  return hasLegacyDefaultValueFn(schema.options);
+	if (!schema) return false;
+	return hasLegacyDefaultValueFn(schema.options);
 }
 function hasLegacyDefaultValueFn(options) {
-  return !!options && typeof options.defaultValue === 'function';
+	return !!options && typeof options.defaultValue === "function";
 }
 function getDefaultValue(schema, identifier, store) {
-  const options = schema?.options;
-  if (!schema || !options && !schema.type) {
-    return;
-  }
-  if (schema.kind !== 'attribute' && schema.kind !== 'field') {
-    return;
-  }
-
-  // legacy support for defaultValues that are functions
-  if (hasLegacyDefaultValueFn(options)) {
-    // If anyone opens an issue for args not working right, we'll restore + deprecate it via a Proxy
-    // that lazily instantiates the record. We don't want to provide any args here
-    // because in a non @ember-data/model world they don't make sense.
-    return options.defaultValue();
-    // legacy support for defaultValues that are primitives
-  } else if (options && 'defaultValue' in options) {
-    const defaultValue = options.defaultValue;
-    return defaultValue;
-
-    // new style transforms
-  } else if (schema.kind !== 'attribute' && schema.type) {
-    const transform = store.schema.transformation(schema);
-    if (transform?.defaultValue) {
-      return transform.defaultValue(options || null, identifier);
-    }
-  }
-}
-function notifyAttributes(storeWrapper, identifier, keys) {
-  if (!keys) {
-    storeWrapper.notifyChange(identifier, 'attributes', null);
-    return;
-  }
-  for (const key of keys) {
-    storeWrapper.notifyChange(identifier, 'attributes', key);
-  }
+	const options = schema?.options;
+	if (!schema || !options && !schema.type) return;
+	if (schema.kind !== "attribute" && schema.kind !== "field") return;
+	if (hasLegacyDefaultValueFn(options)) return options.defaultValue();
+	else if (options && "defaultValue" in options) return options.defaultValue;
+	else if (schema.kind !== "attribute" && schema.type) {
+		const transform = store.schema.transformation(schema);
+		if (transform?.defaultValue) return transform.defaultValue(options || null, identifier);
+	}
 }
-
-/*
-      TODO @deprecate IGOR DAVID
-      There seems to be a potential bug here, where we will return keys that are not
-      in the schema
-  */
 function calculateChangedKeys(cached, updates, fields) {
-  const changedKeys = new Set();
-  const keys = Object.keys(updates);
-  const length = keys.length;
-  const localAttrs = cached.localAttrs;
-  const original = Object.assign(Object.create(null), cached.remoteAttrs, cached.inflightAttrs);
-  for (let i = 0; i < length; i++) {
-    const key = keys[i];
-    if (!fields.has(key)) {
-      continue;
-    }
-    const value = updates[key];
-
-    // A value in localAttrs means the user has a local change to
-    // this attribute. We never override this value when merging
-    // updates from the backend so we should not sent a change
-    // notification if the server value differs from the original.
-    if (localAttrs && localAttrs[key] !== undefined) {
-      continue;
-    }
-    if (original[key] !== value) {
-      changedKeys.add(key);
-    }
-  }
-  return changedKeys;
+	const changedKeys = /* @__PURE__ */ new Set();
+	const keys = Object.keys(updates);
+	const length = keys.length;
+	const localAttrs = cached.localAttrs;
+	const original = Object.assign(Object.create(null), cached.remoteAttrs, cached.inflightAttrs);
+	for (let i = 0; i < length; i++) {
+		const key = keys[i];
+		if (!fields.has(key)) continue;
+		const value = updates[key];
+		if (localAttrs && localAttrs[key] !== void 0) continue;
+		if (original[key] !== value) changedKeys.add(key);
+	}
+	return changedKeys;
 }
 function cacheIsEmpty(cached) {
-  return !cached || cached.remoteAttrs === null && cached.inflightAttrs === null && cached.localAttrs === null;
+	return !cached || cached.remoteAttrs === null && cached.inflightAttrs === null && cached.localAttrs === null;
 }
 function _isEmpty(peeked) {
-  if (!peeked) {
-    return true;
-  }
-  const isNew = peeked.isNew;
-  const isDeleted = peeked.isDeleted;
-  const isEmpty = cacheIsEmpty(peeked);
-  return (!isNew || isDeleted) && isEmpty;
+	if (!peeked) return true;
+	const isNew = peeked.isNew;
+	const isDeleted = peeked.isDeleted;
+	const isEmpty = cacheIsEmpty(peeked);
+	return (!isNew || isDeleted) && isEmpty;
 }
 function recordIsLoaded(cached, filterDeleted = false) {
-  if (!cached) {
-    return false;
-  }
-  const isNew = cached.isNew;
-  const isEmpty = cacheIsEmpty(cached);
-
-  // if we are new we must consider ourselves loaded
-  if (isNew) {
-    return !cached.isDeleted;
-  }
-  // even if we have a past request, if we are now empty we are not loaded
-  // typically this is true after an unloadRecord call
-
-  // if we are not empty, not new && we have a fulfilled request then we are loaded
-  // we should consider allowing for something to be loaded that is simply "not empty".
-  // which is how RecordState currently handles this case; however, RecordState is buggy
-  // in that it does not account for unloading.
-  return filterDeleted && cached.isDeletionCommitted ? false : !isEmpty;
+	if (!cached) return false;
+	const isNew = cached.isNew;
+	const isEmpty = cacheIsEmpty(cached);
+	if (isNew) return !cached.isDeleted;
+	return filterDeleted && cached.isDeletionCommitted ? false : !isEmpty;
 }
 function _isLoading(peeked, capabilities, identifier) {
-  assertPrivateCapabilities(capabilities);
-  // TODO refactor things such that the cache is not required to know
-  // about isLoading
-  const req = capabilities._store.getRequestStateService();
-  // const fulfilled = req.getLastRequestForRecord(identifier);
-  const isLoaded = recordIsLoaded(peeked);
-  return !isLoaded &&
-  // fulfilled === null &&
-  req.getPendingRequestsForRecord(identifier).some(r => r.type === 'query');
+	assertPrivateCapabilities(capabilities);
+	const req = capabilities._store.getRequestStateService();
+	return !recordIsLoaded(peeked) && req.getPendingRequestsForRecord(identifier).some((r) => r.type === "query");
 }
 function setupRelationships(graph, fields, identifier, data) {
-  for (const name in data.relationships) {
-    const relationshipData = data.relationships[name];
-    const field = fields.get(name);
-    // TODO consider asserting if the relationship is not in the schema
-    // we intentionally ignore relationships that are not in the schema
-    if (!relationshipData || !field || !isRelationship(field)) continue;
-    graph.push({
-      op: 'updateRelationship',
-      record: identifier,
-      field: name,
-      value: relationshipData
-    });
-  }
+	for (const name in data.relationships) {
+		const relationshipData = data.relationships[name];
+		const field = fields.get(name);
+		if (!relationshipData || !field || !isRelationship(field)) continue;
+		graph.push({
+			op: "updateRelationship",
+			record: identifier,
+			field: name,
+			value: relationshipData
+		});
+	}
 }
 function isRelationship(field) {
-  const {
-    kind
-  } = field;
-  return kind === 'hasMany' || kind === 'belongsTo' || kind === 'resource' || kind === 'collection';
+	const { kind } = field;
+	return kind === "hasMany" || kind === "belongsTo" || kind === "resource" || kind === "collection";
 }
 function patchLocalAttributes(cached, changedRemoteKeys) {
-  const {
-    localAttrs,
-    remoteAttrs,
-    inflightAttrs,
-    defaultAttrs,
-    changes
-  } = cached;
-  if (!localAttrs) {
-    cached.changes = null;
-    return false;
-  }
-  let hasAppliedPatch = false;
-  const mutatedKeys = Object.keys(localAttrs);
-  for (let i = 0, length = mutatedKeys.length; i < length; i++) {
-    const attr = mutatedKeys[i];
-    const existing = inflightAttrs && attr in inflightAttrs ? inflightAttrs[attr] : remoteAttrs && attr in remoteAttrs ? remoteAttrs[attr] : undefined;
-    if (existing === localAttrs[attr]) {
-      hasAppliedPatch = true;
-
-      // if the local change is committed, then
-      // the remoteKeyChange is no longer relevant
-      changedRemoteKeys?.delete(attr);
-      delete localAttrs[attr];
-      delete changes[attr];
-    }
-    if (defaultAttrs && attr in defaultAttrs) {
-      delete defaultAttrs[attr];
-    }
-  }
-  return hasAppliedPatch;
+	const { localAttrs, remoteAttrs, inflightAttrs, defaultAttrs, changes } = cached;
+	if (!localAttrs) {
+		cached.changes = null;
+		return false;
+	}
+	let hasAppliedPatch = false;
+	const mutatedKeys = Object.keys(localAttrs);
+	for (let i = 0, length = mutatedKeys.length; i < length; i++) {
+		const attr = mutatedKeys[i];
+		if ((inflightAttrs && attr in inflightAttrs ? inflightAttrs[attr] : remoteAttrs && attr in remoteAttrs ? remoteAttrs[attr] : void 0) === localAttrs[attr]) {
+			hasAppliedPatch = true;
+			changedRemoteKeys?.delete(attr);
+			delete localAttrs[attr];
+			delete changes[attr];
+		}
+		if (defaultAttrs && attr in defaultAttrs) delete defaultAttrs[attr];
+	}
+	return hasAppliedPatch;
 }
 function putOne(cache, identifiers, resource) {
-  let identifier = identifiers.peekResourceKey(resource);
-  if (identifier) {
-    identifier = identifiers.updateRecordIdentifier(identifier, resource);
-  } else {
-    identifier = identifiers.getOrCreateRecordIdentifier(resource);
-  }
-  cache.upsert(identifier, resource, cache._capabilities.hasRecord(identifier));
-  // even if the identifier was not "existing" before, it is now
-  return identifier;
+	let identifier = identifiers.peekResourceKey(resource);
+	if (identifier) identifier = identifiers.updateRecordIdentifier(identifier, resource);
+	else identifier = identifiers.getOrCreateRecordIdentifier(resource);
+	cache.upsert(identifier, resource, cache._capabilities.hasRecord(identifier));
+	return identifier;
 }
-
-/*
-    Iterates over the set of internal models reachable from `this` across exactly one
-    relationship.
-  */
 function _directlyRelatedIdentifiersIterable(storeWrapper, originating) {
-  const graph = peekGraph(storeWrapper);
-  const initializedRelationships = graph?.identifiers.get(originating);
-  if (!initializedRelationships) {
-    return EMPTY_ITERATOR;
-  }
-  const initializedRelationshipsArr = [];
-  Object.keys(initializedRelationships).forEach(key => {
-    const rel = initializedRelationships[key];
-    if (rel && !isImplicit(rel)) {
-      initializedRelationshipsArr.push(rel);
-    }
-  });
-  let i = 0;
-  let j = 0;
-  let k = 0;
-  const findNext = () => {
-    while (i < initializedRelationshipsArr.length) {
-      while (j < 2) {
-        const relatedIdentifiers = j === 0 ? getLocalState(initializedRelationshipsArr[i]) : getRemoteState(initializedRelationshipsArr[i]);
-        while (k < relatedIdentifiers.length) {
-          const relatedIdentifier = relatedIdentifiers[k++];
-          if (relatedIdentifier !== null) {
-            return relatedIdentifier;
-          }
-        }
-        k = 0;
-        j++;
-      }
-      j = 0;
-      i++;
-    }
-    return undefined;
-  };
-  return {
-    iterator() {
-      return {
-        next: () => {
-          const value = findNext();
-          return {
-            value,
-            done: value === undefined
-          };
-        }
-      };
-    }
-  };
+	const initializedRelationships = peekGraph(storeWrapper)?.identifiers.get(originating);
+	if (!initializedRelationships) return EMPTY_ITERATOR;
+	const initializedRelationshipsArr = [];
+	Object.keys(initializedRelationships).forEach((key) => {
+		const rel = initializedRelationships[key];
+		if (rel && !isImplicit(rel)) initializedRelationshipsArr.push(rel);
+	});
+	let i = 0;
+	let j = 0;
+	let k = 0;
+	const findNext = () => {
+		while (i < initializedRelationshipsArr.length) {
+			while (j < 2) {
+				const relatedIdentifiers = j === 0 ? getLocalState(initializedRelationshipsArr[i]) : getRemoteState(initializedRelationshipsArr[i]);
+				while (k < relatedIdentifiers.length) {
+					const relatedIdentifier = relatedIdentifiers[k++];
+					if (relatedIdentifier !== null) return relatedIdentifier;
+				}
+				k = 0;
+				j++;
+			}
+			j = 0;
+			i++;
+		}
+	};
+	return { iterator() {
+		return { next: () => {
+			const value = findNext();
+			return {
+				value,
+				done: value === void 0
+			};
+		} };
+	} };
 }
-
-/*
-      Computes the set of Identifiers reachable from this Identifier.
-
-      Reachability is determined over the relationship graph (ie a graph where
-      nodes are identifiers and edges are belongs to or has many
-      relationships).
-
-      Returns an array including `this` and all identifiers reachable
-      from `this.identifier`.
-    */
 function _allRelatedIdentifiers(storeWrapper, originating) {
-  const array = [];
-  const queue = [];
-  const seen = new Set();
-  queue.push(originating);
-  while (queue.length > 0) {
-    const identifier = queue.shift();
-    array.push(identifier);
-    seen.add(identifier);
-    const iterator = _directlyRelatedIdentifiersIterable(storeWrapper, originating).iterator();
-    for (let obj = iterator.next(); !obj.done; obj = iterator.next()) {
-      const relatedIdentifier = obj.value;
-      if (relatedIdentifier && !seen.has(relatedIdentifier)) {
-        seen.add(relatedIdentifier);
-        queue.push(relatedIdentifier);
-      }
-    }
-  }
-  return array;
+	const array = [];
+	const queue = [];
+	const seen = /* @__PURE__ */ new Set();
+	queue.push(originating);
+	while (queue.length > 0) {
+		const identifier = queue.shift();
+		array.push(identifier);
+		seen.add(identifier);
+		const iterator = _directlyRelatedIdentifiersIterable(storeWrapper, originating).iterator();
+		for (let obj = iterator.next(); !obj.done; obj = iterator.next()) {
+			const relatedIdentifier = obj.value;
+			if (relatedIdentifier && !seen.has(relatedIdentifier)) {
+				seen.add(relatedIdentifier);
+				queue.push(relatedIdentifier);
+			}
+		}
+	}
+	return array;
 }
 function fromBaseDocument(doc) {
-  const resourceDocument = {};
-  const jsonApiDoc = doc.content;
-  if (jsonApiDoc) {
-    copyLinksAndMeta(resourceDocument, jsonApiDoc);
-  }
-  return resourceDocument;
+	const resourceDocument = {};
+	const jsonApiDoc = doc.content;
+	if (jsonApiDoc) copyLinksAndMeta(resourceDocument, jsonApiDoc);
+	return resourceDocument;
 }
 function fromStructuredError(doc) {
-  const errorDoc = {};
-  if (doc.content) {
-    copyLinksAndMeta(errorDoc, doc.content);
-    if ('errors' in doc.content) {
-      errorDoc.errors = doc.content.errors;
-    } else if (typeof doc.error === 'object' && 'errors' in doc.error) {
-      errorDoc.errors = doc.error.errors;
-    } else {
-      errorDoc.errors = [{
-        title: doc.message
-      }];
-    }
-  }
-  return errorDoc;
+	const errorDoc = {};
+	if (doc.content) {
+		copyLinksAndMeta(errorDoc, doc.content);
+		if ("errors" in doc.content) errorDoc.errors = doc.content.errors;
+		else if (typeof doc.error === "object" && "errors" in doc.error) errorDoc.errors = doc.error.errors;
+		else errorDoc.errors = [{ title: doc.message }];
+	}
+	return errorDoc;
 }
 function copyLinksAndMeta(target, source) {
-  if ('links' in source) {
-    target.links = source.links;
-  }
-  if ('meta' in source) {
-    target.meta = source.meta;
-  }
+	if ("links" in source) target.links = source.links;
+	if ("meta" in source) target.meta = source.meta;
 }
 function cacheUpsert(cache, identifier, data, calculateChanges) {
-  let changedKeys;
-  const peeked = cache.__safePeek(identifier, false);
-  const existed = !!peeked;
-  const cached = peeked || cache._createCache(identifier);
-  const isLoading = /*#__NOINLINE__*/_isLoading(peeked, cache._capabilities, identifier) || !recordIsLoaded(peeked);
-  const isUpdate = /*#__NOINLINE__*/!_isEmpty(peeked) && !isLoading;
-  if (cached.isNew) {
-    cached.isNew = false;
-    cache._capabilities.notifyChange(identifier, 'identity', null);
-    cache._capabilities.notifyChange(identifier, 'state', null);
-  }
-  const fields = getCacheFields(cache, identifier);
-
-  // if no cache entry existed, no record exists / property has been accessed
-  // and thus we do not need to notify changes to any properties.
-  if (calculateChanges && existed && data.attributes) {
-    changedKeys = calculateChangedKeys(cached, data.attributes, fields);
-  }
-  cached.remoteAttrs = Object.assign(cached.remoteAttrs || Object.create(null), data.attributes);
-  if (cached.localAttrs) {
-    if (patchLocalAttributes(cached, changedKeys)) {
-      cache._capabilities.notifyChange(identifier, 'state', null);
-    }
-  }
-  if (!isUpdate) {
-    cache._capabilities.notifyChange(identifier, 'added', null);
-  }
-  if (data.id) {
-    cached.id = data.id;
-  }
-  if (data.relationships) {
-    setupRelationships(cache.__graph, fields, identifier, data);
-  }
-  if (changedKeys?.size) {
-    notifyAttributes(cache._capabilities, identifier, changedKeys);
-  }
-  return changedKeys?.size ? Array.from(changedKeys) : undefined;
+	let changedKeys;
+	const peeked = cache.__safePeek(identifier, false);
+	const existed = !!peeked;
+	const cached = peeked || cache._createCache(identifier);
+	const isLoading = _isLoading(peeked, cache._capabilities, identifier) || !recordIsLoaded(peeked);
+	const isUpdate = !_isEmpty(peeked) && !isLoading;
+	if (cached.isNew) {
+		cached.isNew = false;
+		cache._capabilities.notifyChange(identifier, "identity", null);
+		cache._capabilities.notifyChange(identifier, "state", null);
+	}
+	const fields = getCacheFields(cache, identifier);
+	if (calculateChanges && existed && data.attributes) changedKeys = calculateChangedKeys(cached, data.attributes, fields);
+	cached.remoteAttrs = Object.assign(cached.remoteAttrs || Object.create(null), data.attributes);
+	if (cached.localAttrs) {
+		if (patchLocalAttributes(cached, changedKeys)) cache._capabilities.notifyChange(identifier, "state", null);
+	}
+	if (!isUpdate) cache._capabilities.notifyChange(identifier, "added", null);
+	if (data.id) cached.id = data.id;
+	if (data.relationships) setupRelationships(cache.__graph, fields, identifier, data);
+	if (changedKeys?.size) cache._capabilities.notifyChange(identifier, "attributes", changedKeys);
+	return changedKeys?.size ? Array.from(changedKeys) : void 0;
 }
 function patchCache(Cache, op) {
-  const isRecord = isResourceKey(op.record);
-  !isRecord && isRequestKey(op.record);
-  switch (op.op) {
-    case 'mergeIdentifiers':
-      {
-        const cache = Cache.__cache.get(op.record);
-        if (cache) {
-          Cache.__cache.set(op.value, cache);
-          Cache.__cache.delete(op.record);
-        }
-        Cache.__graph.update(op, true);
-        break;
-      }
-    case 'update':
-      {
-        if (isRecord) {
-          if ('field' in op) {
-            const field = getCacheFields(Cache, op.record).get(op.field);
-            if (isRelationship(field)) {
-              Cache.__graph.push(op);
-            } else {
-              Cache.upsert(op.record, {
-                type: op.record.type,
-                id: op.record.id,
-                attributes: {
-                  [op.field]: op.value
-                }
-              }, Cache._capabilities.hasRecord(op.record));
-            }
-          } else {
-            Cache.upsert(op.record, op.value, Cache._capabilities.hasRecord(op.record));
-          }
-        }
-        break;
-      }
-    case 'add':
-      {
-        if (isRecord) {
-          if ('field' in op) {
-            Cache.__graph.push(op);
-          } else {
-            Cache.upsert(op.record, op.value, Cache._capabilities.hasRecord(op.record));
-          }
-        } else {
-          addResourceToDocument(Cache, op);
-        }
-        break;
-      }
-    case 'remove':
-      {
-        if (isRecord) {
-          if ('field' in op) {
-            Cache.__graph.push(op);
-          } else {
-            const cached = Cache.__safePeek(op.record, false);
-            if (cached) {
-              cached.isDeleted = true;
-              cached.isDeletionCommitted = true;
-              Cache.unloadRecord(op.record);
-            } else {
-              peekGraph(Cache._capabilities)?.push({
-                op: 'deleteRecord',
-                record: op.record,
-                isNew: false
-              });
-            }
-          }
-        } else {
-          if ('field' in op) {
-            removeResourceFromDocument(Cache, op);
-          }
-        }
-        break;
-      }
-  }
+	const isRecord = isResourceKey(op.record);
+	!isRecord && isRequestKey(op.record);
+	switch (op.op) {
+		case "mergeIdentifiers": {
+			const cache = Cache.__cache.get(op.record);
+			if (cache) {
+				Cache.__cache.set(op.value, cache);
+				Cache.__cache.delete(op.record);
+			}
+			Cache.__graph.update(op, true);
+			break;
+		}
+		case "update":
+			if (isRecord) {
+				if ("field" in op) {
+					if (isRelationship(getCacheFields(Cache, op.record).get(op.field))) Cache.__graph.push(op);
+					else Cache.upsert(op.record, {
+						type: op.record.type,
+						id: op.record.id,
+						attributes: { [op.field]: op.value }
+					}, Cache._capabilities.hasRecord(op.record));
+				} else Cache.upsert(op.record, op.value, Cache._capabilities.hasRecord(op.record));
+			}
+			break;
+		case "add":
+			if (isRecord) {
+				if ("field" in op) Cache.__graph.push(op);
+				else Cache.upsert(op.record, op.value, Cache._capabilities.hasRecord(op.record));
+			} else addResourceToDocument(Cache, op);
+			break;
+		case "remove": if (isRecord) {
+			if ("field" in op) Cache.__graph.push(op);
+			else {
+				const cached = Cache.__safePeek(op.record, false);
+				if (cached) {
+					cached.isDeleted = true;
+					cached.isDeletionCommitted = true;
+					Cache.unloadRecord(op.record);
+				} else peekGraph(Cache._capabilities)?.push({
+					op: "deleteRecord",
+					record: op.record,
+					isNew: false
+				});
+			}
+		} else if ("field" in op) removeResourceFromDocument(Cache, op);
+	}
 }
 function getCacheFields(cache, identifier) {
-  if (cache._capabilities.schema.cacheFields) {
-    const result = cache._capabilities.schema.cacheFields(identifier);
-    if (result) {
-      return result;
-    }
-  }
-
-  // the model schema service cannot process fields that are not cache fields
-  return cache._capabilities.schema.fields(identifier);
+	if (cache._capabilities.schema.cacheFields) {
+		const result = cache._capabilities.schema.cacheFields(identifier);
+		if (result) return result;
+	}
+	return cache._capabilities.schema.fields(identifier);
 }
 function commitDidError(cache, identifier, errors) {
-  const cached = cache.__peek(identifier, false);
-  if (cached.inflightAttrs) {
-    const keys = Object.keys(cached.inflightAttrs);
-    if (keys.length > 0) {
-      const attrs = cached.localAttrs = cached.localAttrs || Object.create(null);
-      for (let i = 0; i < keys.length; i++) {
-        if (attrs[keys[i]] === undefined) {
-          attrs[keys[i]] = cached.inflightAttrs[keys[i]];
-        }
-      }
-    }
-    cached.inflightAttrs = null;
-  }
-  if (errors) {
-    cached.errors = errors;
-  }
-  cache._capabilities.notifyChange(identifier, 'errors', null);
+	const cached = cache.__peek(identifier, false);
+	if (cached.inflightAttrs) {
+		const keys = Object.keys(cached.inflightAttrs);
+		if (keys.length > 0) {
+			const attrs = cached.localAttrs = cached.localAttrs || Object.create(null);
+			for (let i = 0; i < keys.length; i++) if (attrs[keys[i]] === void 0) attrs[keys[i]] = cached.inflightAttrs[keys[i]];
+		}
+		cached.inflightAttrs = null;
+	}
+	if (errors) cached.errors = errors;
+	cache._capabilities.notifyChange(identifier, "errors", null);
 }
 function didCommit(cache, committedIdentifier, data, op) {
-  const {
-    cacheKeyManager
-  } = cache._capabilities;
-  const existingId = committedIdentifier.id;
-  const identifier = op !== 'deleteRecord' && data ? cacheKeyManager.updateRecordIdentifier(committedIdentifier, data) : committedIdentifier;
-  const cached = cache.__peek(identifier, false);
-  if (cached.isDeleted || op === 'deleteRecord') {
-    cache.__graph.push({
-      op: 'deleteRecord',
-      record: identifier,
-      isNew: false
-    });
-    cached.isDeleted = true;
-    cached.isDeletionCommitted = true;
-    cache._capabilities.notifyChange(identifier, 'removed', null);
-    // TODO @runspired should we early exit here?
-  }
-  const fields = getCacheFields(cache, identifier);
-  cached.isNew = false;
-  let newCanonicalAttributes;
-  if (data) {
-    if (data.id && !cached.id) {
-      cached.id = data.id;
-    }
-    if (identifier === committedIdentifier && identifier.id !== existingId) {
-      cache._capabilities.notifyChange(identifier, 'identity', null);
-    }
-    if (data.relationships) {
-      setupRelationships(cache.__graph, fields, identifier, data);
-    }
-    newCanonicalAttributes = data.attributes;
-  }
-  const changedKeys = newCanonicalAttributes && calculateChangedKeys(cached, newCanonicalAttributes, fields);
-  cached.remoteAttrs = Object.assign(cached.remoteAttrs || Object.create(null), cached.inflightAttrs, newCanonicalAttributes);
-  cached.inflightAttrs = null;
-  patchLocalAttributes(cached, changedKeys);
-  if (cached.errors) {
-    cached.errors = null;
-    cache._capabilities.notifyChange(identifier, 'errors', null);
-  }
-  if (changedKeys?.size) notifyAttributes(cache._capabilities, identifier, changedKeys);
-  cache._capabilities.notifyChange(identifier, 'state', null);
+	if (!data) {}
+	const { cacheKeyManager } = cache._capabilities;
+	const existingId = committedIdentifier.id;
+	const identifier = op !== "deleteRecord" && data ? cacheKeyManager.updateRecordIdentifier(committedIdentifier, data) : committedIdentifier;
+	const cached = cache.__peek(identifier, false);
+	if (cached.isDeleted || op === "deleteRecord") {
+		cache.__graph.push({
+			op: "deleteRecord",
+			record: identifier,
+			isNew: false
+		});
+		cached.isDeleted = true;
+		cached.isDeletionCommitted = true;
+		cache._capabilities.notifyChange(identifier, "removed", null);
+	}
+	const fields = getCacheFields(cache, identifier);
+	cached.isNew = false;
+	let newCanonicalAttributes;
+	if (data) {
+		if (data.id && !cached.id) cached.id = data.id;
+		if (identifier === committedIdentifier && identifier.id !== existingId) cache._capabilities.notifyChange(identifier, "identity", null);
+		if (data.relationships) setupRelationships(cache.__graph, fields, identifier, data);
+		newCanonicalAttributes = data.attributes;
+	}
+	const changedKeys = newCanonicalAttributes && calculateChangedKeys(cached, newCanonicalAttributes, fields);
+	cached.remoteAttrs = Object.assign(cached.remoteAttrs || Object.create(null), cached.inflightAttrs, newCanonicalAttributes);
+	cached.inflightAttrs = null;
+	patchLocalAttributes(cached, changedKeys);
+	if (cached.errors) {
+		cached.errors = null;
+		cache._capabilities.notifyChange(identifier, "errors", null);
+	}
+	if (changedKeys?.size) cache._capabilities.notifyChange(identifier, "attributes", changedKeys);
+	cache._capabilities.notifyChange(identifier, "state", null);
 }
 function willCommit(cache, identifier) {
-  const cached = cache.__peek(identifier, false);
-
-  /*
-      if we have multiple saves in flight at once then
-      we have information loss no matter what. This
-      attempts to lose the least information.
-       If we were to clear inflightAttrs, previous requests
-      would not be able to use it during their didCommit.
-       If we upsert inflightattrs, previous requests incorrectly
-      see more recent inflight changes as part of their own and
-      will incorrectly mark the new state as the correct remote state.
-       We choose this latter behavior to avoid accidentally removing
-      earlier changes.
-       If apps do not want this behavior they can either
-      - chain save requests serially vs allowing concurrent saves
-      - move to using a request handler that caches the inflight state
-        on a per-request basis
-      - change their save requests to only send a "PATCH" instead of a "PUT"
-        so that only latest changes are involved in each request, and then also
-        ensure that the API or their handler reflects only those changes back
-        for upsert into the cache.
-    */
-  if (cached.inflightAttrs) {
-    if (cached.localAttrs) {
-      Object.assign(cached.inflightAttrs, cached.localAttrs);
-    }
-  } else {
-    cached.inflightAttrs = cached.localAttrs;
-  }
-  cached.localAttrs = null;
+	const cached = cache.__peek(identifier, false);
+	if (cached.inflightAttrs) {
+		if (cached.localAttrs) Object.assign(cached.inflightAttrs, cached.localAttrs);
+	} else cached.inflightAttrs = cached.localAttrs;
+	cached.localAttrs = null;
 }
 
+//#endregion
 export { JSONAPICache };
+//# sourceMappingURL=index.js.map