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

package/dist/reactive.js

@@ -1,1402 +1,16 @@
+import { L as ReactiveResource, M as isNonIdentityCacheableField, N as getFieldCacheKeyStrict, r as recordIdentifierFor, H as withSignalStore, G as createInternalMemo } from "./request-state-C955e0AL.js";
+export { O as checkout, P as commit } from "./request-state-C955e0AL.js";
 import { isResourceSchema } from './types/schema/fields.js';
-import { E as withSignalStore, Q as isExtensionProp, T as performExtensionSet, G as consumeInternalSignal, U as performArrayExtensionGet, x as entangleSignal, V as performObjectExtensionGet, d as SOURCE$1, f as fastPush, y as defineSignal, l as RelatedCollection, H as getOrCreateInternalSignal, F as notifyInternalSignal, A as Signals, h as setRecordIdentifier, r as recordIdentifierFor } from "./request-state-CjLph1LP.js";
-import { EnableHydration, STRUCTURED } from './types/request.js';
+import { D as Destroy, C as Context } from "./symbols-sql1_mdx.js";
+export { a as Checkout } from "./symbols-sql1_mdx.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
-import { deprecate } from '@ember/debug';
+import { warn, deprecate } from '@ember/debug';
+import './index.js';
+import './types/request.js';
 import './utils/string.js';
-import { A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, c as createMemo } from "./configure-B48bFHOl.js";
-import { RecordStore, Type } from './types/symbols.js';
+import "./configure-C3x8YXzL.js";
 import { getOrSetGlobal } from './types/-private.js';
-import { S as SOURCE, E as Editable, L as Legacy, I as Identifier, P as Parent, a as EmbeddedPath, D as Destroy, C as Checkout, b as EmbeddedField } from "./symbols-SIstXMLI.js";
-import './index.js';
-const ARRAY_GETTER_METHODS = new Set([Symbol.iterator, 'concat', 'entries', 'every', 'fill', 'filter', 'find', 'findIndex', 'flat', 'flatMap', 'forEach', 'includes', 'indexOf', 'join', 'keys', 'lastIndexOf', 'map', 'reduce', 'reduceRight', 'slice', 'some', 'values']);
-// const ARRAY_SETTER_METHODS = new Set<KeyType>(['push', 'pop', 'unshift', 'shift', 'splice', 'sort']);
-const SYNC_PROPS = new Set(['[]', 'length']);
-function isArrayGetter(prop) {
-  return ARRAY_GETTER_METHODS.has(prop);
-}
-const ARRAY_SETTER_METHODS = new Set(['push', 'pop', 'unshift', 'shift', 'splice', 'sort']);
-function isArraySetter(prop) {
-  return ARRAY_SETTER_METHODS.has(prop);
-}
-
-// function isSelfProp<T extends object>(self: T, prop: KeyType): prop is keyof T {
-//   return prop in self;
-// }
-
-function convertToInt(prop) {
-  if (typeof prop === 'symbol') return null;
-  const num = Number(prop);
-  if (isNaN(num)) return null;
-  return num % 1 === 0 ? num : null;
-}
-function safeForEach(instance, arr, store, callback, target) {
-  if (target === undefined) {
-    target = null;
-  }
-  // clone to prevent mutation
-  arr = arr.slice();
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error('`forEach` expects a function as first argument.');
-    }
-  })(typeof callback === 'function') : {};
-
-  // because we retrieveLatest above we need not worry if array is mutated during iteration
-  // by unloadRecord/rollbackAttributes
-  // push/add/removeObject may still be problematic
-  // but this is a more traditionally expected forEach bug.
-  const length = arr.length; // we need to access length to ensure we are consumed
-
-  for (let index = 0; index < length; index++) {
-    callback.call(target, arr[index], index, instance);
-  }
-  return instance;
-}
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-class ManagedArray {
-  constructor(store, schema, cache, field, data, identifier, path, owner, isSchemaArray, editable, legacy) {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const self = this;
-    this[SOURCE] = data?.slice();
-    const IS_EDITABLE = this[Editable] = editable ?? false;
-    this[Legacy] = legacy;
-    const signals = withSignalStore(this);
-    let _SIGNAL = null;
-    const boundFns = new Map();
-    this.identifier = identifier;
-    this.path = path;
-    this.owner = owner;
-    let transaction = false;
-    const mode = field.options?.key ?? '@identity';
-    const RefStorage = mode === '@identity' ? WeakMap :
-    // CAUTION CAUTION CAUTION
-    // this is a pile of lies
-    // the Map is Map<string, WeakRef<ReactiveResource>>
-    // but TS does not understand how to juggle modes like this
-    // internal to a method like ours without us duplicating the code
-    // into two separate methods.
-    Map;
-    const ManagedRecordRefs = isSchemaArray ? new RefStorage() : null;
-    const extensions = legacy ? schema.CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field) : null;
-    const proxy = new Proxy(this[SOURCE], {
-      get(target, prop, receiver) {
-        if (prop === ARRAY_SIGNAL) {
-          return _SIGNAL;
-        }
-        if (prop === 'identifier') {
-          return self.identifier;
-        }
-        if (prop === 'owner') {
-          return self.owner;
-        }
-        const index = convertToInt(prop);
-        if (_SIGNAL.isStale && (index !== null || SYNC_PROPS.has(prop) || isArrayGetter(prop))) {
-          _SIGNAL.isStale = false;
-          const newData = cache.getAttr(identifier, path);
-          if (newData && newData !== self[SOURCE]) {
-            self[SOURCE].length = 0;
-            self[SOURCE].push(...newData);
-          }
-        }
-        if (prop === 'length') {
-          return consumeInternalSignal(_SIGNAL), target.length;
-        }
-        if (prop === '[]') return consumeInternalSignal(_SIGNAL), receiver;
-        if (index !== null) {
-          let val;
-          if (mode === '@hash') {
-            val = target[index];
-            const hashField = schema.resource({
-              type: field.type
-            }).identity;
-            const hashFn = schema.hashFn(hashField);
-            val = hashFn(val, null, null);
-          } else {
-            // if mode is not @identity or @index, then access the key path.
-            // we should assert that `mode` is a string
-            // it should read directly from the cache value for that field (e.g. no derivation, no transformation)
-            // and, we likely should lookup the associated field and throw an error IF
-            // the given field does not exist OR
-            // the field is anything other than a GenericField or LegacyAttributeField.
-            if (mode !== '@identity' && mode !== '@index') {
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error('mode must be a string');
-                }
-              })(typeof mode === 'string') : {};
-              const modeField = schema.resource({
-                type: field.type
-              }).fields.find(f => f.name === mode);
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error('field must exist in schema');
-                }
-              })(modeField) : {};
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error('field must be a GenericField or LegacyAttributeField');
-                }
-              })(modeField.kind === 'field' || modeField.kind === 'attribute') : {};
-            }
-            val = mode === '@identity' ? target[index] : mode === '@index' ? '@index' : target[index][mode];
-          }
-          if (isSchemaArray) {
-            if (!transaction) {
-              consumeInternalSignal(_SIGNAL);
-            }
-            if (val) {
-              const recordRef = ManagedRecordRefs.get(val);
-              let record = recordRef?.deref();
-              if (!record) {
-                const recordPath = path.slice();
-                // this is a dirty lie since path is string[] but really we
-                // should change the types for paths to `Array<string | number>`
-                // TODO we should allow the schema for the field to define a "key"
-                // for stability. Default should be `@identity` which means that
-                // same object reference from cache should result in same ReactiveResource
-                // embedded object.
-                recordPath.push(index);
-                const recordIdentifier = self.owner[Identifier] || self.owner[Parent];
-                record = new ReactiveResource(store, recordIdentifier, {
-                  [Editable]: self.owner[Editable],
-                  [Legacy]: self.owner[Legacy]
-                }, true, field, recordPath);
-                // if mode is not @identity or @index, then access the key path now
-                // to determine the key value.
-                // chris says we can implement this as a special kind `@hash` which
-                // would be a function that only has access to the cache value and not
-                // the record itself, so derivation is possible but intentionally limited
-                // and non-reactive?
-                ManagedRecordRefs.set(val, new WeakRef(record));
-              }
-              return record;
-            }
-            return val;
-          }
-          if (!transaction) {
-            consumeInternalSignal(_SIGNAL);
-          }
-          if (field.type) {
-            const transform = schema.transformation(field);
-            return transform.hydrate(val, field.options ?? null, self.owner);
-          }
-          return val;
-        }
-        if (isArrayGetter(prop)) {
-          let fn = boundFns.get(prop);
-          if (fn === undefined) {
-            if (prop === 'forEach') {
-              fn = function () {
-                consumeInternalSignal(_SIGNAL);
-                transaction = true;
-                const result = safeForEach(receiver, target, store, arguments[0], arguments[1]);
-                transaction = false;
-                return result;
-              };
-            } else {
-              fn = function () {
-                consumeInternalSignal(_SIGNAL);
-                // array functions must run through Reflect to work properly
-                // binding via other means will not work.
-                transaction = true;
-                const result = Reflect.apply(target[prop], receiver, arguments);
-                transaction = false;
-                return result;
-              };
-            }
-            boundFns.set(prop, fn);
-          }
-          return fn;
-        }
-        if (isArraySetter(prop)) {
-          let fn = boundFns.get(prop);
-          if (fn === undefined) {
-            fn = function () {
-              if (!IS_EDITABLE) {
-                throw new Error(`Mutating this array via ${String(prop)} is not allowed because the record is not editable`);
-              }
-              consumeInternalSignal(_SIGNAL);
-              transaction = true;
-              const result = Reflect.apply(target[prop], receiver, arguments);
-              transaction = false;
-              return result;
-            };
-            boundFns.set(prop, fn);
-          }
-          return fn;
-        }
-        if (isExtensionProp(extensions, prop)) {
-          return performArrayExtensionGet(receiver, extensions, signals, prop, _SIGNAL, boundFns, v => void (transaction = v));
-        }
-        return Reflect.get(target, prop, receiver);
-      },
-      set(target, prop, value, receiver) {
-        if (!IS_EDITABLE) {
-          let errorPath = identifier.type;
-          if (path) {
-            errorPath = path[path.length - 1];
-          }
-          throw new Error(`Cannot set ${String(prop)} on ${errorPath} because the record is not editable`);
-        }
-        if (prop === 'identifier') {
-          self.identifier = value;
-          return true;
-        }
-        if (prop === 'owner') {
-          self.owner = value;
-          return true;
-        }
-        if (isExtensionProp(extensions, prop)) {
-          return performExtensionSet(receiver, extensions, signals, prop, value);
-        }
-        const reflect = Reflect.set(target, prop, value, receiver);
-        if (reflect) {
-          if (!field.type) {
-            cache.setAttr(identifier, path, self[SOURCE]);
-            _SIGNAL.isStale = true;
-            return true;
-          }
-          let rawValue = self[SOURCE];
-          if (!isSchemaArray) {
-            const transform = schema.transformation(field);
-            if (!transform) {
-              throw new Error(`No '${field.type}' transform defined for use by ${identifier.type}.${String(prop)}`);
-            }
-            rawValue = self[SOURCE].map(item => transform.serialize(item, field.options ?? null, self.owner));
-          }
-          cache.setAttr(identifier, path, rawValue);
-          _SIGNAL.isStale = true;
-        }
-        return reflect;
-      },
-      has(target, prop) {
-        if (prop === 'identifier' || prop === 'owner' || prop === ARRAY_SIGNAL) {
-          return true;
-        }
-        return Reflect.has(target, prop);
-      }
-    });
-
-    // we entangle the signal on the returned proxy since that is
-    // the object that other code will be interfacing with.
-    _SIGNAL = entangleSignal(signals, proxy, ARRAY_SIGNAL, undefined);
-    return proxy;
-  }
-}
-
-// this will error if someone tries to call
-// A(identifierArray) since it is not configurable
-// which is preferable to the `meta` override we used
-// before which required importing all of Ember
-const desc = {
-  enumerable: true,
-  configurable: false,
-  get: function () {
-    // here to support computed chains
-    // and {{#each}}
-    if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_COMPUTED_CHAINS)) {
-      return this;
-    }
-  }
-};
-// compat(desc);
-Object.defineProperty(ManagedArray.prototype, '[]', desc);
-const ObjectSymbols = new Set([OBJECT_SIGNAL, Parent, SOURCE, Editable, EmbeddedPath]);
-
-// const ignoredGlobalFields = new Set<string>(['setInterval', 'nodeType', 'nodeName', 'length', 'document', STRUCTURED]);
-
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-class ManagedObject {
-  constructor(schema, cache, field, data, identifier, path, owner, editable, legacy) {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const self = this;
-    this[SOURCE] = {
-      ...data
-    };
-    const signals = withSignalStore(this);
-    const _SIGNAL = this[OBJECT_SIGNAL] = entangleSignal(signals, this, OBJECT_SIGNAL, undefined);
-    this[Editable] = editable;
-    this[Legacy] = legacy;
-    this[Parent] = identifier;
-    this[EmbeddedPath] = path;
-
-    // prettier-ignore
-    const extensions = !legacy ? null : schema.CAUTION_MEGA_DANGER_ZONE_objectExtensions(field);
-    const proxy = new Proxy(this[SOURCE], {
-      ownKeys() {
-        return Object.keys(self[SOURCE]);
-      },
-      has(target, prop) {
-        return prop in self[SOURCE];
-      },
-      getOwnPropertyDescriptor(target, prop) {
-        return {
-          writable: editable,
-          enumerable: true,
-          configurable: true
-        };
-      },
-      get(target, prop, receiver) {
-        if (ObjectSymbols.has(prop)) {
-          return self[prop];
-        }
-        if (prop === Symbol.toPrimitive) {
-          return () => null;
-        }
-        if (prop === Symbol.toStringTag) {
-          return `ManagedObject<${identifier.type}:${identifier.id} (${identifier.lid})>`;
-        }
-        if (prop === 'constructor') {
-          return Object;
-        }
-        if (prop === 'toString') {
-          return function () {
-            return `ManagedObject<${identifier.type}:${identifier.id} (${identifier.lid})>`;
-          };
-        }
-        if (prop === 'toHTML') {
-          return function () {
-            return '<span>ManagedObject</span>';
-          };
-        }
-        if (_SIGNAL.isStale) {
-          _SIGNAL.isStale = false;
-          let newData = cache.getAttr(identifier, path);
-          if (newData && newData !== self[SOURCE]) {
-            if (field.type) {
-              const transform = schema.transformation(field);
-              newData = transform.hydrate(newData, field.options ?? null, owner);
-            }
-            self[SOURCE] = {
-              ...newData
-            }; // Add type assertion for newData
-          }
-        }
-
-        // toJSON and extensions need to come after we update data if stale
-        if (prop === 'toJSON') {
-          return function () {
-            return structuredClone(self[SOURCE]);
-          };
-        }
-
-        // we always defer to data before extensions
-        if (prop in self[SOURCE]) {
-          consumeInternalSignal(_SIGNAL);
-          return self[SOURCE][prop];
-        }
-        if (isExtensionProp(extensions, prop)) {
-          return performObjectExtensionGet(receiver, extensions, signals, prop);
-        }
-        return Reflect.get(target, prop, receiver);
-      },
-      set(target, prop, value, receiver) {
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          if (!test) {
-            throw new Error(`Cannot set read-only property '${String(prop)}' on ManagedObject`);
-          }
-        })(editable) : {};
-
-        // since objects function as dictionaries, we can't defer to schema/data before extensions
-        // unless the prop is in the existing data.
-        if (!(prop in self[SOURCE]) && isExtensionProp(extensions, prop)) {
-          return performExtensionSet(receiver, extensions, signals, prop, value);
-        }
-        const reflect = Reflect.set(target, prop, value, receiver);
-        if (!reflect) {
-          return false;
-        }
-        if (!field.type) {
-          cache.setAttr(identifier, path, self[SOURCE]);
-        } else {
-          const transform = schema.transformation(field);
-          const val = transform.serialize(self[SOURCE], field.options ?? null, owner);
-          cache.setAttr(identifier, path, val);
-        }
-        _SIGNAL.isStale = true;
-        return true;
-      }
-    });
-    return proxy;
-  }
-}
-class ManyArrayManager {
-  constructor(record, editable) {
-    this.record = record;
-    this.store = record[RecordStore];
-    this.identifier = record[Identifier];
-    this.editable = editable;
-  }
-  _syncArray(array) {
-    const method = this.editable ? 'getRelationship' : 'getRemoteRelationship';
-    const rawValue = this.store.cache[method](this.identifier, array.key);
-    if (rawValue.meta) {
-      array.meta = rawValue.meta;
-    }
-    if (rawValue.links) {
-      array.links = rawValue.links;
-    }
-    const currentState = array[SOURCE$1];
-
-    // unlike in the normal RecordArray case, we don't need to divorce the reference
-    // because we don't need to worry about associate/disassociate since the graph
-    // takes care of that for us
-    if (currentState !== rawValue.data) {
-      currentState.length = 0;
-      fastPush(currentState, rawValue.data);
-    }
-  }
-  reloadHasMany(key, options) {
-    const field = this.store.schema.fields(this.identifier).get(key);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Expected a hasMany field for ${key}`);
-      }
-    })(field?.kind === 'hasMany') : {};
-    const cacheOptions = options ? extractCacheOptions(options) : {
-      reload: true
-    };
-    cacheOptions.types = [field.type];
-    const rawValue = this.store.cache.getRelationship(this.identifier, key);
-    const req = {
-      url: getRelatedLink(rawValue),
-      op: 'findHasMany',
-      method: 'GET',
-      records: rawValue.data,
-      cacheOptions,
-      options: {
-        field,
-        identifier: this.identifier,
-        links: rawValue.links,
-        meta: rawValue.meta
-      },
-      [EnableHydration]: false
-    };
-    return this.store.request(req);
-  }
-  mutate(mutation) {
-    this.store.cache.mutate(mutation);
-  }
-}
-function getRelatedLink(resource) {
-  const related = resource.links?.related;
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Expected a related link`);
-    }
-  })(related) : {};
-  return typeof related === 'object' ? related.href : related;
-}
-function extractCacheOptions(options) {
-  const cacheOptions = {};
-  if ('reload' in options) {
-    cacheOptions.reload = options.reload;
-  }
-  if ('backgroundReload' in options) {
-    cacheOptions.backgroundReload = options.backgroundReload;
-  }
-  return cacheOptions;
-}
-const ManagedArrayMap = getOrSetGlobal('ManagedArrayMap', new Map());
-const ManagedObjectMap = getOrSetGlobal('ManagedObjectMap', new Map());
-function computeLocal(record, field, prop) {
-  const signals = withSignalStore(record);
-  const signal = getOrCreateInternalSignal(signals, record, prop, field.options?.defaultValue ?? null);
-  consumeInternalSignal(signal);
-  return signal.value;
-}
-function peekManagedArray(record, field) {
-  const managedArrayMapForRecord = ManagedArrayMap.get(record);
-  if (managedArrayMapForRecord) {
-    return managedArrayMapForRecord.get(field.name);
-  }
-}
-function peekManagedObject(record, field) {
-  const managedObjectMapForRecord = ManagedObjectMap.get(record);
-  if (managedObjectMapForRecord) {
-    return managedObjectMapForRecord.get(field.name);
-  }
-}
-function computeField(schema, cache, record, identifier, field, prop, editable) {
-  const rawValue = editable ? cache.getAttr(identifier, prop) : cache.getRemoteAttr(identifier, prop);
-  if (!field.type) {
-    return rawValue;
-  }
-  const transform = schema.transformation(field);
-  return transform.hydrate(rawValue, field.options ?? null, record);
-}
-function computeArray(store, schema, cache, record, identifier, field, path, editable, legacy) {
-  const isSchemaArray = field.kind === 'schema-array';
-  // the thing we hand out needs to know its owner and path in a private manner
-  // its "address" is the parent identifier (identifier) + field name (field.name)
-  //  in the nested object case field name here is the full dot path from root resource to this value
-  // its "key" is the field on the parent record
-  // its "owner" is the parent record
-
-  const managedArrayMapForRecord = ManagedArrayMap.get(record);
-  let managedArray;
-  if (managedArrayMapForRecord) {
-    managedArray = managedArrayMapForRecord.get(field.name);
-  }
-  if (managedArray) {
-    return managedArray;
-  } else {
-    const rawValue = editable ? cache.getAttr(identifier, path) : cache.getRemoteAttr(identifier, path);
-    if (!rawValue) {
-      return null;
-    }
-    managedArray = new ManagedArray(store, schema, cache, field, rawValue, identifier, path, record, isSchemaArray, editable, legacy);
-    if (!managedArrayMapForRecord) {
-      ManagedArrayMap.set(record, new Map([[field.name, managedArray]]));
-    } else {
-      managedArrayMapForRecord.set(field.name, managedArray);
-    }
-  }
-  return managedArray;
-}
-function computeObject(schema, cache, record, identifier, field, path, editable, legacy) {
-  const managedObjectMapForRecord = ManagedObjectMap.get(record);
-  let managedObject;
-  if (managedObjectMapForRecord) {
-    managedObject = managedObjectMapForRecord.get(field.name);
-  }
-  if (managedObject) {
-    return managedObject;
-  } else {
-    let rawValue = editable ? cache.getAttr(identifier, path) : cache.getRemoteAttr(identifier, path);
-    if (!rawValue) {
-      return null;
-    }
-    if (field.type) {
-      const transform = schema.transformation(field);
-      rawValue = transform.hydrate(rawValue, field.options ?? null, record);
-    }
-    managedObject = new ManagedObject(schema, cache, field, rawValue, identifier, path, record, editable, legacy);
-    if (!managedObjectMapForRecord) {
-      ManagedObjectMap.set(record, new Map([[field.name, managedObject]]));
-    } else {
-      managedObjectMapForRecord.set(field.name, managedObject);
-    }
-  }
-  return managedObject;
-}
-function computeSchemaObject(store, cache, record, identifier, field, path, legacy, editable) {
-  const schemaObjectMapForRecord = ManagedObjectMap.get(record);
-  let schemaObject;
-  if (schemaObjectMapForRecord) {
-    schemaObject = schemaObjectMapForRecord.get(field.name);
-  }
-  if (schemaObject) {
-    return schemaObject;
-  } else {
-    const rawValue = editable ? cache.getAttr(identifier, path) : cache.getRemoteAttr(identifier, path);
-    if (!rawValue) {
-      return null;
-    }
-    const embeddedPath = path.slice();
-    schemaObject = new ReactiveResource(store, identifier, {
-      [Editable]: editable,
-      [Legacy]: legacy
-    }, true, field, embeddedPath);
-  }
-  if (!schemaObjectMapForRecord) {
-    ManagedObjectMap.set(record, new Map([[field.name, schemaObject]]));
-  } else {
-    schemaObjectMapForRecord.set(field.name, schemaObject);
-  }
-  return schemaObject;
-}
-function computeAttribute(cache, identifier, prop, editable) {
-  return editable ? cache.getAttr(identifier, prop) : cache.getRemoteAttr(identifier, prop);
-}
-function computeDerivation(schema, record, identifier, field, prop) {
-  return schema.derivation(field)(record, field.options ?? null, prop);
-}
-// TODO probably this should just be a Document
-// but its separate until we work out the lid situation
-class ResourceRelationship {
-  constructor(store, cache, parent, identifier, field, name, editable) {
-    const rawValue = editable ? cache.getRelationship(identifier, name) : cache.getRemoteRelationship(identifier, name);
-
-    // TODO setup true lids for relationship documents
-    // @ts-expect-error we need to give relationship documents a lid
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    this.lid = rawValue.lid ?? rawValue.links?.self ?? `relationship:${identifier.lid}.${name}`;
-    this.data = rawValue.data ? store.peekRecord(rawValue.data) : null;
-    this.name = name;
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      this.links = Object.freeze(Object.assign({}, rawValue.links));
-      this.meta = Object.freeze(Object.assign({}, rawValue.meta));
-    } else {
-      this.links = rawValue.links ?? {};
-      this.meta = rawValue.meta ?? {};
-    }
-    this[RecordStore] = store;
-    this[Parent] = parent;
-  }
-  fetch(options) {
-    const url = options?.url ?? getHref(this.links.related) ?? getHref(this.links.self) ?? null;
-    if (!url) {
-      throw new Error(`Cannot ${options?.method ?? 'fetch'} ${this[Parent][Identifier].type}.${String(this.name)} because it has no related link`);
-    }
-    const request = Object.assign({
-      url,
-      method: 'GET'
-    }, options);
-    return this[RecordStore].request(request);
-  }
-}
-defineSignal(ResourceRelationship.prototype, 'data', null);
-defineSignal(ResourceRelationship.prototype, 'links', null);
-defineSignal(ResourceRelationship.prototype, 'meta', null);
-function getHref(link) {
-  if (!link) {
-    return null;
-  }
-  if (typeof link === 'string') {
-    return link;
-  }
-  return link.href;
-}
-function computeResource(store, cache, parent, identifier, field, prop, editable) {
-  if (field.kind !== 'resource') {
-    throw new Error(`The schema for ${identifier.type}.${String(prop)} is not a resource relationship`);
-  }
-  return new ResourceRelationship(store, cache, parent, identifier, field, prop, editable);
-}
-function computeHasMany(store, schema, cache, record, identifier, field, path, editable, legacy) {
-  // the thing we hand out needs to know its owner and path in a private manner
-  // its "address" is the parent identifier (identifier) + field name (field.name)
-  //  in the nested object case field name here is the full dot path from root resource to this value
-  // its "key" is the field on the parent record
-  // its "owner" is the parent record
-
-  const managedArrayMapForRecord = ManagedArrayMap.get(record);
-  let managedArray;
-  if (managedArrayMapForRecord) {
-    managedArray = managedArrayMapForRecord.get(field.name);
-  }
-  if (managedArray) {
-    return managedArray;
-  } else {
-    const rawValue = cache.getRelationship(identifier, field.name);
-    if (!rawValue) {
-      return null;
-    }
-    managedArray = new RelatedCollection({
-      store,
-      type: field.type,
-      identifier,
-      cache,
-      field: legacy ? field : undefined,
-      // we divorce the reference here because ManyArray mutates the target directly
-      // before sending the mutation op to the cache. We may be able to avoid this in the future
-      identifiers: rawValue.data?.slice(),
-      key: field.name,
-      meta: rawValue.meta || null,
-      links: rawValue.links || null,
-      isPolymorphic: field.options.polymorphic ?? false,
-      isAsync: field.options.async ?? false,
-      // TODO: Grab the proper value
-      _inverseIsAsync: false,
-      // @ts-expect-error Typescript doesn't have a way for us to thread the generic backwards so it infers unknown instead of T
-      manager: new ManyArrayManager(record, editable),
-      isLoaded: true,
-      allowMutation: editable
-    });
-    if (!managedArrayMapForRecord) {
-      ManagedArrayMap.set(record, new Map([[field.name, managedArray]]));
-    } else {
-      managedArrayMapForRecord.set(field.name, managedArray);
-    }
-  }
-  return managedArray;
-}
-const IgnoredGlobalFields = new Set(['length', 'nodeType', 'then', 'setInterval', 'document', STRUCTURED]);
-const symbolList = [Destroy, RecordStore, Identifier, Editable, Parent, Checkout, Legacy, EmbeddedPath, EmbeddedField];
-const RecordSymbols = new Set(symbolList);
-function isPathMatch(a, b) {
-  return a.length === b.length && a.every((v, i) => v === b[i]);
-}
-function isNonEnumerableProp(prop) {
-  return prop === 'constructor' || prop === 'prototype' || prop === '__proto__' || prop === 'toString' || prop === 'toJSON' || prop === 'toHTML' || typeof prop === 'symbol';
-}
-const Editables = new WeakMap();
-/**
- * A class that uses a the ResourceSchema for a ResourceType
- * and a ResouceKey to transform data from the cache into a rich, reactive
- * object.
- *
- * This class is not directly instantiable. To use it, you should
- * configure the store's `instantiateRecord` and `teardownRecord` hooks
- * with the matching hooks provided by this package.
- *
- * @hideconstructor
- * @public
- */
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-class ReactiveResource {
-  constructor(store, identifier, Mode, isEmbedded = false, embeddedField = null, embeddedPath = null) {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const self = this;
-    this[RecordStore] = store;
-    if (isEmbedded) {
-      this[Parent] = identifier;
-    } else {
-      this[Identifier] = identifier;
-    }
-    const IS_EDITABLE = this[Editable] = Mode[Editable] ?? false;
-    this[Legacy] = Mode[Legacy] ?? false;
-    const schema = store.schema;
-    const cache = store.cache;
-    const identityField = schema.resource(isEmbedded ? embeddedField : identifier).identity;
-    const BoundFns = new Map();
-
-    // prettier-ignore
-    const extensions = !Mode[Legacy] ? null : isEmbedded ? schema.CAUTION_MEGA_DANGER_ZONE_objectExtensions(embeddedField) : schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(identifier);
-    this[EmbeddedField] = embeddedField;
-    this[EmbeddedPath] = embeddedPath;
-    const fields = isEmbedded ? schema.fields(embeddedField) : schema.fields(identifier);
-    const signals = withSignalStore(this);
-    const proxy = new Proxy(this, {
-      ownKeys() {
-        const identityKey = identityField?.name;
-        const keys = Array.from(fields.keys());
-        if (identityKey) {
-          keys.unshift(identityKey);
-        }
-        return keys;
-      },
-      has(target, prop) {
-        if (prop === Destroy || prop === Checkout) {
-          return true;
-        }
-        return fields.has(prop);
-      },
-      getOwnPropertyDescriptor(target, prop) {
-        const schemaForField = prop === identityField?.name ? identityField : fields.get(prop);
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          if (!test) {
-            throw new Error(`No field named ${String(prop)} on ${identifier.type}`);
-          }
-        })(schemaForField) : {};
-        if (isNonEnumerableProp(prop)) {
-          return {
-            writable: false,
-            enumerable: false,
-            configurable: true
-          };
-        }
-        switch (schemaForField.kind) {
-          case 'derived':
-            return {
-              writable: false,
-              enumerable: true,
-              configurable: true
-            };
-          case '@id':
-            return {
-              writable: identifier.id === null,
-              enumerable: true,
-              configurable: true
-            };
-          case '@local':
-          case 'field':
-          case 'attribute':
-          case 'resource':
-          case 'alias':
-          case 'belongsTo':
-          case 'hasMany':
-          case 'collection':
-          case 'schema-array':
-          case 'array':
-          case 'schema-object':
-          case 'object':
-            return {
-              writable: IS_EDITABLE,
-              enumerable: true,
-              configurable: true
-            };
-          default:
-            return {
-              writable: false,
-              enumerable: false,
-              configurable: false
-            };
-        }
-      },
-      get(target, prop, receiver) {
-        if (RecordSymbols.has(prop)) {
-          if (prop === Destroy) {
-            return () => _DESTROY(receiver);
-          }
-          if (prop === Checkout) {
-            return () => _CHECKOUT(receiver);
-          }
-          return target[prop];
-        }
-        if (prop === Signals) {
-          return signals;
-        }
-
-        // TODO make this a symbol
-        if (prop === '___notifications') {
-          return target.___notifications;
-        }
-
-        // ReactiveResource reserves use of keys that begin with these characters
-        // for its own usage.
-        // _, @, $, *
-
-        const maybeField = prop === identityField?.name ? identityField : fields.get(prop);
-        if (!maybeField) {
-          if (IgnoredGlobalFields.has(prop)) {
-            return undefined;
-          }
-
-          /////////////////////////////////////////////////////////////
-          //// Note these bound function behaviors are essentially ////
-          //// built-in but overrideable derivations.              ////
-          ////                                                     ////
-          //// The bar for this has to be "basic expectations of   ////
-          ///  an object" – very, very high                        ////
-          /////////////////////////////////////////////////////////////
-
-          if (prop === Symbol.toStringTag || prop === 'toString') {
-            let fn = BoundFns.get('toString');
-            if (!fn) {
-              fn = function () {
-                entangleSignal(signals, receiver, '@identity', null);
-                return `Record<${identifier.type}:${identifier.id} (${identifier.lid})>`;
-              };
-              BoundFns.set(prop, fn);
-            }
-            return fn;
-          }
-          if (prop === 'toHTML') {
-            let fn = BoundFns.get('toHTML');
-            if (!fn) {
-              fn = function () {
-                entangleSignal(signals, receiver, '@identity', null);
-                return `<span>Record<${identifier.type}:${identifier.id} (${identifier.lid})></span>`;
-              };
-              BoundFns.set(prop, fn);
-            }
-            return fn;
-          }
-          if (prop === 'toJSON') {
-            let fn = BoundFns.get('toJSON');
-            if (!fn) {
-              fn = function () {
-                const json = {};
-                for (const key in receiver) {
-                  json[key] = receiver[key];
-                }
-                return json;
-              };
-              BoundFns.set(prop, fn);
-            }
-            return fn;
-          }
-          if (prop === Symbol.toPrimitive) return () => null;
-          if (prop === Symbol.iterator) {
-            let fn = BoundFns.get(Symbol.iterator);
-            if (!fn) {
-              fn = function* () {
-                for (const key in receiver) {
-                  yield [key, receiver[key]];
-                }
-              };
-              BoundFns.set(Symbol.iterator, fn);
-            }
-            return fn;
-          }
-          if (prop === 'constructor') {
-            return ReactiveResource;
-          }
-          if (isExtensionProp(extensions, prop)) {
-            return performObjectExtensionGet(receiver, extensions, signals, prop);
-          }
-
-          // too many things check for random symbols
-          if (typeof prop === 'symbol') return undefined;
-          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-            {
-              throw new Error(`No field named ${String(prop)} on ${isEmbedded ? embeddedField.type : identifier.type}`);
-            }
-          })() : {};
-          return undefined;
-        }
-        const field = maybeField.kind === 'alias' ? maybeField.options : maybeField;
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          if (!test) {
-            throw new Error(`Alias fields cannot alias '@id' '@local' '@hash' or 'derived' fields`);
-          }
-        })(maybeField.kind !== 'alias' || !['@id', '@local', '@hash', 'derived'].includes(maybeField.options.kind)) : {};
-        const propArray = isEmbedded ? embeddedPath.slice() : [];
-        // we use the field.name instead of prop here because we want to use the cache-path not
-        // the record path.
-        propArray.push(field.name);
-        // propArray.push(prop as string);
-
-        switch (field.kind) {
-          case '@id':
-            entangleSignal(signals, receiver, '@identity', null);
-            return identifier.id;
-          case '@hash':
-            // TODO pass actual cache value not {}
-            return schema.hashFn(field)({}, field.options ?? null, field.name ?? null);
-          case '@local':
-            {
-              return computeLocal(receiver, field, prop);
-            }
-          case 'field':
-            entangleSignal(signals, receiver, field.name, null);
-            return computeField(schema, cache, target, identifier, field, propArray, IS_EDITABLE);
-          case 'attribute':
-            entangleSignal(signals, receiver, field.name, null);
-            return computeAttribute(cache, identifier, prop, IS_EDITABLE);
-          case 'resource':
-            entangleSignal(signals, receiver, field.name, null);
-            return computeResource(store, cache, target, identifier, field, prop, IS_EDITABLE);
-          case 'derived':
-            return computeDerivation(schema, receiver, identifier, field, prop);
-          case 'schema-array':
-          case 'array':
-            entangleSignal(signals, receiver, field.name, null);
-            return computeArray(store, schema, cache, target, identifier, field, propArray, Mode[Editable], Mode[Legacy]);
-          case 'object':
-            entangleSignal(signals, receiver, field.name, null);
-            return computeObject(schema, cache, target, identifier, field, propArray, Mode[Editable], Mode[Legacy]);
-          case 'schema-object':
-            entangleSignal(signals, receiver, field.name, null);
-            // run transform, then use that value as the object to manage
-            return computeSchemaObject(store, cache, target, identifier, field, propArray, Mode[Legacy], Mode[Editable]);
-          case 'belongsTo':
-            if (field.options.linksMode) {
-              entangleSignal(signals, receiver, field.name, null);
-              const rawValue = IS_EDITABLE ? cache.getRelationship(identifier, field.name) : cache.getRemoteRelationship(identifier, field.name);
-
-              // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-              return rawValue.data ? store.peekRecord(rawValue.data) : null;
-            }
-            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`Can only use belongsTo fields when the resource is in legacy mode`);
-              }
-            })(Mode[Legacy]) : {};
-            entangleSignal(signals, receiver, field.name, null);
-            return schema._kind('@legacy', 'belongsTo').get(store, receiver, identifier, field);
-          case 'hasMany':
-            if (field.options.linksMode) {
-              entangleSignal(signals, receiver, field.name, null);
-              return computeHasMany(store, schema, cache, target, identifier, field, propArray, Mode[Editable], Mode[Legacy]);
-            }
-            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
-              }
-            })(Mode[Legacy]) : {};
-            entangleSignal(signals, receiver, field.name, null);
-            return schema._kind('@legacy', 'hasMany').get(store, receiver, identifier, field);
-          default:
-            throw new Error(`Field '${String(prop)}' on '${identifier.type}' has the unknown kind '${field.kind}'`);
-        }
-      },
-      set(target, prop, value, receiver) {
-        if (!IS_EDITABLE) {
-          const type = isEmbedded ? embeddedField.type : identifier.type;
-          throw new Error(`Cannot set ${String(prop)} on ${type} because the record is not editable`);
-        }
-        const maybeField = prop === identityField?.name ? identityField : fields.get(prop);
-        if (!maybeField) {
-          const type = isEmbedded ? embeddedField.type : identifier.type;
-          if (isExtensionProp(extensions, prop)) {
-            return performExtensionSet(receiver, extensions, signals, prop, value);
-          }
-          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-            {
-              throw new Error(`There is no settable field named ${String(prop)} on ${type}`);
-            }
-          })() : {};
-          return false;
-        }
-        const field = maybeField.kind === 'alias' ? maybeField.options : maybeField;
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          if (!test) {
-            throw new Error(`Alias fields cannot alias '@id' '@local' '@hash' or 'derived' fields`);
-          }
-        })(maybeField.kind !== 'alias' || !['@id', '@local', '@hash', 'derived'].includes(maybeField.options.kind)) : {};
-        const propArray = isEmbedded ? embeddedPath.slice() : [];
-        // we use the field.name instead of prop here because we want to use the cache-path not
-        // the record path.
-        propArray.push(field.name);
-        // propArray.push(prop as string);
-
-        switch (field.kind) {
-          case '@id':
-            {
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error(`Expected to receive a string id`);
-                }
-              })(typeof value === 'string' && value.length) : {};
-              const normalizedId = String(value);
-              const didChange = normalizedId !== identifier.id;
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error(`Cannot set ${identifier.type} record's id to ${normalizedId}, because id is already ${identifier.id}`);
-                }
-              })(!didChange || identifier.id === null) : {};
-              if (normalizedId !== null && didChange) {
-                store._instanceCache.setRecordId(identifier, normalizedId);
-                store.notifications.notify(identifier, 'identity');
-              }
-              return true;
-            }
-          case '@local':
-            {
-              const signal = getOrCreateInternalSignal(signals, receiver, prop, field.options?.defaultValue ?? null);
-              if (signal.value !== value) {
-                signal.value = value;
-                notifyInternalSignal(signal);
-              }
-              return true;
-            }
-          case 'field':
-            {
-              if (!field.type) {
-                cache.setAttr(identifier, propArray, value);
-                return true;
-              }
-              const transform = schema.transformation(field);
-              const rawValue = transform.serialize(value, field.options ?? null, target);
-              cache.setAttr(identifier, propArray, rawValue);
-              return true;
-            }
-          case 'attribute':
-            {
-              cache.setAttr(identifier, propArray, value);
-              return true;
-            }
-          case 'array':
-            {
-              if (!field.type) {
-                cache.setAttr(identifier, propArray, value?.slice());
-                const peeked = peekManagedArray(self, field);
-                if (peeked) {
-                  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                    if (!test) {
-                      throw new Error(`Expected the peekManagedArray for ${field.kind} to return a ManagedArray`);
-                    }
-                  })(ARRAY_SIGNAL in peeked) : {};
-                  const arrSignal = peeked[ARRAY_SIGNAL];
-                  arrSignal.isStale = true;
-                }
-                if (!Array.isArray(value)) {
-                  ManagedArrayMap.delete(target);
-                }
-                return true;
-              }
-              const transform = schema.transformation(field);
-              const rawValue = value.map(item => transform.serialize(item, field.options ?? null, target));
-              cache.setAttr(identifier, propArray, rawValue);
-              const peeked = peekManagedArray(self, field);
-              if (peeked) {
-                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                  if (!test) {
-                    throw new Error(`Expected the peekManagedArray for ${field.kind} to return a ManagedArray`);
-                  }
-                })(ARRAY_SIGNAL in peeked) : {};
-                const arrSignal = peeked[ARRAY_SIGNAL];
-                arrSignal.isStale = true;
-              }
-              return true;
-            }
-          case 'schema-array':
-            {
-              const arrayValue = value?.slice();
-              if (!Array.isArray(arrayValue)) {
-                ManagedArrayMap.delete(target);
-              }
-              cache.setAttr(identifier, propArray, arrayValue);
-              const peeked = peekManagedArray(self, field);
-              if (peeked) {
-                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                  if (!test) {
-                    throw new Error(`Expected the peekManagedArray for ${field.kind} to return a ManagedArray`);
-                  }
-                })(ARRAY_SIGNAL in peeked) : {};
-                const arrSignal = peeked[ARRAY_SIGNAL];
-                arrSignal.isStale = true;
-              }
-              if (!Array.isArray(value)) {
-                ManagedArrayMap.delete(target);
-              }
-              return true;
-            }
-          case 'object':
-            {
-              if (!field.type) {
-                let newValue = value;
-                if (value !== null) {
-                  newValue = {
-                    ...value
-                  };
-                } else {
-                  ManagedObjectMap.delete(target);
-                }
-                cache.setAttr(identifier, propArray, newValue);
-                const peeked = peekManagedObject(self, field);
-                if (peeked) {
-                  const objSignal = peeked[OBJECT_SIGNAL];
-                  objSignal.isStale = true;
-                }
-                return true;
-              }
-              const transform = schema.transformation(field);
-              const rawValue = transform.serialize({
-                ...value
-              }, field.options ?? null, target);
-              cache.setAttr(identifier, propArray, rawValue);
-              const peeked = peekManagedObject(self, field);
-              if (peeked) {
-                const objSignal = peeked[OBJECT_SIGNAL];
-                objSignal.isStale = true;
-              }
-              return true;
-            }
-          case 'schema-object':
-            {
-              let newValue = value;
-              if (value !== null) {
-                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                  if (!test) {
-                    throw new Error(`Expected value to be an object`);
-                  }
-                })(typeof value === 'object') : {};
-                newValue = {
-                  ...value
-                };
-                const schemaFields = schema.fields({
-                  type: field.type
-                });
-                for (const key of Object.keys(newValue)) {
-                  if (!schemaFields.has(key)) {
-                    throw new Error(`Field ${key} does not exist on schema object ${field.type}`);
-                  }
-                }
-              } else {
-                ManagedObjectMap.delete(target);
-              }
-              cache.setAttr(identifier, propArray, newValue);
-              // const peeked = peekManagedObject(self, field);
-              // if (peeked) {
-              //   const objSignal = peeked[OBJECT_SIGNAL];
-              //   objSignal.isStale = true;
-              // }
-              return true;
-            }
-          case 'derived':
-            {
-              throw new Error(`Cannot set ${String(prop)} on ${identifier.type} because it is derived`);
-            }
-          case 'belongsTo':
-            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`Can only use belongsTo fields when the resource is in legacy mode`);
-              }
-            })(Mode[Legacy]) : {};
-            schema._kind('@legacy', 'belongsTo').set(store, receiver, identifier, field, value);
-            return true;
-          case 'hasMany':
-            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
-              }
-            })(Mode[Legacy]) : {};
-            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`You must pass an array of records to set a hasMany relationship`);
-              }
-            })(Array.isArray(value)) : {};
-            schema._kind('@legacy', 'hasMany').set(store, receiver, identifier, field, value);
-            return true;
-          default:
-            throw new Error(`Unknown field kind ${field.kind}`);
-        }
-      }
-    });
-
-    // what signal do we need for embedded record?
-    this.___notifications = store.notifications.subscribe(identifier, (_, type, key) => {
-      switch (type) {
-        case 'identity':
-          {
-            if (isEmbedded || !identityField) return; // base paths never apply to embedded records
-
-            if (identityField.name && identityField.kind === '@id') {
-              const signal = signals.get('@identity');
-              if (signal) {
-                notifyInternalSignal(signal);
-              }
-            }
-            break;
-          }
-        case 'attributes':
-          if (key) {
-            if (Array.isArray(key)) {
-              if (!isEmbedded) return; // deep paths will be handled by embedded records
-              // TODO we should have the notification manager
-              // ensure it is safe for each callback to mutate this array
-              if (isPathMatch(embeddedPath, key)) {
-                // handle the notification
-                // TODO we should likely handle this notification here
-                // also we should add a LOGGING flag
-                // eslint-disable-next-line no-console
-                console.warn(`Notification unhandled for ${key.join(',')} on ${identifier.type}`, self);
-                return;
-              }
-
-              // TODO we should add a LOGGING flag
-              // console.log(`Deep notification skipped for ${key.join('.')} on ${identifier.type}`, self);
-              // deep notify the key path
-            } else {
-              if (isEmbedded) return; // base paths never apply to embedded records
-
-              // TODO determine what LOGGING flag to wrap this in if any
-              // console.log(`Notification for ${key} on ${identifier.type}`, self);
-              const signal = signals.get(key);
-              if (signal) {
-                notifyInternalSignal(signal);
-              }
-              const field = fields.get(key);
-              if (field?.kind === 'array' || field?.kind === 'schema-array') {
-                const peeked = peekManagedArray(self, field);
-                if (peeked) {
-                  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                    if (!test) {
-                      throw new Error(`Expected the peekManagedArray for ${field.kind} to return a ManagedArray`);
-                    }
-                  })(ARRAY_SIGNAL in peeked) : {};
-                  const arrSignal = peeked[ARRAY_SIGNAL];
-                  notifyInternalSignal(arrSignal);
-                }
-              }
-              if (field?.kind === 'object') {
-                const peeked = peekManagedObject(self, field);
-                if (peeked) {
-                  const objSignal = peeked[OBJECT_SIGNAL];
-                  notifyInternalSignal(objSignal);
-                }
-              }
-            }
-          }
-          break;
-        case 'relationships':
-          if (key) {
-            if (Array.isArray(key)) ;else {
-              if (isEmbedded) return; // base paths never apply to embedded records
-
-              const field = fields.get(key);
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error(`Expected relationshp ${key} to be the name of a field`);
-                }
-              })(field) : {};
-              if (field.kind === 'belongsTo') {
-                // TODO determine what LOGGING flag to wrap this in if any
-                // console.log(`Notification for ${key} on ${identifier.type}`, self);
-                const signal = signals.get(key);
-                if (signal) {
-                  notifyInternalSignal(signal);
-                }
-                // FIXME
-              } else if (field.kind === 'resource') ;else if (field.kind === 'hasMany') {
-                if (field.options.linksMode) {
-                  const peeked = peekManagedArray(self, field);
-                  if (peeked) {
-                    notifyInternalSignal(peeked[ARRAY_SIGNAL]);
-                  }
-                  return;
-                }
-                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                  if (!test) {
-                    throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
-                  }
-                })(Mode[Legacy]) : {};
-                if (schema._kind('@legacy', 'hasMany').notify(store, proxy, identifier, field)) {
-                  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                    if (!test) {
-                      throw new Error(`Expected options to exist on relationship meta`);
-                    }
-                  })(field.options) : {};
-                  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                    if (!test) {
-                      throw new Error(`Expected async to exist on relationship meta options`);
-                    }
-                  })('async' in field.options) : {};
-                  if (field.options.async) {
-                    const signal = signals.get(key);
-                    if (signal) {
-                      notifyInternalSignal(signal);
-                    }
-                  }
-                }
-              } else if (field.kind === 'collection') ;
-            }
-          }
-          break;
-      }
-    });
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      Object.defineProperty(this, '__SHOW_ME_THE_DATA_(debug mode only)__', {
-        enumerable: false,
-        configurable: true,
-        get() {
-          const data = {};
-          for (const key of fields.keys()) {
-            data[key] = proxy[key];
-          }
-          return data;
-        }
-      });
-    }
-    return proxy;
-  }
-}
-function _CHECKOUT(record) {
-  // IF we are already the editable record, throw an error
-  if (record[Editable]) {
-    throw new Error(`Cannot checkout an already editable record`);
-  }
-  const editable = Editables.get(record);
-  if (editable) {
-    return Promise.resolve(editable);
-  }
-  const embeddedType = record[EmbeddedField];
-  const embeddedPath = record[EmbeddedPath];
-  const isEmbedded = embeddedType !== null && embeddedPath !== null;
-  if (isEmbedded) {
-    throw new Error(`Cannot checkout an embedded record (yet)`);
-  }
-  const editableRecord = new ReactiveResource(record[RecordStore], record[Identifier], {
-    [Editable]: true,
-    [Legacy]: record[Legacy]
-  }, isEmbedded, embeddedType, embeddedPath);
-  setRecordIdentifier(editableRecord, recordIdentifierFor(record));
-  return Promise.resolve(editableRecord);
-}
-function _DESTROY(record) {
-  if (record[Legacy]) {
-    // @ts-expect-error
-    record.isDestroying = true;
-    // @ts-expect-error
-    record.isDestroyed = true;
-  }
-  record[RecordStore].notifications.unsubscribe(record.___notifications);
-}
+import { Type } from './types/symbols.js';
 function instantiateRecord(store, identifier, createArgs) {
   const schema = store.schema;
   const resourceSchema = schema.resource(identifier);
@@ -1405,13 +19,19 @@ function instantiateRecord(store, identifier, createArgs) {
       throw new Error(`Expected a resource schema`);
     }
   })(isResourceSchema(resourceSchema)) : {};
-  const isLegacy = resourceSchema?.legacy ?? false;
-  const isEditable = isLegacy || store.cache.isNew(identifier);
-  const record = new ReactiveResource(store, identifier, {
-    [Editable]: isEditable,
-    [Legacy]: isLegacy
+  const legacy = resourceSchema?.legacy ?? false;
+  const editable = legacy;
+  const record = new ReactiveResource({
+    store,
+    resourceKey: identifier,
+    modeName: legacy ? 'legacy' : 'polaris',
+    legacy: legacy,
+    editable: editable,
+    path: null,
+    field: null,
+    value: null
   });
-  if (createArgs) {
+  if (createArgs && editable) {
     Object.assign(record, createArgs);
   }
   return record;
@@ -1546,7 +166,7 @@ function getExt(extCache, type, extName) {
 function hasObjectSchema(field) {
   return 'kind' in field && (field.kind === 'schema-array' || field.kind === 'schema-object');
 }
-function processExtensions(schema, field, scenario) {
+function processExtensions(schema, field, scenario, resolvedType) {
   // if we're looking up extensions for a resource, there is no
   // merging required so if we have no objectExtensions
   // we are done.
@@ -1573,12 +193,16 @@ function processExtensions(schema, field, scenario) {
     if (!hasObjectSchema(field)) {
       return null;
     }
-    return schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(field);
+    return schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resolvedType ? {
+      type: resolvedType
+    } : field);
   }
 
   // if we have made it here, we have extensions, lets check if there's
   // a cached version we can use
-  const baseExtensions = scenario === 'resource' && hasObjectSchema(field) ? schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(field) : scenario === 'object' && hasObjectSchema(field) ? schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(field) : null;
+  const baseExtensions = scenario === 'resource' && hasObjectSchema(field) ? schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(field) : scenario === 'object' && hasObjectSchema(field) ? schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resolvedType ? {
+    type: resolvedType
+  } : field) : null;
   if (!baseExtensions && extensions.length === 1) {
     const value = getExt(extCache, type, extensions[0]);
     fieldCache[type].set(field, value);
@@ -1646,7 +270,8 @@ function withDefaults(schema) {
  * @public
  */
 const fromIdentity = (record, options, key) => {
-  const identifier = record[Identifier];
+  const context = record[Context];
+  const identifier = context.resourceKey;
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
     if (!test) {
       throw new Error(`Cannot compute @identity for a record without an identifier`);
@@ -1670,7 +295,6 @@ fromIdentity[Type] = '@identity';
  * ```
  *
  * @public
- * @param {SchemaService} schema
  */
 function registerDerivations(schema) {
   schema.registerDerivation(fromIdentity);
@@ -1687,10 +311,9 @@ function makeCachedDerivation(derivation) {
     const signals = withSignalStore(record);
     let signal = signals.get(prop);
     if (!signal) {
-      signal = createMemo(record, prop, () => {
+      signal = createInternalMemo(signals, record, prop, () => {
         return derivation(record, options, prop);
       }); // a total lie, for convenience of reusing the storage
-      signals.set(prop, signal);
     }
     return signal();
   };
@@ -1700,7 +323,6 @@ function makeCachedDerivation(derivation) {
 /**
  * A SchemaService designed to work with dynamically registered schemas.
  *
- * @class SchemaService
  * @public
  */
 class SchemaService {
@@ -1719,12 +341,14 @@ class SchemaService {
 
   /** @internal */
 
+  /** @internal */
+
   constructor() {
     this._schemas = new Map();
     this._transforms = new Map();
     this._hashFns = new Map();
     this._derivations = new Map();
-    this._traits = new Set();
+    this._traits = new Map();
     this._modes = new Map();
     this._extensions = {
       object: new Map(),
@@ -1821,7 +445,7 @@ class SchemaService {
     const fields = new Map();
     const relationships = {};
     const attributes = {};
-    schema.fields.forEach(field => {
+    for (const field of schema.fields) {
       macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
         if (!test) {
           throw new Error(`${field.kind} is not valid inside a ResourceSchema's fields.`);
@@ -1835,20 +459,62 @@ class SchemaService {
       } else if (field.kind === 'belongsTo' || field.kind === 'hasMany') {
         relationships[field.name] = field;
       }
-    });
+    }
+    const cacheFields = null;
     const traits = new Set(isResourceSchema(schema) ? schema.traits : []);
-    traits.forEach(trait => {
-      this._traits.add(trait);
-    });
+    const finalized = traits.size === 0;
     const internalSchema = {
       original: schema,
+      finalized,
       fields,
+      cacheFields,
       relationships,
       attributes,
       traits
     };
+    if (traits.size === 0) {
+      internalSchema.cacheFields = getCacheFields(internalSchema);
+    }
     this._schemas.set(schema.type, internalSchema);
   }
+
+  /**
+   * Registers a {@link Trait} for use by resource schemas.
+   *
+   * Traits are re-usable collections of fields that can be composed to
+   * build up a resource schema. Often they represent polymorphic behaviors
+   * a resource should exhibit.
+   *
+   * When we finalize a resource, we walk its traits and apply their fields
+   * to the resource's fields. All specified traits must be registered by
+   * this time or an error will be thrown.
+   *
+   * Traits are applied left-to-right, with traits of traits being applied in the same
+   * way. Thus for the most part, application of traits is a post-order graph traversal
+   * problem.
+   *
+   * A trait is only ever processed once. If multiple traits (A, B, C) have the same
+   * trait (D) as a dependency, D will be included only once when first encountered by
+   * A.
+   *
+   * If a cycle exists such that trait A has trait B which has Trait A, trait A will
+   * be applied *after* trait B in production. In development a cycle error will be thrown.
+   *
+   * Fields are finalized on a "last wins principle". Thus traits appearing higher in
+   * the tree and further to the right of a traits array take precedence, with the
+   * resource's fields always being applied last and winning out.
+   *
+   * @public
+   */
+  registerTrait(trait) {
+    const internalTrait = Object.assign({}, trait, {
+      fields: new Map()
+    });
+    for (const field of trait.fields) {
+      internalTrait.fields.set(field.name, field);
+    }
+    this._traits.set(trait.name, internalTrait);
+  }
   registerTransformation(transformation) {
     this._transforms.set(transformation[Type], transformation);
   }
@@ -1865,13 +531,16 @@ class SchemaService {
   }
   CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource) {
     const schema = this.resource(resource);
-    return processExtensions(this, schema, 'resource');
+    return processExtensions(this, schema, 'resource', null);
   }
-  CAUTION_MEGA_DANGER_ZONE_objectExtensions(field) {
-    return processExtensions(this, field, 'object');
+  CAUTION_MEGA_DANGER_ZONE_objectExtensions(field, resolvedType) {
+    return processExtensions(this, field, 'object', resolvedType);
   }
   CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field) {
-    return processExtensions(this, field, 'array');
+    return processExtensions(this, field, 'array', null);
+  }
+  CAUTION_MEGA_DANGER_ZONE_hasExtension(ext) {
+    return this._extensions[ext.kind].has(ext.name);
   }
 
   /**
@@ -1919,6 +588,13 @@ class SchemaService {
     })(kinds[kind]) : {};
     return kinds[kind];
   }
+
+  /**
+   * Registers a {@link HashFn} for use with a {@link HashField} for
+   * either {@link ObjectSchema} identity or polymorphic type calculation.
+   *
+   * @public
+   */
   registerHashFn(hashFn) {
     this._hashFns.set(hashFn[Type], hashFn);
   }
@@ -1926,11 +602,30 @@ class SchemaService {
     type
   }) {
     const schema = this._schemas.get(type);
-    if (!schema) {
-      throw new Error(`No schema defined for ${type}`);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`No schema defined for ${type}`);
+      }
+    })(schema) : {};
+    if (!schema.finalized) {
+      finalizeResource(this, schema);
     }
     return schema.fields;
   }
+  cacheFields({
+    type
+  }) {
+    const schema = this._schemas.get(type);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`No schema defined for ${type}`);
+      }
+    })(schema) : {};
+    if (!schema.finalized) {
+      finalizeResource(this, schema);
+    }
+    return schema.cacheFields;
+  }
   hasResource(resource) {
     return this._schemas.has(resource.type);
   }
@@ -1985,4 +680,224 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_SCHEMA
     return this._schemas.has(type);
   };
 }
-export { Checkout, SchemaService, fromIdentity, instantiateRecord, registerDerivations, teardownRecord, withDefaults };
+
+/**
+ * When we finalize a resource, we walk its traits and apply their fields
+ * to the resource's fields.
+ *
+ * Traits are applied left-to-right, with traits of traits being applied in the same
+ * way. Thus for the most part, application of traits is a post-order graph traversal
+ * problem.
+ *
+ * A trait is only ever processed once. If multiple traits (A, B, C) have the same
+ * trait (D) as a dependency, D will be included only once when first encountered by
+ * A.
+ *
+ * If a cycle exists such that trait A has trait B which has Trait A, trait A will
+ * be applied *after* trait B in production. In development a cycle error will be thrown.
+ *
+ * Fields are finalized on a "last wins principle". Thus traits appearing higher in
+ * the tree and further to the right of a traits array take precedence, with the
+ * resource's fields always being applied last and winning out.
+ */
+function finalizeResource(schema, resource) {
+  const fields = new Map();
+  const seen = new Set();
+  for (const traitName of resource.traits) {
+    const trait = schema._traits.get(traitName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`The trait ${traitName} MUST be supplied before the resource ${resource.original.type} can be finalized for use.`);
+      }
+    })(trait) : {};
+    walkTrait(schema, trait, fields, seen, resource.original.type, macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? [] : null);
+  }
+  mergeMap(fields, resource.fields);
+  resource.fields = fields;
+  resource.cacheFields = getCacheFields(resource);
+  resource.finalized = true;
+}
+function getCacheFields(resource) {
+  const {
+    fields
+  } = resource;
+  const cacheFields = new Map();
+  for (const [key, value] of fields) {
+    if (isNonIdentityCacheableField(value)) {
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`The sourceKey '${value.sourceKey}' for the field '${key}' on ${resource.original.type} is invalid because it matches the name of an existing field`);
+        }
+      })(!value.sourceKey || value.sourceKey === key || !fields.has(value.sourceKey)) : {};
+      const cacheKey = getFieldCacheKeyStrict(value);
+      cacheFields.set(cacheKey, value);
+    }
+  }
+  return cacheFields;
+}
+function walkTrait(schema, trait, fields, seen, type, debugPath) {
+  if (seen.has(trait)) {
+    // if the trait is in the current path, we throw a cycle error in dev.
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+      if (debugPath.includes(trait.name)) {
+        throw new Error(`CycleError: The Trait '${trait.name}' utilized by the Resource '${type}' includes the following circular reference "${debugPath.join(' > ')} > ${trait.name}"`);
+      }
+    }
+    return;
+  }
+  const ownPath = macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? [...debugPath, trait.name] : null;
+
+  // immediately mark as seen to prevent cycles
+  // further down the tree from looping back
+  seen.add(trait);
+
+  // first apply any child traits
+  if (trait.traits?.length) {
+    for (const traitName of trait.traits) {
+      const subtrait = schema._traits.get(traitName);
+      if (macroCondition(getGlobalConfig().WarpDrive.features.ENFORCE_STRICT_RESOURCE_FINALIZATION)) {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`The trait ${traitName} used by the trait ${trait.name} MUST be supplied before the resource ${type} can be finalized for use.`);
+          }
+        })(subtrait) : {};
+      } else {
+        warn(`The trait ${traitName} used by the trait ${trait.name} MUST be supplied before the resource ${type} can be finalized for use.`, !!subtrait, {
+          id: 'warp-drive:missing-trait-schema-for-resource'
+        });
+      }
+      if (!subtrait) continue;
+      walkTrait(schema, subtrait, fields, seen, type, ownPath);
+    }
+  }
+
+  // then apply our own fields
+  mergeMap(fields, trait.fields);
+}
+function mergeMap(base, toApply) {
+  for (const [key, value] of toApply) {
+    base.set(key, value);
+  }
+}
+const Subscriptions = new WeakMap();
+
+/**
+ * `ExpensiveSubscription` is a mechanism for non-reactive
+ * frameworks such as `react` to integrate with WarpDrive.
+ *
+ * This mechanism should never be used by frameworks or libraries
+ * that support fine-grained reactivity.
+ *
+ * ExpensiveSubscription is expensive *because* it doubles the number
+ * of notification callbacks required for each resource contained in
+ * the request being subscribed to. The more requests in-use, the more
+ * this cost adds up.
+ */
+class ExpensiveSubscription {
+  constructor(store, request) {
+    this._store = store;
+    this._request = request;
+    this._callbacks = new Set();
+    this._resources = new Map();
+    this._subscription = store.notifications.subscribe(request, this._notifyRequestChange);
+    this._updateResourceCallbacks();
+  }
+  _updateResourceCallbacks() {
+    const request = this._request;
+    const store = this._store;
+    const {
+      notifications
+    } = store;
+    const req = store.cache.peek(request);
+    const resources = this._resources;
+    const isInitialSubscription = resources.size === 0;
+    if (req && 'data' in req) {
+      if (Array.isArray(req.data)) {
+        for (const resourceKey of req.data) {
+          if (isInitialSubscription || !resources.has(resourceKey)) {
+            resources.set(resourceKey, notifications.subscribe(resourceKey, this._scheduleNotify));
+          }
+        }
+      } else if (req.data) {
+        if (isInitialSubscription || !resources.has(req.data)) {
+          resources.set(req.data, notifications.subscribe(req.data, this._scheduleNotify));
+        }
+      }
+    }
+    if (req && 'included' in req && Array.isArray(req.included)) {
+      for (const resourceKey of req.included) {
+        if (isInitialSubscription || !resources.has(resourceKey)) {
+          resources.set(resourceKey, notifications.subscribe(resourceKey, this._scheduleNotify));
+        }
+      }
+    }
+  }
+  _notifyRequestChange = () => {
+    this._updateResourceCallbacks();
+    this._scheduleNotify();
+  };
+  _scheduleNotify = () => {
+    this._notify = this._notify || Promise.resolve().then(() => {
+      for (const callback of this._callbacks) {
+        callback();
+      }
+      this._notify = null;
+    });
+  };
+  addWatcher(callback) {
+    this._callbacks.add(callback);
+  }
+  removeWatcher(callback) {
+    this._callbacks.delete(callback);
+    if (this._callbacks.size === 0) {
+      this.destroy();
+    }
+  }
+  destroy() {
+    Subscriptions.delete(this._request);
+    const {
+      notifications
+    } = this._store;
+    if (this._subscription) {
+      notifications.unsubscribe(this._subscription);
+    }
+    for (const token of this._resources.values()) {
+      notifications.unsubscribe(token);
+    }
+    this._callbacks.clear();
+    this._resources.clear();
+  }
+}
+
+/**
+ * Creates an {@link ExpensiveSubscription} for the {@link RequestKey}
+ * if one does not already exist and adds a watcher to it.
+ *
+ * Returns a cleanup function. This should be called on-mount by a component
+ * that wants to subscribe to a request and cleanup should be called on dismount.
+ *
+ * ::: warning ⚠️ Avoid Using If Your App Supports Fine-grained Reactivity
+ * This mechanism should never be used by frameworks or libraries
+ * that support fine-grained reactivity.
+ * :::
+ *
+ * `ExpensiveSubscription` is a mechanism for non-reactive
+ * frameworks such as `react` to integrate with WarpDrive, for instance
+ * by treating a request as an [external store](https://react.dev/reference/react/useSyncExternalStore)
+ *
+ * `ExpensiveSubscription` is expensive *because* it doubles the number
+ * of notification callbacks required for each resource contained in
+ * the request being subscribed to. The more requests in-use, the more
+ * this cost adds up.
+ */
+function getExpensiveRequestSubscription(store, requestKey, callback) {
+  let subscription = Subscriptions.get(requestKey);
+  if (!subscription) {
+    subscription = new ExpensiveSubscription(store, requestKey);
+  }
+  subscription.addWatcher(callback);
+  return () => {
+    subscription.removeWatcher(callback);
+  };
+}
+export { SchemaService, fromIdentity, getExpensiveRequestSubscription, instantiateRecord, registerDerivations, teardownRecord, withDefaults };