@warp-drive/core 5.7.0-alpha.0 → 5.7.0-alpha.10

package/dist/reactive.js

@@ -1,14 +1,29 @@
 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 { F as withSignalStore, T as isExtensionProp, U as performExtensionSet, H as consumeInternalSignal, V as performArrayExtensionGet, x as entangleSignal, E as peekInternalSignal, d as SOURCE$1, f as fastPush, l as RelatedCollection, J as getOrCreateInternalSignal, G as notifyInternalSignal, W as performObjectExtensionGet, y as defineSignal, B as Signals, h as setRecordIdentifier, r as recordIdentifierFor } from "./request-state-CeN66aML.js";
 import { EnableHydration, STRUCTURED } from './types/request.js';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
-import { deprecate } from '@ember/debug';
+import { warn, deprecate } from '@ember/debug';
 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 { S as SOURCE, E as Editable, L as Legacy, D as Destroy, I as Identifier, P as Parent, a as EmbeddedPath, C as Checkout, b as EmbeddedField } from "./symbols-SIstXMLI.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';
+function getAliasField(context) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    {
+      throw new Error(`Alias field access is not implemented`);
+    }
+  })() : {};
+}
+function setAliasField(context) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    {
+      throw new Error(`Alias field setting is not implemented`);
+    }
+  })() : {};
+  return false;
+}
 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']);
@@ -55,21 +70,27 @@ function safeForEach(instance, arr, store, callback, target) {
 }
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
 class ManagedArray {
-  constructor(store, schema, cache, field, data, identifier, path, owner, isSchemaArray, editable, legacy) {
+  constructor(context, owner, data) {
     // 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 IS_EDITABLE = this[Editable] = context.editable ?? false;
+    this[Legacy] = context.legacy;
+    const schema = context.store.schema;
+    const cache = context.store.cache;
+    const {
+      field
+    } = context;
     const signals = withSignalStore(this);
     let _SIGNAL = null;
     const boundFns = new Map();
-    this.identifier = identifier;
-    this.path = path;
+    this.identifier = context.resourceKey;
+    this.path = context.path;
     this.owner = owner;
     let transaction = false;
-    const mode = field.options?.key ?? '@identity';
-    const RefStorage = mode === '@identity' ? WeakMap :
+    const KeyMode = field.options?.key ?? '@identity';
+    // listener.
+    const RefStorage = KeyMode === '@identity' ? WeakMap :
     // CAUTION CAUTION CAUTION
     // this is a pile of lies
     // the Map is Map<string, WeakRef<ReactiveResource>>
@@ -77,8 +98,8 @@ class ManagedArray {
     // 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 ManagedRecordRefs = field.kind === 'schema-array' ? new RefStorage() : null;
+    const extensions = context.legacy ? schema.CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field) : null;
     const proxy = new Proxy(this[SOURCE], {
       get(target, prop, receiver) {
         if (prop === ARRAY_SIGNAL) {
@@ -93,7 +114,7 @@ class ManagedArray {
         const index = convertToInt(prop);
         if (_SIGNAL.isStale && (index !== null || SYNC_PROPS.has(prop) || isArrayGetter(prop))) {
           _SIGNAL.isStale = false;
-          const newData = cache.getAttr(identifier, path);
+          const newData = cache.getAttr(context.resourceKey, context.path);
           if (newData && newData !== self[SOURCE]) {
             self[SOURCE].length = 0;
             self[SOURCE].push(...newData);
@@ -104,14 +125,72 @@ class ManagedArray {
         }
         if (prop === '[]') return consumeInternalSignal(_SIGNAL), receiver;
         if (index !== null) {
-          let val;
-          if (mode === '@hash') {
-            val = target[index];
+          if (!transaction) {
+            consumeInternalSignal(_SIGNAL);
+          }
+          const rawValue = target[index];
+          if (field.kind === 'array') {
+            if (field.type) {
+              const transform = schema.transformation(field);
+              return transform.hydrate(rawValue, field.options ?? null, self.owner);
+            }
+            return rawValue;
+          }
+
+          /**
+           * When the array is polymorphic, we need to determine the real type
+           * in order to apply the correct identity as schema-object identity
+           * is only required to be unique by type
+           */
+          let objectType;
+          if (field.options?.polymorphic) {
+            const typePath = field.options.type ?? 'type';
+            // if we are polymorphic, then context.field.options.type will
+            // either specify a path on the rawValue to use as the type, defaulting to "type" or
+            // the special string "@hash" which tells us to treat field.type as a hashFn name with which
+            // to calc the type.
+            if (typePath === '@hash') {
+              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                if (!test) {
+                  throw new Error(`Expected the field to define a hashFn as its type`);
+                }
+              })(field.type) : {};
+              const hashFn = schema.hashFn({
+                type: field.type
+              });
+              // TODO consider if there are better options and name args we could provide.
+              objectType = hashFn(rawValue, null, null);
+            } else {
+              objectType = rawValue[typePath];
+              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                if (!test) {
+                  throw new Error(`Expected the type path for the field to be a value on the raw object`);
+                }
+              })(typePath && objectType && typeof objectType === 'string') : {};
+            }
+          } else {
+            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              if (!test) {
+                throw new Error(`A non-polymorphic SchemaArrayField must provide a SchemaObject type in its definition`);
+              }
+            })(field.type) : {};
+            objectType = field.type;
+          }
+
+          /**
+           * When KeyMode=@hash the ReactiveResource is keyed into
+           * ManagedRecordRefs by the return value of @hash on the rawValue.
+           *
+           * This means that we could find a way to only recompute the identity
+           * when ARRAY_SIGNAL is dirty if hash performance becomes a bottleneck.
+           */
+          let schemaObjectKeyValue;
+          if (KeyMode === '@hash') {
             const hashField = schema.resource({
-              type: field.type
+              type: objectType
             }).identity;
             const hashFn = schema.hashFn(hashField);
-            val = hashFn(val, null, null);
+            schemaObjectKeyValue = hashFn(rawValue, hashField.options ?? null, hashField.name);
           } else {
             // if mode is not @identity or @index, then access the key path.
             // we should assert that `mode` is a string
@@ -119,69 +198,78 @@ class ManagedArray {
             // 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));
+            if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+              const isPathKeyMode = KeyMode !== '@identity' && KeyMode !== '@index';
+              if (isPathKeyMode) {
+                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                  if (!test) {
+                    throw new Error('mode must be a string');
+                  }
+                })(typeof KeyMode === 'string' && KeyMode !== '') : {};
+                const modeField = schema.fields({
+                  type: objectType
+                }).get(KeyMode);
+                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') : {};
               }
-              return record;
             }
-            return val;
+            schemaObjectKeyValue = KeyMode === '@identity' ? rawValue : KeyMode === '@index' ? index : rawValue[KeyMode];
           }
-          if (!transaction) {
-            consumeInternalSignal(_SIGNAL);
+          if (!schemaObjectKeyValue) {
+            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              {
+                throw new Error(`Unexpected out of bounds access on SchemaArray`);
+              }
+            })() : {};
+            return undefined;
           }
-          if (field.type) {
-            const transform = schema.transformation(field);
-            return transform.hydrate(val, field.options ?? null, self.owner);
+          const recordRef = ManagedRecordRefs.get(schemaObjectKeyValue);
+          const record = recordRef?.value.deref();
+
+          // confirm the type and key still match
+          if (record && recordRef.type === objectType && recordRef.identity === schemaObjectKeyValue) {
+            if (recordRef.index !== index) {
+              recordRef.index = index;
+              recordRef.context.path[recordRef.context.path.length - 1] = index;
+            }
+            return record;
+          } else if (record) {
+            // TODO schedule idle once we can
+            void Promise.resolve().then(() => {
+              record[Destroy]();
+            });
           }
-          return val;
+          const recordPath = context.path.slice();
+          // this is a dirty lie since path is string[] but really we
+          // should change the types for paths to `Array<string | number>`
+          recordPath.push(index);
+          const objectContext = {
+            store: context.store,
+            resourceKey: context.resourceKey,
+            modeName: context.modeName,
+            legacy: context.legacy,
+            editable: context.editable,
+            path: recordPath,
+            field: field,
+            value: objectType
+          };
+          const schemaObject = new ReactiveResource(objectContext);
+          ManagedRecordRefs.set(schemaObjectKeyValue, {
+            type: objectType,
+            identity: schemaObjectKeyValue,
+            index,
+            context: objectContext,
+            value: new WeakRef(schemaObject)
+          });
+          return schemaObject;
         }
         if (isArrayGetter(prop)) {
           let fn = boundFns.get(prop);
@@ -190,7 +278,7 @@ class ManagedArray {
               fn = function () {
                 consumeInternalSignal(_SIGNAL);
                 transaction = true;
-                const result = safeForEach(receiver, target, store, arguments[0], arguments[1]);
+                const result = safeForEach(receiver, target, context.store, arguments[0], arguments[1]);
                 transaction = false;
                 return result;
               };
@@ -233,9 +321,9 @@ class ManagedArray {
       },
       set(target, prop, value, receiver) {
         if (!IS_EDITABLE) {
-          let errorPath = identifier.type;
-          if (path) {
-            errorPath = path[path.length - 1];
+          let errorPath = context.resourceKey.type;
+          if (context.path) {
+            errorPath = context.path[context.path.length - 1];
           }
           throw new Error(`Cannot set ${String(prop)} on ${errorPath} because the record is not editable`);
         }
@@ -253,19 +341,19 @@ class ManagedArray {
         const reflect = Reflect.set(target, prop, value, receiver);
         if (reflect) {
           if (!field.type) {
-            cache.setAttr(identifier, path, self[SOURCE]);
+            cache.setAttr(context.resourceKey, context.path, self[SOURCE]);
             _SIGNAL.isStale = true;
             return true;
           }
           let rawValue = self[SOURCE];
-          if (!isSchemaArray) {
+          if (field.kind !== 'schema-array') {
             const transform = schema.transformation(field);
             if (!transform) {
-              throw new Error(`No '${field.type}' transform defined for use by ${identifier.type}.${String(prop)}`);
+              throw new Error(`No '${field.type}' transform defined for use by ${context.resourceKey.type}.${String(prop)}`);
             }
             rawValue = self[SOURCE].map(item => transform.serialize(item, field.options ?? null, self.owner));
           }
-          cache.setAttr(identifier, path, rawValue);
+          cache.setAttr(context.resourceKey, context.path, rawValue);
           _SIGNAL.isStale = true;
         }
         return reflect;
@@ -302,27 +390,453 @@ const desc = {
 };
 // compat(desc);
 Object.defineProperty(ManagedArray.prototype, '[]', desc);
+function getArrayField(context) {
+  const signal = entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  // 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 {
+    record
+  } = context;
+  let managedArray = signal.value;
+  if (managedArray) {
+    return managedArray;
+  } else {
+    const {
+      store,
+      resourceKey,
+      path
+    } = context;
+    const {
+      cache
+    } = store;
+    const rawValue = context.editable ? cache.getAttr(resourceKey, path) : cache.getRemoteAttr(resourceKey, path);
+    if (!rawValue) {
+      return null;
+    }
+    managedArray = new ManagedArray(context, record, rawValue);
+    signal.value = managedArray;
+  }
+  return managedArray;
+}
+function setArrayField(context) {
+  const {
+    field,
+    record,
+    value
+  } = context;
+  const {
+    cache,
+    schema
+  } = context.store;
+  const fieldSignal = peekInternalSignal(context.signals, context.path.at(-1));
+  const peeked = fieldSignal?.value;
+  const transform = field.type ? schema.transformation(field) : null;
+  const rawValue = field.type ? value.map(item => transform.serialize(item, field.options ?? null, record)) : value?.slice();
+  cache.setAttr(context.resourceKey, context.path, rawValue);
+  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;
+    // TODO run array destroy?
+  }
+  if (!Array.isArray(rawValue) && fieldSignal) {
+    fieldSignal.value = null;
+  }
+  return true;
+}
+function getAttributeField(context) {
+  entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  const {
+    cache
+  } = context.store;
+  return context.editable ? cache.getAttr(context.resourceKey, context.path) : cache.getRemoteAttr(context.resourceKey, context.path);
+}
+function setAttributeField(context) {
+  context.store.cache.setAttr(context.resourceKey, context.path, context.value);
+  return true;
+}
+const InvalidKinds = ['alias', 'derived', '@local'];
+function isInvalidKind(kind) {
+  return InvalidKinds.includes(kind);
+}
+function isNonIdentityCacheableField(field) {
+  return !isInvalidKind(field.kind) && field.kind !== '@id' && field.kind !== '@hash';
+}
+function getFieldCacheKeyStrict(field) {
+  return field.sourceKey || field.name;
+}
+function getFieldCacheKey(field) {
+  return 'sourceKey' in field && field.sourceKey ? field.sourceKey : field.name;
+}
+function getBelongsToField(context) {
+  entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  const {
+    field,
+    resourceKey,
+    store
+  } = context;
+  const {
+    schema,
+    cache
+  } = store;
+  if (field.options.linksMode) {
+    const rawValue = context.editable ? cache.getRelationship(resourceKey, getFieldCacheKeyStrict(field)) : cache.getRemoteRelationship(resourceKey, getFieldCacheKeyStrict(field));
+    return rawValue.data ? store.peekRecord(rawValue.data) : null;
+  }
+
+  // FIXME move this to a "LegacyMode" make this part of "PolarisMode"
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Can only use belongsTo fields when the resource is in legacy mode`);
+    }
+  })(context.legacy) : {};
+  return schema._kind('@legacy', 'belongsTo').get(store, context.record, resourceKey, field);
+}
+function setBelongsToField(context) {
+  const {
+    store
+  } = context;
+  const {
+    schema
+  } = store;
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Can only mutate belongsTo fields when the resource is in legacy mode`);
+    }
+  })(context.legacy) : {};
+  schema._kind('@legacy', 'belongsTo').set(store, context.record, context.resourceKey, context.field, context.value);
+  return true;
+}
+function getCollectionField(context) {
+  entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    {
+      throw new Error(`Accessing collection fields is not yet implemented`);
+    }
+  })() : {};
+}
+function setCollectionField(context) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    {
+      throw new Error(`Setting collection fields is not yet implemented`);
+    }
+  })() : {};
+  return false;
+}
+function getDerivedField(context) {
+  const {
+    schema
+  } = context.store;
+  return schema.derivation(context.field)(context.record, context.field.options ?? null, context.field.name);
+}
+function setDerivedField(context) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    {
+      throw new Error(`ILLEGAL SET: Cannot set '${context.path.join('.')}' on '${context.resourceKey.type}' as ${context.field.kind} fields are not mutable`);
+    }
+  })() : {};
+  return false;
+}
+function getGenericField(context) {
+  entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  const {
+    cache,
+    schema
+  } = context.store;
+  const rawValue = context.editable ? cache.getAttr(context.resourceKey, context.path) : cache.getRemoteAttr(context.resourceKey, context.path);
+  const {
+    field
+  } = context;
+  if (!field.type) {
+    return rawValue;
+  }
+  const transform = schema.transformation(field);
+  return transform.hydrate(rawValue, field.options ?? null, context.record);
+}
+function setGenericField(context) {
+  const {
+    cache,
+    schema
+  } = context.store;
+  const {
+    field
+  } = context;
+  if (!field.type) {
+    cache.setAttr(context.resourceKey, context.path, context.value);
+    return true;
+  }
+  const transform = schema.transformation(field);
+  const rawValue = transform.serialize(context.value, field.options ?? null, context.record);
+  cache.setAttr(context.resourceKey, context.path, rawValue);
+  return true;
+}
+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';
+    // FIXME field needs to use sourceKey
+    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) {
+    // FIXME field needs to use sourceKey
+    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;
+}
+function getHasManyField(context) {
+  const signal = entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  const {
+    store,
+    field
+  } = context;
+  if (field.options.linksMode) {
+    const {
+      record
+    } = context;
+    // 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 cached = signal.value;
+    if (cached) {
+      return cached;
+    }
+    const {
+      editable,
+      resourceKey
+    } = context;
+    const {
+      cache
+    } = store;
+    const rawValue = cache.getRelationship(resourceKey, getFieldCacheKeyStrict(field));
+    if (!rawValue) {
+      return null;
+    }
+    const managedArray = new RelatedCollection({
+      store,
+      type: field.type,
+      identifier: resourceKey,
+      cache,
+      field: context.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
+    });
+    signal.value = managedArray;
+    return managedArray;
+  }
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
+    }
+  })(context.legacy) : {};
+  return store.schema._kind('@legacy', 'hasMany').get(store, context.record, context.resourceKey, field);
+}
+function setHasManyField(context) {
+  const {
+    store
+  } = context;
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
+    }
+  })(context.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(context.value)) : {};
+  store.schema._kind('@legacy', 'hasMany').set(store, context.record, context.resourceKey, context.field, context.value);
+  return true;
+}
+function getHashField(context) {
+  const {
+    field,
+    path,
+    resourceKey
+  } = context;
+  const {
+    schema,
+    cache
+  } = context.store;
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Cannot use a ${field.kind} directly on a resource.`);
+    }
+  })(Array.isArray(path) && path.length > 1) : {};
+  const realPath = path.slice(0, -1);
+  const rawData = context.editable ? cache.getAttr(resourceKey, realPath) : cache.getRemoteAttr(resourceKey, realPath);
+  return schema.hashFn(field)(rawData, field.options ?? null, field.name ?? null);
+}
+function setHashField(context) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    {
+      throw new Error(`ILLEGAL SET: Cannot set '${Array.isArray(context.path) ? context.path.join('.') : context.path}' on '${context.resourceKey.type}' as ${context.field.kind} fields are not mutable`);
+    }
+  })() : {};
+  return false;
+}
+function getIdentityField(context) {
+  entangleSignal(context.signals, context.record, '@identity', null);
+  return context.resourceKey.id;
+}
+function setIdentityField(context) {
+  const {
+    value,
+    resourceKey,
+    store
+  } = context;
+  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 !== resourceKey.id;
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Cannot set ${resourceKey.type} record's id to ${normalizedId}, because id is already ${resourceKey.id}`);
+    }
+  })(!didChange || resourceKey.id === null) : {};
+  if (normalizedId !== null && didChange) {
+    store._instanceCache.setRecordId(resourceKey, normalizedId);
+    store.notifications.notify(resourceKey, 'identity');
+  }
+  return true;
+}
+function getLocalField(context) {
+  const {
+    field
+  } = context;
+  const signal = getOrCreateInternalSignal(context.signals, context.record, field.name, field.options?.defaultValue ?? null);
+  consumeInternalSignal(signal);
+  return signal.value;
+}
+function setLocalField(context) {
+  const {
+    value
+  } = context;
+  const signal = getOrCreateInternalSignal(context.signals, context.record, context.field.name, value);
+  if (signal.value !== value) {
+    signal.value = value;
+    notifyInternalSignal(signal);
+  }
+  return true;
+}
 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) {
+  constructor(context) {
+    const {
+      field,
+      path
+    } = context;
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const self = this;
-    this[SOURCE] = {
-      ...data
-    };
+    this[SOURCE] = Object.assign({}, context.value);
     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[Editable] = context.editable;
+    this[Legacy] = context.legacy;
+    this[Parent] = context.resourceKey;
     this[EmbeddedPath] = path;
+    const identifier = context.resourceKey;
+    const {
+      cache,
+      schema
+    } = context.store;
 
     // prettier-ignore
-    const extensions = !legacy ? null : schema.CAUTION_MEGA_DANGER_ZONE_objectExtensions(field);
+    const extensions = !context.legacy ? null : schema.CAUTION_MEGA_DANGER_ZONE_objectExtensions(field, null);
     const proxy = new Proxy(this[SOURCE], {
       ownKeys() {
         return Object.keys(self[SOURCE]);
@@ -332,7 +846,7 @@ class ManagedObject {
       },
       getOwnPropertyDescriptor(target, prop) {
         return {
-          writable: editable,
+          writable: context.editable,
           enumerable: true,
           configurable: true
         };
@@ -366,11 +880,9 @@ class ManagedObject {
           if (newData && newData !== self[SOURCE]) {
             if (field.type) {
               const transform = schema.transformation(field);
-              newData = transform.hydrate(newData, field.options ?? null, owner);
+              newData = transform.hydrate(newData, field.options ?? null, context.record);
             }
-            self[SOURCE] = {
-              ...newData
-            }; // Add type assertion for newData
+            self[SOURCE] = Object.assign({}, newData); // Add type assertion for newData
           }
         }
 
@@ -396,7 +908,7 @@ class ManagedObject {
           if (!test) {
             throw new Error(`Cannot set read-only property '${String(prop)}' on ManagedObject`);
           }
-        })(editable) : {};
+        })(context.editable) : {};
 
         // since objects function as dictionaries, we can't defer to schema/data before extensions
         // unless the prop is in the existing data.
@@ -411,7 +923,7 @@ class ManagedObject {
           cache.setAttr(identifier, path, self[SOURCE]);
         } else {
           const transform = schema.transformation(field);
-          const val = transform.serialize(self[SOURCE], field.options ?? null, owner);
+          const val = transform.serialize(self[SOURCE], field.options ?? null, context.record);
           cache.setAttr(identifier, path, val);
         }
         _SIGNAL.isStale = true;
@@ -421,141 +933,19 @@ class ManagedObject {
     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) {
+function getObjectField(context) {
+  entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  const {
+    record,
+    field
+  } = context;
   const managedObjectMapForRecord = ManagedObjectMap.get(record);
   let managedObject;
   if (managedObjectMapForRecord) {
@@ -564,7 +954,16 @@ function computeObject(schema, cache, record, identifier, field, path, editable,
   if (managedObject) {
     return managedObject;
   } else {
-    let rawValue = editable ? cache.getAttr(identifier, path) : cache.getRemoteAttr(identifier, path);
+    const {
+      store,
+      resourceKey,
+      path
+    } = context;
+    const {
+      cache,
+      schema
+    } = store;
+    let rawValue = context.editable ? cache.getAttr(resourceKey, path) : cache.getRemoteAttr(resourceKey, path);
     if (!rawValue) {
       return null;
     }
@@ -572,7 +971,18 @@ function computeObject(schema, cache, record, identifier, field, path, editable,
       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);
+    managedObject = new ManagedObject({
+      store,
+      resourceKey,
+      modeName: context.modeName,
+      legacy: context.legacy,
+      editable: context.editable,
+      path,
+      field,
+      record,
+      signals: context.signals,
+      value: rawValue
+    });
     if (!managedObjectMapForRecord) {
       ManagedObjectMap.set(record, new Map([[field.name, managedObject]]));
     } else {
@@ -581,48 +991,64 @@ function computeObject(schema, cache, record, identifier, field, path, editable,
   }
   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;
+function setObjectField(context) {
+  const {
+    field,
+    value,
+    record
+  } = context;
+  const {
+    cache,
+    schema
+  } = context.store;
+  if (!field.type) {
+    let newValue = value;
+    if (value !== null) {
+      newValue = {
+        ...value
+      };
+    } else {
+      ManagedObjectMap.delete(record);
     }
-    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);
+    cache.setAttr(context.resourceKey, context.path, newValue);
+    const peeked = peekManagedObject(record, field);
+    if (peeked) {
+      const objSignal = peeked[OBJECT_SIGNAL];
+      objSignal.isStale = true;
+    }
+    return true;
   }
-  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);
+  const transform = schema.transformation(field);
+  const rawValue = transform.serialize({
+    ...value
+  }, field.options ?? null, record);
+  cache.setAttr(context.resourceKey, context.path, rawValue);
+  const peeked = peekManagedObject(record, field);
+  if (peeked) {
+    const objSignal = peeked[OBJECT_SIGNAL];
+    objSignal.isStale = true;
+  }
+  return true;
 }
+
 // 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);
+  constructor(context) {
+    const {
+      store,
+      resourceKey
+    } = context;
+    const {
+      cache
+    } = store;
+    const name = getFieldCacheKeyStrict(context.field);
+    const rawValue = context.editable ? cache.getRelationship(resourceKey, name) : cache.getRemoteRelationship(resourceKey, 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.lid = rawValue.lid ?? rawValue.links?.self ?? `relationship:${resourceKey.lid}.${name}`;
     this.data = rawValue.data ? store.peekRecord(rawValue.data) : null;
     this.name = name;
     if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
@@ -633,7 +1059,7 @@ class ResourceRelationship {
       this.meta = rawValue.meta ?? {};
     }
     this[RecordStore] = store;
-    this[Parent] = parent;
+    this[Parent] = context.record;
   }
   fetch(options) {
     const url = options?.url ?? getHref(this.links.related) ?? getHref(this.links.self) ?? null;
@@ -659,60 +1085,273 @@ function getHref(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`);
+function getResourceField(context) {
+  entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  return new ResourceRelationship(context);
+}
+function setResourceField(context) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    {
+      throw new Error(`setting resource relationships is not yet supported`);
+    }
+  })() : {};
+  return false;
+}
+function setSchemaArrayField(context) {
+  const arrayValue = context.value?.slice();
+  const fieldSignal = peekInternalSignal(context.signals, context.path.at(-1));
+  const peeked = fieldSignal?.value;
+  context.store.cache.setAttr(context.resourceKey, context.path, arrayValue);
+  if (peeked) {
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected the peekManagedArray for ${context.field.kind} to return a ManagedArray`);
+      }
+    })(ARRAY_SIGNAL in peeked) : {};
+    const arrSignal = peeked[ARRAY_SIGNAL];
+    arrSignal.isStale = true;
+    if (!Array.isArray(arrayValue)) {
+      fieldSignal.value = null;
+    }
   }
-  return new ResourceRelationship(store, cache, parent, identifier, field, prop, editable);
+  return true;
 }
-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);
+function getSchemaObjectField(context) {
+  const signal = entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  const {
+    store,
+    resourceKey,
+    path
+  } = context;
+  const {
+    cache
+  } = store;
+  const rawValue = context.editable ? cache.getAttr(resourceKey, path) : cache.getRemoteAttr(resourceKey, path);
+  if (!rawValue) {
+    if (signal.value) {
+      const value = signal.value;
+      // TODO if we had idle scheduling this should be done there.
+      void Promise.resolve().then(() => {
+        value.value[Destroy]();
+      });
+      signal.value = null;
+    }
+    return null;
   }
-  if (managedArray) {
-    return managedArray;
+  const {
+    field
+  } = context;
+  const {
+    schema
+  } = store;
+  let objectType;
+  if (field.options?.polymorphic) {
+    const typePath = field.options.type ?? 'type';
+    // if we are polymorphic, then context.field.options.type will
+    // either specify a path on the rawValue to use as the type, defaulting to "type" or
+    // the special string "@hash" which tells us to treat field.type as a hashFn name with which
+    // to calc the type.
+    if (typePath === '@hash') {
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Expected the field to define a hashFn as its type`);
+        }
+      })(field.type) : {};
+      const hashFn = schema.hashFn({
+        type: field.type
+      });
+      // TODO consider if there are better options and name args we could provide.
+      objectType = hashFn(rawValue, null, null);
+    } else {
+      objectType = rawValue[typePath];
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Expected the type path for the field to be a value on the raw object`);
+        }
+      })(typePath && objectType && typeof objectType === 'string') : {};
+    }
   } else {
-    const rawValue = cache.getRelationship(identifier, field.name);
-    if (!rawValue) {
-      return null;
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`A non-polymorphic SchemaObjectField must provide a SchemaObject type in its definition`);
+      }
+    })(field.type) : {};
+    objectType = field.type;
+  }
+  const hashField = schema.resource({
+    type: objectType
+  }).identity;
+  const identity = hashField ? schema.hashFn(hashField)(rawValue, hashField.options ?? null, hashField.name) : field.name;
+  const cachedSchemaObject = signal.value;
+  if (cachedSchemaObject) {
+    if (cachedSchemaObject.type === objectType && cachedSchemaObject.identity === identity) {
+      return cachedSchemaObject.value;
+    } else {
+      // TODO if we had idle scheduling this should be done there.
+      void Promise.resolve().then(() => {
+        cachedSchemaObject.value[Destroy]();
+      });
     }
-    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
+  }
+  const schemaObject = new ReactiveResource({
+    store: context.store,
+    resourceKey: context.resourceKey,
+    modeName: context.modeName,
+    legacy: context.legacy,
+    editable: context.editable,
+    path: context.path,
+    field: context.field,
+    value: objectType
+  });
+  signal.value = {
+    type: objectType,
+    identity: identity,
+    value: schemaObject
+  };
+  return schemaObject;
+}
+function setSchemaObjectField(context) {
+  const {
+    store,
+    value
+  } = context;
+  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
+    };
+    // FIXME the case of field.type to string here is likely incorrect
+    const schemaFields = store.schema.fields({
+      type: context.field.type
     });
-    if (!managedArrayMapForRecord) {
-      ManagedArrayMap.set(record, new Map([[field.name, managedArray]]));
-    } else {
-      managedArrayMapForRecord.set(field.name, managedArray);
+    for (const key of Object.keys(newValue)) {
+      if (!schemaFields.has(key)) {
+        throw new Error(`Field ${key} does not exist on schema object ${context.field.type}`);
+      }
     }
+  } else {
+    ManagedObjectMap.delete(context.record);
   }
-  return managedArray;
+  store.cache.setAttr(context.resourceKey, context.path, newValue);
+  // const peeked = peekManagedObject(self, field);
+  // if (peeked) {
+  //   const objSignal = peeked[OBJECT_SIGNAL];
+  //   objSignal.isStale = true;
+  // }
+  return true;
 }
+const DefaultMode = {
+  '@hash': {
+    get: getHashField,
+    set: setHashField,
+    mutable: false,
+    enumerable: false,
+    serializable: false
+  },
+  '@id': {
+    get: getIdentityField,
+    set: setIdentityField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  '@local': {
+    get: getLocalField,
+    set: setLocalField,
+    mutable: true,
+    enumerable: false,
+    serializable: false
+  },
+  alias: {
+    get: getAliasField,
+    set: setAliasField,
+    mutable: true,
+    enumerable: true,
+    serializable: false
+  },
+  array: {
+    get: getArrayField,
+    set: setArrayField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  attribute: {
+    get: getAttributeField,
+    set: setAttributeField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  belongsTo: {
+    get: getBelongsToField,
+    set: setBelongsToField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  collection: {
+    get: getCollectionField,
+    set: setCollectionField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  derived: {
+    get: getDerivedField,
+    set: setDerivedField,
+    mutable: true,
+    enumerable: true,
+    serializable: false
+  },
+  field: {
+    get: getGenericField,
+    set: setGenericField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  hasMany: {
+    get: getHasManyField,
+    set: setHasManyField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  object: {
+    get: getObjectField,
+    set: setObjectField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  resource: {
+    get: getResourceField,
+    set: setResourceField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  'schema-array': {
+    get: getArrayField,
+    set: setSchemaArrayField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  'schema-object': {
+    get: getSchemaObjectField,
+    set: setSchemaObjectField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  }
+};
 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);
@@ -737,27 +1376,41 @@ const Editables = new WeakMap();
  */
 // 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;
+  constructor(context) {
+    const {
+      store
+    } = context;
+    const identifier = context.resourceKey;
+    const embeddedField = context.field;
+    const embeddedPath = context.path;
+    const isEmbedded = context.field !== null;
     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 IS_EDITABLE = this[Editable] = context.editable ?? false;
     const schema = store.schema;
-    const cache = store.cache;
-    const identityField = schema.resource(isEmbedded ? embeddedField : identifier).identity;
+    this[Legacy] = context.legacy ?? false;
+    const objectType = isEmbedded ? context.value : identifier.type;
+    const ResourceSchema = schema.resource(isEmbedded ? {
+      type: objectType
+    } : identifier);
+    const identityField = ResourceSchema.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);
+    const extensions = !context.legacy ? null : isEmbedded ? schema.CAUTION_MEGA_DANGER_ZONE_objectExtensions(embeddedField, objectType) : schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(identifier);
     this[EmbeddedField] = embeddedField;
     this[EmbeddedPath] = embeddedPath;
-    const fields = isEmbedded ? schema.fields(embeddedField) : schema.fields(identifier);
+    const fields = isEmbedded ? schema.fields({
+      type: objectType
+    }) : schema.fields(identifier);
+    const method = typeof schema.cacheFields === 'function' ? 'cacheFields' : 'fields';
+    const cacheFields = isEmbedded ? schema[method]({
+      type: objectType
+    }) : schema[method](identifier);
     const signals = withSignalStore(this);
     const proxy = new Proxy(this, {
       ownKeys() {
@@ -934,74 +1587,64 @@ class ReactiveResource {
             throw new Error(`Alias fields cannot alias '@id' '@local' '@hash' or 'derived' fields`);
           }
         })(maybeField.kind !== 'alias' || !['@id', '@local', '@hash', 'derived'].includes(maybeField.options.kind)) : {};
+        /**
+         * Prop Array is the path from a resource to the field including
+         * intermediate "links" on arrays,objects,schema-arrays and schema-objects.
+         *
+         * E.g. in the following
+         *
+         * ```
+         * const user = {
+         *   addresses: [{
+         *     street: 'Sunset Blvd',
+         *     zip: 90210
+         *   }]
+         * }
+         * ```
+         *
+         * The propArray for "street" is ['addresses', 0, 'street']
+         *
+         * Prop Array follows the `cache` path to the value, not the ui path.
+         * Thus, if `addresses` has a sourceKey of `user_addresses` and
+         * `zip` has a sourceKey of `zip_code` then the propArray for "zip" is
+         * ['user_addresses', 0, 'zip_code']
+         */
         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);
-
+        // SAFETY: we lie as string here because if we were to get null
+        // we would be in a field kind that won't use the propArray below.
+        const fieldCacheKey = getFieldCacheKey(field);
+        propArray.push(fieldCacheKey);
         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 'derived':
           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 'object':
+          case 'resource':
           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);
+          case 'collection':
+            return DefaultMode[field.kind].get({
+              store,
+              resourceKey: identifier,
+              modeName: context.modeName,
+              legacy: context.legacy,
+              editable: context.editable,
+              path: propArray,
+              field: field,
+              record: receiver,
+              signals,
+              value: null
+            });
           default:
-            throw new Error(`Field '${String(prop)}' on '${identifier.type}' has the unknown kind '${field.kind}'`);
+            assertNeverField(identifier, field, propArray);
         }
       },
       set(target, prop, value, receiver) {
@@ -1028,203 +1671,64 @@ class ReactiveResource {
             throw new Error(`Alias fields cannot alias '@id' '@local' '@hash' or 'derived' fields`);
           }
         })(maybeField.kind !== 'alias' || !['@id', '@local', '@hash', 'derived'].includes(maybeField.options.kind)) : {};
+        /**
+         * Prop Array is the path from a resource to the field including
+         * intermediate "links" on arrays,objects,schema-arrays and schema-objects.
+         *
+         * E.g. in the following
+         *
+         * ```
+         * const user = {
+         *   addresses: [{
+         *     street: 'Sunset Blvd',
+         *     zip: 90210
+         *   }]
+         * }
+         * ```
+         *
+         * The propArray for "street" is ['addresses', 0, 'street']
+         *
+         * Prop Array follows the `cache` path to the value, not the ui path.
+         * Thus, if `addresses` has a sourceKey of `user_addresses` and
+         * `zip` has a sourceKey of `zip_code` then the propArray for "zip" is
+         * ['user_addresses', 0, 'zip_code']
+         */
         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);
-
+        // SAFETY: we lie as string here because if we were to get null
+        // we would be in a field kind that won't use the propArray below.
+        const fieldCacheKey = getFieldCacheKey(field);
+        propArray.push(fieldCacheKey);
         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 '@hash':
           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 'derived':
           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 'object':
+          case 'resource':
           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;
+          case 'collection':
+            return DefaultMode[field.kind].set({
+              store,
+              resourceKey: identifier,
+              modeName: context.modeName,
+              legacy: context.legacy,
+              editable: context.editable,
+              path: propArray,
+              field: field,
+              record: receiver,
+              signals,
+              value
+            });
           default:
-            throw new Error(`Unknown field kind ${field.kind}`);
+            return assertNeverField(identifier, field, propArray);
         }
       }
     });
@@ -1255,25 +1759,25 @@ class ReactiveResource {
                 // 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);
+                console.warn(`Notification unhandled for ${key.join(',')} on ${identifier.type}`, proxy);
                 return;
               }
 
               // TODO we should add a LOGGING flag
-              // console.log(`Deep notification skipped for ${key.join('.')} on ${identifier.type}`, self);
+              // console.log(`Deep notification skipped for ${key.join('.')} on ${identifier.type}`, proxy);
               // 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);
+              // console.log(`Notification for ${key} on ${identifier.type}`, proxy);
               const signal = signals.get(key);
               if (signal) {
                 notifyInternalSignal(signal);
               }
-              const field = fields.get(key);
+              const field = cacheFields.get(key);
               if (field?.kind === 'array' || field?.kind === 'schema-array') {
-                const peeked = peekManagedArray(self, field);
+                const peeked = signal?.value;
                 if (peeked) {
                   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
                     if (!test) {
@@ -1285,7 +1789,7 @@ class ReactiveResource {
                 }
               }
               if (field?.kind === 'object') {
-                const peeked = peekManagedObject(self, field);
+                const peeked = peekManagedObject(proxy, field);
                 if (peeked) {
                   const objSignal = peeked[OBJECT_SIGNAL];
                   notifyInternalSignal(objSignal);
@@ -1299,15 +1803,15 @@ class ReactiveResource {
             if (Array.isArray(key)) ;else {
               if (isEmbedded) return; // base paths never apply to embedded records
 
-              const field = fields.get(key);
+              const field = cacheFields.get(key);
               macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
                 if (!test) {
-                  throw new Error(`Expected relationshp ${key} to be the name of a field`);
+                  throw new Error(`Expected relationship ${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);
+                // console.log(`Notification for ${key} on ${identifier.type}`, proxy);
                 const signal = signals.get(key);
                 if (signal) {
                   notifyInternalSignal(signal);
@@ -1315,9 +1819,12 @@ class ReactiveResource {
                 // 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]);
+                  const signal = signals.get(key);
+                  if (signal) {
+                    const peeked = signal.value;
+                    if (peeked) {
+                      notifyInternalSignal(peeked[ARRAY_SIGNAL]);
+                    }
                   }
                   return;
                 }
@@ -1325,7 +1832,7 @@ class ReactiveResource {
                   if (!test) {
                     throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
                   }
-                })(Mode[Legacy]) : {};
+                })(context.legacy) : {};
                 if (schema._kind('@legacy', 'hasMany').notify(store, proxy, identifier, field)) {
                   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
                     if (!test) {
@@ -1381,10 +1888,17 @@ function _CHECKOUT(record) {
   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);
+  const legacy = record[Legacy];
+  const editableRecord = new ReactiveResource({
+    store: record[RecordStore],
+    resourceKey: record[Identifier],
+    modeName: legacy ? 'legacy' : 'polaris',
+    legacy: legacy,
+    editable: true,
+    path: null,
+    field: null,
+    value: null
+  });
   setRecordIdentifier(editableRecord, recordIdentifierFor(record));
   return Promise.resolve(editableRecord);
 }
@@ -1396,6 +1910,17 @@ function _DESTROY(record) {
     record.isDestroyed = true;
   }
   record[RecordStore].notifications.unsubscribe(record.___notifications);
+
+  // FIXME we need a way to also unsubscribe all SchemaObjects when the primary
+  // resource is destroyed.
+}
+function assertNeverField(identifier, field, path) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    {
+      throw new Error(`Cannot use unknown field kind ${field.kind} on <${identifier.type}>.${Array.isArray(path) ? path.join('.') : path}`);
+    }
+  })() : {};
+  return false;
 }
 function instantiateRecord(store, identifier, createArgs) {
   const schema = store.schema;
@@ -1405,11 +1930,17 @@ 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 || store.cache.isNew(identifier);
+  const record = new ReactiveResource({
+    store,
+    resourceKey: identifier,
+    modeName: legacy ? 'legacy' : 'polaris',
+    legacy: legacy,
+    editable: editable,
+    path: null,
+    field: null,
+    value: null
   });
   if (createArgs) {
     Object.assign(record, createArgs);
@@ -1546,7 +2077,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 +2104,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);
@@ -1724,7 +2259,7 @@ class SchemaService {
     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 +2356,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 +2370,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 +2442,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);
   }
 
   /**
@@ -1926,11 +2506,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 +2584,103 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_SCHEMA
     return this._schemas.has(type);
   };
 }
+
+/**
+ * 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);
+  }
+}
 export { Checkout, SchemaService, fromIdentity, instantiateRecord, registerDerivations, teardownRecord, withDefaults };