@warp-drive/core 5.7.0-alpha.2 → 5.7.0-alpha.4

package/dist/reactive.js

@@ -1,5 +1,5 @@
 import { isResourceSchema } from './types/schema/fields.js';
-import { F as withSignalStore, T as isExtensionProp, U as performExtensionSet, H as consumeInternalSignal, V as performArrayExtensionGet, x as entangleSignal, W as performObjectExtensionGet, d as SOURCE$1, f as fastPush, y as defineSignal, l as RelatedCollection, J as getOrCreateInternalSignal, G as notifyInternalSignal, B as Signals, h as setRecordIdentifier, r as recordIdentifierFor } from "./request-state-CejVJgdj.js";
+import { F as withSignalStore, T as isExtensionProp, U as performExtensionSet, H as consumeInternalSignal, V as performArrayExtensionGet, x as entangleSignal, 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-Bj0zUw2r.js";
 import { EnableHydration, STRUCTURED } from './types/request.js';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { warn, deprecate } from '@ember/debug';
@@ -9,6 +9,21 @@ import { RecordStore, Type } from './types/symbols.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,20 +70,22 @@ 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 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 mode = context.field.options?.key ?? '@identity';
     const RefStorage = mode === '@identity' ? WeakMap :
     // CAUTION CAUTION CAUTION
     // this is a pile of lies
@@ -77,8 +94,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 = context.field.kind === 'schema-array' ? new RefStorage() : null;
+    const extensions = context.legacy ? schema.CAUTION_MEGA_DANGER_ZONE_arrayExtensions(context.field) : null;
     const proxy = new Proxy(this[SOURCE], {
       get(target, prop, receiver) {
         if (prop === ARRAY_SIGNAL) {
@@ -93,7 +110,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);
@@ -108,7 +125,7 @@ class ManagedArray {
           if (mode === '@hash') {
             val = target[index];
             const hashField = schema.resource({
-              type: field.type
+              type: context.field.type
             }).identity;
             const hashFn = schema.hashFn(hashField);
             val = hashFn(val, null, null);
@@ -126,7 +143,7 @@ class ManagedArray {
                 }
               })(typeof mode === 'string') : {};
               const modeField = schema.resource({
-                type: field.type
+                type: context.field.type
               }).fields.find(f => f.name === mode);
               macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
                 if (!test) {
@@ -141,7 +158,7 @@ class ManagedArray {
             }
             val = mode === '@identity' ? target[index] : mode === '@index' ? '@index' : target[index][mode];
           }
-          if (isSchemaArray) {
+          if (context.field.kind === 'schema-array') {
             if (!transaction) {
               consumeInternalSignal(_SIGNAL);
             }
@@ -149,7 +166,7 @@ class ManagedArray {
               const recordRef = ManagedRecordRefs.get(val);
               let record = recordRef?.deref();
               if (!record) {
-                const recordPath = path.slice();
+                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>`
                 // TODO we should allow the schema for the field to define a "key"
@@ -157,11 +174,16 @@ class ManagedArray {
                 // 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);
+                record = new ReactiveResource({
+                  store: context.store,
+                  resourceKey: context.resourceKey,
+                  modeName: context.modeName,
+                  legacy: context.legacy,
+                  editable: context.editable,
+                  path: recordPath,
+                  field: context.field
+                });
+
                 // 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
@@ -177,9 +199,9 @@ class ManagedArray {
           if (!transaction) {
             consumeInternalSignal(_SIGNAL);
           }
-          if (field.type) {
-            const transform = schema.transformation(field);
-            return transform.hydrate(val, field.options ?? null, self.owner);
+          if (context.field.type) {
+            const transform = schema.transformation(context.field);
+            return transform.hydrate(val, context.field.options ?? null, self.owner);
           }
           return val;
         }
@@ -190,7 +212,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 +255,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`);
         }
@@ -252,20 +274,20 @@ class ManagedArray {
         }
         const reflect = Reflect.set(target, prop, value, receiver);
         if (reflect) {
-          if (!field.type) {
-            cache.setAttr(identifier, path, self[SOURCE]);
+          if (!context.field.type) {
+            cache.setAttr(context.resourceKey, context.path, self[SOURCE]);
             _SIGNAL.isStale = true;
             return true;
           }
           let rawValue = self[SOURCE];
-          if (!isSchemaArray) {
-            const transform = schema.transformation(field);
+          if (context.field.kind !== 'schema-array') {
+            const transform = schema.transformation(context.field);
             if (!transform) {
-              throw new Error(`No '${field.type}' transform defined for use by ${identifier.type}.${String(prop)}`);
+              throw new Error(`No '${context.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));
+            rawValue = self[SOURCE].map(item => transform.serialize(item, context.field.options ?? null, self.owner));
           }
-          cache.setAttr(identifier, path, rawValue);
+          cache.setAttr(context.resourceKey, context.path, rawValue);
           _SIGNAL.isStale = true;
         }
         return reflect;
@@ -302,27 +324,490 @@ const desc = {
 };
 // compat(desc);
 Object.defineProperty(ManagedArray.prototype, '[]', desc);
+const ManagedArrayMap = getOrSetGlobal('ManagedArrayMap', new Map());
+function peekManagedArray(record, field) {
+  const managedArrayMapForRecord = ManagedArrayMap.get(record);
+  if (managedArrayMapForRecord) {
+    return managedArrayMapForRecord.get(field.name);
+  }
+}
+function getArrayField(context) {
+  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 {
+    field,
+    record
+  } = context;
+  const managedArrayMapForRecord = ManagedArrayMap.get(record);
+  let managedArray;
+  if (managedArrayMapForRecord) {
+    managedArray = managedArrayMapForRecord.get(field.name);
+  }
+  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);
+    if (!managedArrayMapForRecord) {
+      ManagedArrayMap.set(record, new Map([[field.name, managedArray]]));
+    } else {
+      managedArrayMapForRecord.set(field.name, managedArray);
+    }
+  }
+  return managedArray;
+}
+function setArrayField(context) {
+  const {
+    field,
+    record,
+    value
+  } = context;
+  const {
+    cache,
+    schema
+  } = context.store;
+  if (!field.type) {
+    cache.setAttr(context.resourceKey, context.path, value?.slice());
+    const peeked = peekManagedArray(record, 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(record);
+    }
+    return true;
+  }
+  const transform = schema.transformation(field);
+  const rawValue = value.map(item => transform.serialize(item, field.options ?? null, record));
+  cache.setAttr(context.resourceKey, context.path, rawValue);
+  const peeked = peekManagedArray(record, 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;
+}
+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) {
+  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 managedArrayMapForRecord = ManagedArrayMap.get(record);
+    let managedArray;
+    if (managedArrayMapForRecord) {
+      managedArray = managedArrayMapForRecord.get(getFieldCacheKeyStrict(field));
+    }
+    if (managedArray) {
+      return managedArray;
+    } else {
+      const {
+        editable,
+        resourceKey
+      } = context;
+      const {
+        cache
+      } = store;
+      const rawValue = cache.getRelationship(resourceKey, getFieldCacheKeyStrict(field));
+      if (!rawValue) {
+        return null;
+      }
+      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
+      });
+      if (!managedArrayMapForRecord) {
+        ManagedArrayMap.set(record, new Map([[field.name, managedArray]]));
+      } else {
+        managedArrayMapForRecord.set(field.name, 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);
     const proxy = new Proxy(this[SOURCE], {
       ownKeys() {
         return Object.keys(self[SOURCE]);
@@ -332,7 +817,7 @@ class ManagedObject {
       },
       getOwnPropertyDescriptor(target, prop) {
         return {
-          writable: editable,
+          writable: context.editable,
           enumerable: true,
           configurable: true
         };
@@ -366,11 +851,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 +879,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.
@@ -405,157 +888,35 @@ class ManagedObject {
         }
         const reflect = Reflect.set(target, prop, value, receiver);
         if (!reflect) {
-          return false;
-        }
-        if (!field.type) {
-          cache.setAttr(identifier, path, self[SOURCE]);
-        } else {
-          const transform = schema.transformation(field);
-          const val = transform.serialize(self[SOURCE], field.options ?? null, owner);
-          cache.setAttr(identifier, path, val);
-        }
-        _SIGNAL.isStale = true;
-        return true;
-      }
-    });
-    return proxy;
-  }
-}
-class ManyArrayManager {
-  constructor(record, editable) {
-    this.record = record;
-    this.store = record[RecordStore];
-    this.identifier = record[Identifier];
-    this.editable = editable;
-  }
-  _syncArray(array) {
-    const method = this.editable ? 'getRelationship' : 'getRemoteRelationship';
-    const rawValue = this.store.cache[method](this.identifier, array.key);
-    if (rawValue.meta) {
-      array.meta = rawValue.meta;
-    }
-    if (rawValue.links) {
-      array.links = rawValue.links;
-    }
-    const currentState = array[SOURCE$1];
-
-    // unlike in the normal RecordArray case, we don't need to divorce the reference
-    // because we don't need to worry about associate/disassociate since the graph
-    // takes care of that for us
-    if (currentState !== rawValue.data) {
-      currentState.length = 0;
-      fastPush(currentState, rawValue.data);
-    }
-  }
-  reloadHasMany(key, options) {
-    const field = this.store.schema.fields(this.identifier).get(key);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Expected a hasMany field for ${key}`);
-      }
-    })(field?.kind === 'hasMany') : {};
-    const cacheOptions = options ? extractCacheOptions(options) : {
-      reload: true
-    };
-    cacheOptions.types = [field.type];
-    const rawValue = this.store.cache.getRelationship(this.identifier, key);
-    const req = {
-      url: getRelatedLink(rawValue),
-      op: 'findHasMany',
-      method: 'GET',
-      records: rawValue.data,
-      cacheOptions,
-      options: {
-        field,
-        identifier: this.identifier,
-        links: rawValue.links,
-        meta: rawValue.meta
-      },
-      [EnableHydration]: false
-    };
-    return this.store.request(req);
-  }
-  mutate(mutation) {
-    this.store.cache.mutate(mutation);
-  }
-}
-function getRelatedLink(resource) {
-  const related = resource.links?.related;
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Expected a related link`);
-    }
-  })(related) : {};
-  return typeof related === 'object' ? related.href : related;
-}
-function extractCacheOptions(options) {
-  const cacheOptions = {};
-  if ('reload' in options) {
-    cacheOptions.reload = options.reload;
-  }
-  if ('backgroundReload' in options) {
-    cacheOptions.backgroundReload = options.backgroundReload;
+          return false;
+        }
+        if (!field.type) {
+          cache.setAttr(identifier, path, self[SOURCE]);
+        } else {
+          const transform = schema.transformation(field);
+          const val = transform.serialize(self[SOURCE], field.options ?? null, context.record);
+          cache.setAttr(identifier, path, val);
+        }
+        _SIGNAL.isStale = true;
+        return true;
+      }
+    });
+    return proxy;
   }
-  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 +925,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 +942,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 +962,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 +1030,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 +1056,220 @@ 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();
+  if (!Array.isArray(arrayValue)) {
+    ManagedArrayMap.delete(context.record);
+  }
+  context.store.cache.setAttr(context.resourceKey, context.path, arrayValue);
+  const peeked = peekManagedArray(context.record, context.field);
+  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;
   }
-  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) {
+  entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  const {
+    record,
+    field
+  } = context;
+  const schemaObjectMapForRecord = ManagedObjectMap.get(record);
+  let schemaObject;
+  if (schemaObjectMapForRecord) {
+    schemaObject = schemaObjectMapForRecord.get(field.name);
   }
-  if (managedArray) {
-    return managedArray;
+  if (schemaObject) {
+    return schemaObject;
   } else {
-    const rawValue = cache.getRelationship(identifier, field.name);
+    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 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
+    schemaObject = new ReactiveResource({
+      store: context.store,
+      resourceKey: context.resourceKey,
+      modeName: context.modeName,
+      legacy: context.legacy,
+      editable: context.editable,
+      path: context.path,
+      field: context.field
     });
-    if (!managedArrayMapForRecord) {
-      ManagedArrayMap.set(record, new Map([[field.name, managedArray]]));
-    } else {
-      managedArrayMapForRecord.set(field.name, managedArray);
-    }
   }
-  return managedArray;
+  if (!schemaObjectMapForRecord) {
+    ManagedObjectMap.set(record, new Map([[field.name, schemaObject]]));
+  } else {
+    schemaObjectMapForRecord.set(field.name, 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
+    };
+    const schemaFields = store.schema.fields({
+      type: context.field.type
+    });
+    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);
+  }
+  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,24 +1294,29 @@ 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;
+    this[Legacy] = context.legacy ?? false;
     const schema = store.schema;
-    const cache = store.cache;
-    const identityField = schema.resource(isEmbedded ? embeddedField : identifier).identity;
+    const ResourceSchema = schema.resource(isEmbedded ? embeddedField : 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) : schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(identifier);
     this[EmbeddedField] = embeddedField;
     this[EmbeddedPath] = embeddedPath;
     const fields = isEmbedded ? schema.fields(embeddedField) : schema.fields(identifier);
@@ -934,74 +1496,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 +1580,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 +1668,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);
               if (field?.kind === 'array' || field?.kind === 'schema-array') {
-                const peeked = peekManagedArray(self, field);
+                const peeked = peekManagedArray(proxy, field);
                 if (peeked) {
                   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
                     if (!test) {
@@ -1285,7 +1698,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);
@@ -1302,12 +1715,12 @@ class ReactiveResource {
               const field = fields.get(key);
               macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
                 if (!test) {
-                  throw new Error(`Expected relationshp ${key} to be the name of a field`);
+                  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,7 +1728,7 @@ class ReactiveResource {
                 // FIXME
               } else if (field.kind === 'resource') ;else if (field.kind === 'hasMany') {
                 if (field.options.linksMode) {
-                  const peeked = peekManagedArray(self, field);
+                  const peeked = peekManagedArray(proxy, field);
                   if (peeked) {
                     notifyInternalSignal(peeked[ARRAY_SIGNAL]);
                   }
@@ -1325,7 +1738,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 +1794,16 @@ 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: embeddedPath,
+    field: embeddedType
+  });
   setRecordIdentifier(editableRecord, recordIdentifierFor(record));
   return Promise.resolve(editableRecord);
 }
@@ -1397,6 +1816,14 @@ function _DESTROY(record) {
   }
   record[RecordStore].notifications.unsubscribe(record.___notifications);
 }
+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;
   const resourceSchema = schema.resource(identifier);
@@ -1405,11 +1832,16 @@ 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
   });
   if (createArgs) {
     Object.assign(record, createArgs);
@@ -1836,16 +2268,21 @@ class SchemaService {
         relationships[field.name] = field;
       }
     }
+    const cacheFields = null;
     const traits = new Set(isResourceSchema(schema) ? schema.traits : []);
     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);
   }
 
@@ -1976,6 +2413,20 @@ class SchemaService {
     }
     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);
   }
@@ -2064,8 +2515,27 @@ function finalizeResource(schema, resource) {
   }
   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.