@warp-drive-mirror/schema-record 5.6.0-beta.0 → 5.6.0-beta.2

package/dist/index.js

@@ -1,1777 +1 @@
-import { isResourceSchema } from '@warp-drive-mirror/core-types/schema/fields';
-import { macroCondition, getGlobalConfig, dependencySatisfies, importSync } from '@embroider/macros';
-import { withSignalStore, entangleSignal, ARRAY_SIGNAL, consumeInternalSignal, OBJECT_SIGNAL, SOURCE as SOURCE$1, fastPush, defineSignal, RelatedCollection, getOrCreateInternalSignal, notifyInternalSignal, Signals, setRecordIdentifier, recordIdentifierFor, createMemo } from '@ember-data-mirror/store/-private';
-import { EnableHydration, STRUCTURED } from '@warp-drive-mirror/core-types/request';
-import { RecordStore, Type } from '@warp-drive-mirror/core-types/symbols';
-import { getOrSetGlobal } from '@warp-drive-mirror/core-types/-private';
-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 EmbeddedType } from "./symbols-B_60yPO2.js";
-import { deprecate } from '@ember/debug';
-import { recordIdentifierFor as recordIdentifierFor$1 } from '@ember-data-mirror/store';
-const ARRAY_GETTER_METHODS = new Set([Symbol.iterator, 'concat', 'entries', 'every', 'fill', 'filter', 'find', 'findIndex', 'flat', 'flatMap', 'forEach', 'includes', 'indexOf', 'join', 'keys', 'lastIndexOf', 'map', 'reduce', 'reduceRight', 'slice', 'some', 'values']);
-// const ARRAY_SETTER_METHODS = new Set<KeyType>(['push', 'pop', 'unshift', 'shift', 'splice', 'sort']);
-const SYNC_PROPS = new Set(['[]', 'length']);
-function isArrayGetter(prop) {
-  return ARRAY_GETTER_METHODS.has(prop);
-}
-const ARRAY_SETTER_METHODS = new Set(['push', 'pop', 'unshift', 'shift', 'splice', 'sort']);
-function isArraySetter(prop) {
-  return ARRAY_SETTER_METHODS.has(prop);
-}
-
-// function isSelfProp<T extends object>(self: T, prop: KeyType): prop is keyof T {
-//   return prop in self;
-// }
-
-function convertToInt(prop) {
-  if (typeof prop === 'symbol') return null;
-  const num = Number(prop);
-  if (isNaN(num)) return null;
-  return num % 1 === 0 ? num : null;
-}
-function safeForEach(instance, arr, store, callback, target) {
-  if (target === undefined) {
-    target = null;
-  }
-  // clone to prevent mutation
-  arr = arr.slice();
-  macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error('`forEach` expects a function as first argument.');
-    }
-  })(typeof callback === 'function') : {};
-
-  // because we retrieveLatest above we need not worry if array is mutated during iteration
-  // by unloadRecord/rollbackAttributes
-  // push/add/removeObject may still be problematic
-  // but this is a more traditionally expected forEach bug.
-  const length = arr.length; // we need to access length to ensure we are consumed
-
-  for (let index = 0; index < length; index++) {
-    callback.call(target, arr[index], index, instance);
-  }
-  return instance;
-}
-class ManagedArray {
-  [SOURCE];
-  constructor(store, schema, cache, field, data, identifier, path, owner, isSchemaArray, editable, legacy) {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const self = this;
-    this[SOURCE] = data?.slice();
-    const IS_EDITABLE = this[Editable] = editable ?? false;
-    this[Legacy] = legacy;
-
-    // FIXME probably can get rid of the manual ARRAY_SIGNAL storage
-    // FIXME probably the storage should be on the proxy/receiver not this class
-    const signals = withSignalStore(this);
-    const _SIGNAL = this[ARRAY_SIGNAL] = entangleSignal(signals, this, ARRAY_SIGNAL, undefined);
-    const boundFns = new Map();
-    this.identifier = identifier;
-    this.path = path;
-    this.owner = owner;
-    let transaction = false;
-    const mode = field.options?.key ?? '@identity';
-    const RefStorage = mode === '@identity' ? WeakMap :
-    // CAUTION CAUTION CAUTION
-    // this is a pile of lies
-    // the Map is Map<string, WeakRef<SchemaRecord>>
-    // but TS does not understand how to juggle modes like this
-    // internal to a method like ours without us duplicating the code
-    // into two separate methods.
-    Map;
-    const ManagedRecordRefs = isSchemaArray ? new RefStorage() : null;
-    const proxy = new Proxy(this[SOURCE], {
-      get(target, prop, receiver) {
-        if (prop === ARRAY_SIGNAL) {
-          return _SIGNAL;
-        }
-        if (prop === 'identifier') {
-          return self.identifier;
-        }
-        if (prop === 'owner') {
-          return self.owner;
-        }
-        const index = convertToInt(prop);
-        if (_SIGNAL.isStale && (index !== null || SYNC_PROPS.has(prop) || isArrayGetter(prop))) {
-          _SIGNAL.isStale = false;
-          const newData = cache.getAttr(identifier, path);
-          if (newData && newData !== self[SOURCE]) {
-            self[SOURCE].length = 0;
-            self[SOURCE].push(...newData);
-          }
-        }
-        if (index !== null) {
-          let val;
-          if (mode === '@hash') {
-            val = target[index];
-            const hashField = schema.resource({
-              type: field.type
-            }).identity;
-            const hashFn = schema.hashFn(hashField);
-            val = hashFn(val, null, null);
-          } else {
-            // if mode is not @identity or @index, then access the key path.
-            // we should assert that `mode` is a string
-            // it should read directly from the cache value for that field (e.g. no derivation, no transformation)
-            // and, we likely should lookup the associated field and throw an error IF
-            // the given field does not exist OR
-            // the field is anything other than a GenericField or LegacyAttributeField.
-            if (mode !== '@identity' && mode !== '@index') {
-              macroCondition(getGlobalConfig().WarpDriveMirror.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().WarpDriveMirror.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error('field must exist in schema');
-                }
-              })(modeField) : {};
-              macroCondition(getGlobalConfig().WarpDriveMirror.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 SchemaRecord
-                // embedded object.
-                recordPath.push(index);
-                const recordIdentifier = self.owner[Identifier] || self.owner[Parent];
-                record = new SchemaRecord(store, recordIdentifier, {
-                  [Editable]: self.owner[Editable],
-                  [Legacy]: self.owner[Legacy]
-                }, true, field.type, recordPath);
-                // if mode is not @identity or @index, then access the key path now
-                // to determine the key value.
-                // chris says we can implement this as a special kind `@hash` which
-                // would be a function that only has access to the cache value and not
-                // the record itself, so derivation is possible but intentionally limited
-                // and non-reactive?
-                ManagedRecordRefs.set(val, new WeakRef(record));
-              }
-              return record;
-            }
-            return val;
-          }
-          if (!transaction) {
-            consumeInternalSignal(_SIGNAL);
-          }
-          if (field.type) {
-            const transform = schema.transformation(field);
-            return transform.hydrate(val, field.options ?? null, self.owner);
-          }
-          return val;
-        }
-        if (isArrayGetter(prop)) {
-          let fn = boundFns.get(prop);
-          if (fn === undefined) {
-            if (prop === 'forEach') {
-              fn = function () {
-                consumeInternalSignal(_SIGNAL);
-                transaction = true;
-                const result = safeForEach(receiver, target, store, arguments[0], arguments[1]);
-                transaction = false;
-                return result;
-              };
-            } else {
-              fn = function () {
-                consumeInternalSignal(_SIGNAL);
-                // array functions must run through Reflect to work properly
-                // binding via other means will not work.
-                transaction = true;
-                const result = Reflect.apply(target[prop], receiver, arguments);
-                transaction = false;
-                return result;
-              };
-            }
-            boundFns.set(prop, fn);
-          }
-          return fn;
-        }
-        if (isArraySetter(prop)) {
-          let fn = boundFns.get(prop);
-          if (fn === undefined) {
-            fn = function () {
-              if (!IS_EDITABLE) {
-                throw new Error(`Mutating this array via ${String(prop)} is not allowed because the record is not editable`);
-              }
-              consumeInternalSignal(_SIGNAL);
-              transaction = true;
-              const result = Reflect.apply(target[prop], receiver, arguments);
-              transaction = false;
-              return result;
-            };
-            boundFns.set(prop, fn);
-          }
-          return fn;
-        }
-        return Reflect.get(target, prop, receiver);
-      },
-      set(target, prop, value, receiver) {
-        if (!IS_EDITABLE) {
-          let errorPath = identifier.type;
-          if (path) {
-            errorPath = path[path.length - 1];
-          }
-          throw new Error(`Cannot set ${String(prop)} on ${errorPath} because the record is not editable`);
-        }
-        if (prop === 'identifier') {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-          self.identifier = value;
-          return true;
-        }
-        if (prop === 'owner') {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-          self.owner = value;
-          return true;
-        }
-        const reflect = Reflect.set(target, prop, value, receiver);
-        if (reflect) {
-          if (!field.type) {
-            cache.setAttr(identifier, path, self[SOURCE]);
-            _SIGNAL.isStale = true;
-            return true;
-          }
-          let rawValue = self[SOURCE];
-          if (!isSchemaArray) {
-            const transform = schema.transformation(field);
-            if (!transform) {
-              throw new Error(`No '${field.type}' transform defined for use by ${identifier.type}.${String(prop)}`);
-            }
-            rawValue = self[SOURCE].map(item => transform.serialize(item, field.options ?? null, self.owner));
-          }
-          cache.setAttr(identifier, path, rawValue);
-          _SIGNAL.isStale = true;
-        }
-        return reflect;
-      },
-      has(target, prop) {
-        if (prop === 'identifier' || prop === 'owner' || prop === ARRAY_SIGNAL) {
-          return true;
-        }
-        return Reflect.has(target, prop);
-      }
-    });
-    return proxy;
-  }
-}
-const ObjectSymbols = new Set([OBJECT_SIGNAL, Parent, SOURCE, Editable, EmbeddedPath]);
-
-// const ignoredGlobalFields = new Set<string>(['setInterval', 'nodeType', 'nodeName', 'length', 'document', STRUCTURED]);
-
-class ManagedObject {
-  constructor(schema, cache, field, data, identifier, path, owner, editable, legacy) {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const self = this;
-    this[SOURCE] = {
-      ...data
-    };
-    const signals = withSignalStore(this);
-    const _SIGNAL = this[OBJECT_SIGNAL] = entangleSignal(signals, this, OBJECT_SIGNAL, undefined);
-    this[Editable] = editable;
-    this[Legacy] = legacy;
-    this[Parent] = identifier;
-    this[EmbeddedPath] = path;
-    const proxy = new Proxy(this[SOURCE], {
-      ownKeys() {
-        return Object.keys(self[SOURCE]);
-      },
-      has(target, prop) {
-        return prop in self[SOURCE];
-      },
-      getOwnPropertyDescriptor(target, prop) {
-        return {
-          writable: editable,
-          enumerable: true,
-          configurable: true
-        };
-      },
-      get(target, prop, receiver) {
-        if (ObjectSymbols.has(prop)) {
-          return self[prop];
-        }
-        if (prop === Symbol.toPrimitive) {
-          return () => null;
-        }
-        if (prop === Symbol.toStringTag) {
-          return `ManagedObject<${identifier.type}:${identifier.id} (${identifier.lid})>`;
-        }
-        if (prop === 'constructor') {
-          return Object;
-        }
-        if (prop === 'toString') {
-          return function () {
-            return `ManagedObject<${identifier.type}:${identifier.id} (${identifier.lid})>`;
-          };
-        }
-        if (prop === 'toHTML') {
-          return function () {
-            return '<span>ManagedObject</span>';
-          };
-        }
-        if (prop === 'toJSON') {
-          return function () {
-            return structuredClone(self[SOURCE]);
-          };
-        }
-        if (_SIGNAL.isStale) {
-          _SIGNAL.isStale = false;
-          let newData = cache.getAttr(identifier, path);
-          if (newData && newData !== self[SOURCE]) {
-            if (field.type) {
-              const transform = schema.transformation(field);
-              newData = transform.hydrate(newData, field.options ?? null, owner);
-            }
-            self[SOURCE] = {
-              ...newData
-            }; // Add type assertion for newData
-          }
-        }
-        if (prop in self[SOURCE]) {
-          consumeInternalSignal(_SIGNAL);
-          return self[SOURCE][prop];
-        }
-        return Reflect.get(target, prop, receiver);
-      },
-      set(target, prop, value, receiver) {
-        macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-          if (!test) {
-            throw new Error(`Cannot set read-only property '${String(prop)}' on ManagedObject`);
-          }
-        })(editable) : {};
-        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().WarpDriveMirror.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().WarpDriveMirror.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Expected a related link`);
-    }
-  })(related) : {};
-  return typeof related === 'object' ? related.href : related;
-}
-function extractCacheOptions(options) {
-  const cacheOptions = {};
-  if ('reload' in options) {
-    cacheOptions.reload = options.reload;
-  }
-  if ('backgroundReload' in options) {
-    cacheOptions.backgroundReload = options.backgroundReload;
-  }
-  return cacheOptions;
-}
-const ManagedArrayMap = getOrSetGlobal('ManagedArrayMap', new Map());
-const ManagedObjectMap = getOrSetGlobal('ManagedObjectMap', new Map());
-function computeLocal(record, field, prop) {
-  const signals = withSignalStore(record);
-  const signal = getOrCreateInternalSignal(signals, record, prop, field.options?.defaultValue ?? null);
-  consumeInternalSignal(signal);
-  return signal.value;
-}
-function peekManagedArray(record, field) {
-  const managedArrayMapForRecord = ManagedArrayMap.get(record);
-  if (managedArrayMapForRecord) {
-    return managedArrayMapForRecord.get(field.name);
-  }
-}
-function peekManagedObject(record, field) {
-  const managedObjectMapForRecord = ManagedObjectMap.get(record);
-  if (managedObjectMapForRecord) {
-    return managedObjectMapForRecord.get(field.name);
-  }
-}
-function computeField(schema, cache, record, identifier, field, prop, editable) {
-  const rawValue = editable ? cache.getAttr(identifier, prop) : cache.getRemoteAttr(identifier, prop);
-  if (!field.type) {
-    return rawValue;
-  }
-  const transform = schema.transformation(field);
-  return transform.hydrate(rawValue, field.options ?? null, record);
-}
-function computeArray(store, schema, cache, record, identifier, field, path, editable, legacy) {
-  const isSchemaArray = field.kind === 'schema-array';
-  // the thing we hand out needs to know its owner and path in a private manner
-  // its "address" is the parent identifier (identifier) + field name (field.name)
-  //  in the nested object case field name here is the full dot path from root resource to this value
-  // its "key" is the field on the parent record
-  // its "owner" is the parent record
-
-  const managedArrayMapForRecord = ManagedArrayMap.get(record);
-  let managedArray;
-  if (managedArrayMapForRecord) {
-    managedArray = managedArrayMapForRecord.get(field.name);
-  }
-  if (managedArray) {
-    return managedArray;
-  } else {
-    const rawValue = editable ? cache.getAttr(identifier, path) : cache.getRemoteAttr(identifier, path);
-    if (!rawValue) {
-      return null;
-    }
-    managedArray = new ManagedArray(store, schema, cache, field, rawValue, identifier, path, record, isSchemaArray, editable, legacy);
-    if (!managedArrayMapForRecord) {
-      ManagedArrayMap.set(record, new Map([[field.name, managedArray]]));
-    } else {
-      managedArrayMapForRecord.set(field.name, managedArray);
-    }
-  }
-  return managedArray;
-}
-function computeObject(schema, cache, record, identifier, field, path, editable, legacy) {
-  const managedObjectMapForRecord = ManagedObjectMap.get(record);
-  let managedObject;
-  if (managedObjectMapForRecord) {
-    managedObject = managedObjectMapForRecord.get(field.name);
-  }
-  if (managedObject) {
-    return managedObject;
-  } else {
-    let rawValue = editable ? cache.getAttr(identifier, path) : cache.getRemoteAttr(identifier, path);
-    if (!rawValue) {
-      return null;
-    }
-    if (field.type) {
-      const transform = schema.transformation(field);
-      rawValue = transform.hydrate(rawValue, field.options ?? null, record);
-    }
-    managedObject = new ManagedObject(schema, cache, field, rawValue, identifier, path, record, editable, legacy);
-    if (!managedObjectMapForRecord) {
-      ManagedObjectMap.set(record, new Map([[field.name, managedObject]]));
-    } else {
-      managedObjectMapForRecord.set(field.name, managedObject);
-    }
-  }
-  return managedObject;
-}
-function computeSchemaObject(store, cache, record, identifier, field, path, legacy, editable) {
-  const schemaObjectMapForRecord = ManagedObjectMap.get(record);
-  let schemaObject;
-  if (schemaObjectMapForRecord) {
-    schemaObject = schemaObjectMapForRecord.get(field.name);
-  }
-  if (schemaObject) {
-    return schemaObject;
-  } else {
-    const rawValue = editable ? cache.getAttr(identifier, path) : cache.getRemoteAttr(identifier, path);
-    if (!rawValue) {
-      return null;
-    }
-    const embeddedPath = path.slice();
-    schemaObject = new SchemaRecord(store, identifier, {
-      [Editable]: editable,
-      [Legacy]: legacy
-    }, true, field.type, embeddedPath);
-  }
-  if (!schemaObjectMapForRecord) {
-    ManagedObjectMap.set(record, new Map([[field.name, schemaObject]]));
-  } else {
-    schemaObjectMapForRecord.set(field.name, schemaObject);
-  }
-  return schemaObject;
-}
-function computeAttribute(cache, identifier, prop, editable) {
-  return editable ? cache.getAttr(identifier, prop) : cache.getRemoteAttr(identifier, prop);
-}
-function computeDerivation(schema, record, identifier, field, prop) {
-  return schema.derivation(field)(record, field.options ?? null, prop);
-}
-
-// TODO probably this should just be a Document
-// but its separate until we work out the lid situation
-class ResourceRelationship {
-  constructor(store, cache, parent, identifier, field, name, editable) {
-    const rawValue = editable ? cache.getRelationship(identifier, name) : cache.getRemoteRelationship(identifier, name);
-
-    // TODO setup true lids for relationship documents
-    // @ts-expect-error we need to give relationship documents a lid
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    this.lid = rawValue.lid ?? rawValue.links?.self ?? `relationship:${identifier.lid}.${name}`;
-    this.data = rawValue.data ? store.peekRecord(rawValue.data) : null;
-    this.name = name;
-    if (macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG)) {
-      this.links = Object.freeze(Object.assign({}, rawValue.links));
-      this.meta = Object.freeze(Object.assign({}, rawValue.meta));
-    } else {
-      this.links = rawValue.links ?? {};
-      this.meta = rawValue.meta ?? {};
-    }
-    this[RecordStore] = store;
-    this[Parent] = parent;
-  }
-  fetch(options) {
-    const url = options?.url ?? getHref(this.links.related) ?? getHref(this.links.self) ?? null;
-    if (!url) {
-      throw new Error(`Cannot ${options?.method ?? 'fetch'} ${this[Parent][Identifier].type}.${String(this.name)} because it has no related link`);
-    }
-    const request = Object.assign({
-      url,
-      method: 'GET'
-    }, options);
-    return this[RecordStore].request(request);
-  }
-}
-defineSignal(ResourceRelationship.prototype, 'data', null);
-defineSignal(ResourceRelationship.prototype, 'links', null);
-defineSignal(ResourceRelationship.prototype, 'meta', null);
-function getHref(link) {
-  if (!link) {
-    return null;
-  }
-  if (typeof link === 'string') {
-    return link;
-  }
-  return link.href;
-}
-function computeResource(store, cache, parent, identifier, field, prop, editable) {
-  if (field.kind !== 'resource') {
-    throw new Error(`The schema for ${identifier.type}.${String(prop)} is not a resource relationship`);
-  }
-  return new ResourceRelationship(store, cache, parent, identifier, field, prop, editable);
-}
-function computeHasMany(store, schema, cache, record, identifier, field, path, editable, legacy) {
-  // the thing we hand out needs to know its owner and path in a private manner
-  // its "address" is the parent identifier (identifier) + field name (field.name)
-  //  in the nested object case field name here is the full dot path from root resource to this value
-  // its "key" is the field on the parent record
-  // its "owner" is the parent record
-
-  const managedArrayMapForRecord = ManagedArrayMap.get(record);
-  let managedArray;
-  if (managedArrayMapForRecord) {
-    managedArray = managedArrayMapForRecord.get(field.name);
-  }
-  if (managedArray) {
-    return managedArray;
-  } else {
-    const rawValue = cache.getRelationship(identifier, field.name);
-    if (!rawValue) {
-      return null;
-    }
-    managedArray = new RelatedCollection({
-      store,
-      type: field.type,
-      identifier,
-      cache,
-      // we divorce the reference here because ManyArray mutates the target directly
-      // before sending the mutation op to the cache. We may be able to avoid this in the future
-      identifiers: rawValue.data?.slice(),
-      key: field.name,
-      meta: rawValue.meta || null,
-      links: rawValue.links || null,
-      isPolymorphic: field.options.polymorphic ?? false,
-      isAsync: field.options.async ?? false,
-      // TODO: Grab the proper value
-      _inverseIsAsync: false,
-      // @ts-expect-error Typescript doesn't have a way for us to thread the generic backwards so it infers unknown instead of T
-      manager: new ManyArrayManager(record, editable),
-      isLoaded: true,
-      allowMutation: editable
-    });
-    if (!managedArrayMapForRecord) {
-      ManagedArrayMap.set(record, new Map([[field.name, managedArray]]));
-    } else {
-      managedArrayMapForRecord.set(field.name, managedArray);
-    }
-  }
-  return managedArray;
-}
-const HAS_MODEL_PACKAGE = dependencySatisfies('@ember-data-mirror/model', '*');
-const getLegacySupport = macroCondition(dependencySatisfies('@ember-data-mirror/model', '*')) ? importSync('@ember-data-mirror/model/-private').lookupLegacySupport : null;
-const IgnoredGlobalFields = new Set(['length', 'nodeType', 'then', 'setInterval', 'document', STRUCTURED]);
-const symbolList = [Destroy, RecordStore, Identifier, Editable, Parent, Checkout, Legacy, EmbeddedPath, EmbeddedType];
-const RecordSymbols = new Set(symbolList);
-function isPathMatch(a, b) {
-  return a.length === b.length && a.every((v, i) => v === b[i]);
-}
-function isNonEnumerableProp(prop) {
-  return prop === 'constructor' || prop === 'prototype' || prop === '__proto__' || prop === 'toString' || prop === 'toJSON' || prop === 'toHTML' || typeof prop === 'symbol';
-}
-const Editables = new WeakMap();
-class SchemaRecord {
-  constructor(store, identifier, Mode, isEmbedded = false, embeddedType = null, embeddedPath = null) {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const self = this;
-    this[RecordStore] = store;
-    if (isEmbedded) {
-      this[Parent] = identifier;
-    } else {
-      this[Identifier] = identifier;
-    }
-    const IS_EDITABLE = this[Editable] = Mode[Editable] ?? false;
-    this[Legacy] = Mode[Legacy] ?? false;
-    const schema = store.schema;
-    const cache = store.cache;
-    const identityField = schema.resource(isEmbedded ? {
-      type: embeddedType
-    } : identifier).identity;
-    const BoundFns = new Map();
-    this[EmbeddedType] = embeddedType;
-    this[EmbeddedPath] = embeddedPath;
-    const fields = isEmbedded ? schema.fields({
-      type: embeddedType
-    }) : schema.fields(identifier);
-    const signals = withSignalStore(this);
-    const proxy = new Proxy(this, {
-      ownKeys() {
-        const identityKey = identityField?.name;
-        const keys = Array.from(fields.keys());
-        if (identityKey) {
-          keys.unshift(identityKey);
-        }
-        return keys;
-      },
-      has(target, prop) {
-        if (prop === Destroy || prop === Checkout) {
-          return true;
-        }
-        return fields.has(prop);
-      },
-      getOwnPropertyDescriptor(target, prop) {
-        const schemaForField = prop === identityField?.name ? identityField : fields.get(prop);
-        macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-          if (!test) {
-            throw new Error(`No field named ${String(prop)} on ${identifier.type}`);
-          }
-        })(schemaForField) : {};
-        if (isNonEnumerableProp(prop)) {
-          return {
-            writable: false,
-            enumerable: false,
-            configurable: true
-          };
-        }
-        switch (schemaForField.kind) {
-          case 'derived':
-            return {
-              writable: false,
-              enumerable: true,
-              configurable: true
-            };
-          case '@id':
-            return {
-              writable: identifier.id === null,
-              enumerable: true,
-              configurable: true
-            };
-          case '@local':
-          case 'field':
-          case 'attribute':
-          case 'resource':
-          case 'alias':
-          case 'belongsTo':
-          case 'hasMany':
-          case 'collection':
-          case 'schema-array':
-          case 'array':
-          case 'schema-object':
-          case 'object':
-            return {
-              writable: IS_EDITABLE,
-              enumerable: true,
-              configurable: true
-            };
-          default:
-            return {
-              writable: false,
-              enumerable: false,
-              configurable: false
-            };
-        }
-      },
-      get(target, prop, receiver) {
-        if (RecordSymbols.has(prop)) {
-          return target[prop];
-        }
-        if (prop === Signals) {
-          return signals;
-        }
-
-        // TODO make this a symbol
-        if (prop === '___notifications') {
-          return target.___notifications;
-        }
-
-        // SchemaRecord reserves use of keys that begin with these characters
-        // for its own usage.
-        // _, @, $, *
-
-        const maybeField = prop === identityField?.name ? identityField : fields.get(prop);
-        if (!maybeField) {
-          if (IgnoredGlobalFields.has(prop)) {
-            return undefined;
-          }
-
-          /////////////////////////////////////////////////////////////
-          //// Note these bound function behaviors are essentially ////
-          //// built-in but overrideable derivations.              ////
-          ////                                                     ////
-          //// The bar for this has to be "basic expectations of   ////
-          ///  an object" – very, very high                        ////
-          /////////////////////////////////////////////////////////////
-
-          if (prop === Symbol.toStringTag || prop === 'toString') {
-            let fn = BoundFns.get('toString');
-            if (!fn) {
-              fn = function () {
-                entangleSignal(signals, receiver, '@identity', null);
-                return `Record<${identifier.type}:${identifier.id} (${identifier.lid})>`;
-              };
-              BoundFns.set(prop, fn);
-            }
-            return fn;
-          }
-          if (prop === 'toHTML') {
-            let fn = BoundFns.get('toHTML');
-            if (!fn) {
-              fn = function () {
-                entangleSignal(signals, receiver, '@identity', null);
-                return `<span>Record<${identifier.type}:${identifier.id} (${identifier.lid})></span>`;
-              };
-              BoundFns.set(prop, fn);
-            }
-            return fn;
-          }
-          if (prop === 'toJSON') {
-            let fn = BoundFns.get('toJSON');
-            if (!fn) {
-              fn = function () {
-                const json = {};
-                for (const key in receiver) {
-                  json[key] = receiver[key];
-                }
-                return json;
-              };
-              BoundFns.set(prop, fn);
-            }
-            return fn;
-          }
-          if (prop === Symbol.toPrimitive) return () => null;
-          if (prop === Symbol.iterator) {
-            let fn = BoundFns.get(Symbol.iterator);
-            if (!fn) {
-              fn = function* () {
-                for (const key in receiver) {
-                  yield [key, receiver[key]];
-                }
-              };
-              BoundFns.set(Symbol.iterator, fn);
-            }
-            return fn;
-          }
-          if (prop === 'constructor') {
-            return SchemaRecord;
-          }
-          // too many things check for random symbols
-          if (typeof prop === 'symbol') return undefined;
-          macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-            {
-              throw new Error(`No field named ${String(prop)} on ${isEmbedded ? embeddedType : identifier.type}`);
-            }
-          })() : {};
-          return undefined;
-        }
-        const field = maybeField.kind === 'alias' ? maybeField.options : maybeField;
-        macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-          if (!test) {
-            throw new Error(`Alias fields cannot alias '@id' '@local' '@hash' or 'derived' fields`);
-          }
-        })(maybeField.kind !== 'alias' || !['@id', '@local', '@hash', 'derived'].includes(maybeField.options.kind)) : {};
-        const propArray = isEmbedded ? embeddedPath.slice() : [];
-        // we use the field.name instead of prop here because we want to use the cache-path not
-        // the record path.
-        propArray.push(field.name);
-        // propArray.push(prop as string);
-
-        switch (field.kind) {
-          case '@id':
-            entangleSignal(signals, receiver, '@identity', null);
-            return identifier.id;
-          case '@hash':
-            // TODO pass actual cache value not {}
-            return schema.hashFn(field)({}, field.options ?? null, field.name ?? null);
-          case '@local':
-            {
-              return computeLocal(receiver, field, prop);
-            }
-          case 'field':
-            entangleSignal(signals, receiver, field.name, null);
-            return computeField(schema, cache, target, identifier, field, propArray, IS_EDITABLE);
-          case 'attribute':
-            entangleSignal(signals, receiver, field.name, null);
-            return computeAttribute(cache, identifier, prop, IS_EDITABLE);
-          case 'resource':
-            entangleSignal(signals, receiver, field.name, null);
-            return computeResource(store, cache, target, identifier, field, prop, IS_EDITABLE);
-          case 'derived':
-            return computeDerivation(schema, receiver, identifier, field, prop);
-          case 'schema-array':
-          case 'array':
-            entangleSignal(signals, receiver, field.name, null);
-            return computeArray(store, schema, cache, target, identifier, field, propArray, Mode[Editable], Mode[Legacy]);
-          case 'object':
-            entangleSignal(signals, receiver, field.name, null);
-            return computeObject(schema, cache, target, identifier, field, propArray, Mode[Editable], Mode[Legacy]);
-          case 'schema-object':
-            entangleSignal(signals, receiver, field.name, null);
-            // run transform, then use that value as the object to manage
-            return computeSchemaObject(store, cache, target, identifier, field, propArray, Mode[Legacy], Mode[Editable]);
-          case 'belongsTo':
-            if (field.options.linksMode) {
-              entangleSignal(signals, receiver, field.name, null);
-              const rawValue = IS_EDITABLE ? cache.getRelationship(identifier, field.name) : cache.getRemoteRelationship(identifier, field.name);
-
-              // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-              return rawValue.data ? store.peekRecord(rawValue.data) : null;
-            }
-            if (!HAS_MODEL_PACKAGE) {
-              macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-                {
-                  throw new Error(`Cannot use belongsTo fields in your schema unless @ember-data-mirror/model is installed to provide legacy model support. ${field.name} should likely be migrated to be a resource field.`);
-                }
-              })() : {};
-            }
-            macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`Expected to have a getLegacySupport function`);
-              }
-            })(getLegacySupport) : {};
-            macroCondition(getGlobalConfig().WarpDriveMirror.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 getLegacySupport(receiver).getBelongsTo(field.name);
-          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]);
-            }
-            if (!HAS_MODEL_PACKAGE) {
-              macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-                {
-                  throw new Error(`Cannot use hasMany fields in your schema unless @ember-data-mirror/model is installed to provide legacy model support.  ${field.name} should likely be migrated to be a collection field.`);
-                }
-              })() : {};
-            }
-            macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`Expected to have a getLegacySupport function`);
-              }
-            })(getLegacySupport) : {};
-            macroCondition(getGlobalConfig().WarpDriveMirror.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 getLegacySupport(receiver).getHasMany(field.name);
-          default:
-            throw new Error(`Field '${String(prop)}' on '${identifier.type}' has the unknown kind '${field.kind}'`);
-        }
-      },
-      set(target, prop, value, receiver) {
-        if (!IS_EDITABLE) {
-          const type = isEmbedded ? embeddedType : identifier.type;
-          throw new Error(`Cannot set ${String(prop)} on ${type} because the record is not editable`);
-        }
-        const maybeField = prop === identityField?.name ? identityField : fields.get(prop);
-        if (!maybeField) {
-          const type = isEmbedded ? embeddedType : identifier.type;
-          throw new Error(`There is no field named ${String(prop)} on ${type}`);
-        }
-        const field = maybeField.kind === 'alias' ? maybeField.options : maybeField;
-        macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-          if (!test) {
-            throw new Error(`Alias fields cannot alias '@id' '@local' '@hash' or 'derived' fields`);
-          }
-        })(maybeField.kind !== 'alias' || !['@id', '@local', '@hash', 'derived'].includes(maybeField.options.kind)) : {};
-        const propArray = isEmbedded ? embeddedPath.slice() : [];
-        // we use the field.name instead of prop here because we want to use the cache-path not
-        // the record path.
-        propArray.push(field.name);
-        // propArray.push(prop as string);
-
-        switch (field.kind) {
-          case '@id':
-            {
-              macroCondition(getGlobalConfig().WarpDriveMirror.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().WarpDriveMirror.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error(`Cannot set ${identifier.type} record's id to ${normalizedId}, because id is already ${identifier.id}`);
-                }
-              })(!didChange || identifier.id === null) : {};
-              if (normalizedId !== null && didChange) {
-                store._instanceCache.setRecordId(identifier, normalizedId);
-                store.notifications.notify(identifier, 'identity');
-              }
-              return true;
-            }
-          case '@local':
-            {
-              const signal = getOrCreateInternalSignal(signals, receiver, prop, field.options?.defaultValue ?? null);
-              if (signal.value !== value) {
-                signal.value = value;
-                notifyInternalSignal(signal);
-              }
-              return true;
-            }
-          case 'field':
-            {
-              if (!field.type) {
-                cache.setAttr(identifier, propArray, value);
-                return true;
-              }
-              const transform = schema.transformation(field);
-              const rawValue = transform.serialize(value, field.options ?? null, target);
-              cache.setAttr(identifier, propArray, rawValue);
-              return true;
-            }
-          case 'attribute':
-            {
-              cache.setAttr(identifier, propArray, value);
-              return true;
-            }
-          case 'array':
-            {
-              if (!field.type) {
-                cache.setAttr(identifier, propArray, value?.slice());
-                const peeked = peekManagedArray(self, field);
-                if (peeked) {
-                  macroCondition(getGlobalConfig().WarpDriveMirror.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().WarpDriveMirror.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().WarpDriveMirror.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().WarpDriveMirror.env.DEBUG) ? (test => {
-                  if (!test) {
-                    throw new Error(`Expected value to be an object`);
-                  }
-                })(typeof value === 'object') : {};
-                newValue = {
-                  ...value
-                };
-                const schemaFields = schema.fields({
-                  type: field.type
-                });
-                for (const key of Object.keys(newValue)) {
-                  if (!schemaFields.has(key)) {
-                    throw new Error(`Field ${key} does not exist on schema object ${field.type}`);
-                  }
-                }
-              } else {
-                ManagedObjectMap.delete(target);
-              }
-              cache.setAttr(identifier, propArray, newValue);
-              // const peeked = peekManagedObject(self, field);
-              // if (peeked) {
-              //   const objSignal = peeked[OBJECT_SIGNAL];
-              //   objSignal.isStale = true;
-              // }
-              return true;
-            }
-          case 'derived':
-            {
-              throw new Error(`Cannot set ${String(prop)} on ${identifier.type} because it is derived`);
-            }
-          case 'belongsTo':
-            if (!HAS_MODEL_PACKAGE) {
-              macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-                {
-                  throw new Error(`Cannot use belongsTo fields in your schema unless @ember-data-mirror/model is installed to provide legacy model support. ${field.name} should likely be migrated to be a resource field.`);
-                }
-              })() : {};
-            }
-            macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`Expected to have a getLegacySupport function`);
-              }
-            })(getLegacySupport) : {};
-            macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`Can only use belongsTo fields when the resource is in legacy mode`);
-              }
-            })(Mode[Legacy]) : {};
-            store._join(() => {
-              getLegacySupport(receiver).setDirtyBelongsTo(field.name, value);
-            });
-            return true;
-          case 'hasMany':
-            if (!HAS_MODEL_PACKAGE) {
-              macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-                {
-                  throw new Error(`Cannot use hasMany fields in your schema unless @ember-data-mirror/model is installed to provide legacy model support.  ${field.name} should likely be migrated to be a collection field.`);
-                }
-              })() : {};
-            }
-            macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`Expected to have a getLegacySupport function`);
-              }
-            })(getLegacySupport) : {};
-            macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
-              }
-            })(Mode[Legacy]) : {};
-            macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`You must pass an array of records to set a hasMany relationship`);
-              }
-            })(Array.isArray(value)) : {};
-            store._join(() => {
-              const support = getLegacySupport(receiver);
-              const manyArray = support.getManyArray(field.name);
-              manyArray.splice(0, manyArray.length, ...value);
-            });
-            return true;
-          default:
-            throw new Error(`Unknown field kind ${field.kind}`);
-        }
-      }
-    });
-
-    // what signal do we need for embedded record?
-    this.___notifications = store.notifications.subscribe(identifier, (_, type, key) => {
-      switch (type) {
-        case 'identity':
-          {
-            if (isEmbedded || !identityField) return; // base paths never apply to embedded records
-
-            if (identityField.name && identityField.kind === '@id') {
-              const signal = signals.get('@identity');
-              if (signal) {
-                notifyInternalSignal(signal);
-              }
-            }
-            break;
-          }
-        case 'attributes':
-          if (key) {
-            if (Array.isArray(key)) {
-              if (!isEmbedded) return; // deep paths will be handled by embedded records
-              // TODO we should have the notification manager
-              // ensure it is safe for each callback to mutate this array
-              if (isPathMatch(embeddedPath, key)) {
-                // handle the notification
-                // TODO we should likely handle this notification here
-                // also we should add a LOGGING flag
-                // eslint-disable-next-line no-console
-                console.warn(`Notification unhandled for ${key.join(',')} on ${identifier.type}`, self);
-                return;
-              }
-
-              // TODO we should add a LOGGING flag
-              // console.log(`Deep notification skipped for ${key.join('.')} on ${identifier.type}`, self);
-              // deep notify the key path
-            } else {
-              if (isEmbedded) return; // base paths never apply to embedded records
-
-              // TODO determine what LOGGING flag to wrap this in if any
-              // console.log(`Notification for ${key} on ${identifier.type}`, self);
-              const signal = signals.get(key);
-              if (signal) {
-                notifyInternalSignal(signal);
-              }
-              const field = fields.get(key);
-              if (field?.kind === 'array' || field?.kind === 'schema-array') {
-                const peeked = peekManagedArray(self, field);
-                if (peeked) {
-                  macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-                    if (!test) {
-                      throw new Error(`Expected the peekManagedArray for ${field.kind} to return a ManagedArray`);
-                    }
-                  })(ARRAY_SIGNAL in peeked) : {};
-                  const arrSignal = peeked[ARRAY_SIGNAL];
-                  notifyInternalSignal(arrSignal);
-                }
-              }
-              if (field?.kind === 'object') {
-                const peeked = peekManagedObject(self, field);
-                if (peeked) {
-                  const objSignal = peeked[OBJECT_SIGNAL];
-                  notifyInternalSignal(objSignal);
-                }
-              }
-            }
-          }
-          break;
-        case 'relationships':
-          if (key) {
-            if (Array.isArray(key)) ;else {
-              if (isEmbedded) return; // base paths never apply to embedded records
-
-              const field = fields.get(key);
-              macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error(`Expected relationshp ${key} to be the name of a field`);
-                }
-              })(field) : {};
-              if (field.kind === 'belongsTo') {
-                // TODO determine what LOGGING flag to wrap this in if any
-                // console.log(`Notification for ${key} on ${identifier.type}`, self);
-                const signal = signals.get(key);
-                if (signal) {
-                  notifyInternalSignal(signal);
-                }
-                // FIXME
-              } else if (field.kind === 'resource') ;else if (field.kind === 'hasMany') {
-                if (field.options.linksMode) {
-                  const peeked = peekManagedArray(self, field);
-                  if (peeked) {
-                    notifyInternalSignal(peeked[ARRAY_SIGNAL]);
-                  }
-                  return;
-                }
-                macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-                  if (!test) {
-                    throw new Error(`Expected to have a getLegacySupport function`);
-                  }
-                })(getLegacySupport) : {};
-                macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-                  if (!test) {
-                    throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
-                  }
-                })(Mode[Legacy]) : {};
-                const support = getLegacySupport(proxy);
-                const manyArray = support && support._manyArrayCache[key];
-                const hasPromise = support && support._relationshipPromisesCache[key];
-                if (manyArray && hasPromise) {
-                  // do nothing, we will notify the ManyArray directly
-                  // once the fetch has completed.
-                  return;
-                }
-                if (manyArray) {
-                  notifyInternalSignal(manyArray[ARRAY_SIGNAL]);
-                  macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-                    if (!test) {
-                      throw new Error(`Expected options to exist on relationship meta`);
-                    }
-                  })(field.options) : {};
-                  macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-                    if (!test) {
-                      throw new Error(`Expected async to exist on relationship meta options`);
-                    }
-                  })('async' in field.options) : {};
-                  if (field.options.async) {
-                    const signal = signals.get(key);
-                    if (signal) {
-                      notifyInternalSignal(signal);
-                    }
-                  }
-                }
-              } else if (field.kind === 'collection') ;
-            }
-          }
-          break;
-      }
-    });
-    if (macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG)) {
-      Object.defineProperty(this, '__SHOW_ME_THE_DATA_(debug mode only)__', {
-        enumerable: false,
-        configurable: true,
-        get() {
-          const data = {};
-          for (const key of fields.keys()) {
-            data[key] = proxy[key];
-          }
-          return data;
-        }
-      });
-    }
-    return proxy;
-  }
-  [Destroy]() {
-    if (this[Legacy]) {
-      // @ts-expect-error
-      this.isDestroying = true;
-      // @ts-expect-error
-      this.isDestroyed = true;
-    }
-    this[RecordStore].notifications.unsubscribe(this.___notifications);
-  }
-  [Checkout]() {
-    // IF we are already the editable record, throw an error
-    if (this[Editable]) {
-      throw new Error(`Cannot checkout an already editable record`);
-    }
-    const editable = Editables.get(this);
-    if (editable) {
-      return Promise.resolve(editable);
-    }
-    const embeddedType = this[EmbeddedType];
-    const embeddedPath = this[EmbeddedPath];
-    const isEmbedded = embeddedType !== null && embeddedPath !== null;
-    if (isEmbedded) {
-      throw new Error(`Cannot checkout an embedded record (yet)`);
-    }
-    const editableRecord = new SchemaRecord(this[RecordStore], this[Identifier], {
-      [Editable]: true,
-      [Legacy]: this[Legacy]
-    }, isEmbedded, embeddedType, embeddedPath);
-    setRecordIdentifier(editableRecord, recordIdentifierFor(this));
-    return Promise.resolve(editableRecord);
-  }
-}
-function instantiateRecord(store, identifier, createArgs) {
-  const schema = store.schema;
-  const resourceSchema = schema.resource(identifier);
-  macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Expected a resource schema`);
-    }
-  })(isResourceSchema(resourceSchema)) : {};
-  const isLegacy = resourceSchema?.legacy ?? false;
-  const isEditable = isLegacy || store.cache.isNew(identifier);
-  const record = new SchemaRecord(store, identifier, {
-    [Editable]: isEditable,
-    [Legacy]: isLegacy
-  });
-  if (createArgs) {
-    Object.assign(record, createArgs);
-  }
-  return record;
-}
-function assertSchemaRecord(record) {
-  macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error('Expected a SchemaRecord');
-    }
-  })(record && typeof record === 'object' && Destroy in record) : {};
-}
-function teardownRecord(record) {
-  assertSchemaRecord(record);
-  record[Destroy]();
-}
-
-/**
- * @module @warp-drive-mirror/schema-record
- */
-const Support = getOrSetGlobal('Support', new WeakMap());
-const ConstructorField = {
-  type: '@constructor',
-  name: 'constructor',
-  kind: 'derived'
-};
-const TypeField = {
-  type: '@identity',
-  name: '$type',
-  kind: 'derived',
-  options: {
-    key: 'type'
-  }
-};
-const DefaultIdentityField = {
-  name: 'id',
-  kind: '@id'
-};
-function _constructor(record) {
-  let state = Support.get(record);
-  if (!state) {
-    state = {};
-    Support.set(record, state);
-  }
-  return state._constructor = state._constructor || {
-    name: `SchemaRecord<${recordIdentifierFor$1(record).type}>`,
-    get modelName() {
-      macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-        {
-          throw new Error(`record.constructor.modelName is not available outside of legacy mode`);
-        }
-      })() : {};
-      return undefined;
-    }
-  };
-}
-_constructor[Type] = '@constructor';
-
-/**
- * Utility for constructing a ResourceSchema with the recommended
- * fields for the PolarisMode experience.
- *
- * Using this requires registering the PolarisMode derivations
- *
- * ```ts
- * import { registerDerivations } from '@warp-drive-mirror/schema-record';
- *
- * registerDerivations(schema);
- * ```
- *
- * @method withDefaults
- * @for @warp-drive-mirror/schema-record
- * @static
- * @public
- * @param schema
- * @return {PolarisResourceSchema}
- */
-function withDefaults(schema) {
-  schema.identity = schema.identity || DefaultIdentityField;
-
-  // because fields gets iterated in definition order,
-  // we add TypeField to the beginning so that it will
-  // appear right next to the identity field
-  schema.fields.unshift(TypeField);
-  schema.fields.push(ConstructorField);
-  return schema;
-}
-
-/**
- * A derivation that computes its value from the
- * record's identity.
- *
- * It can be used via a derived field definition like:
- *
- * ```ts
- * {
- *   kind: 'derived',
- *   name: 'id',
- *   type: '@identity',
- *   options: { key: 'id' }
- * }
- * ```
- *
- * Valid keys are `'id'`, `'lid'`, `'type'`, and `'^'`.
- *
- * `^` returns the entire identifier object.
- *
- * @method fromIdentity
- * @for @warp-drive-mirror/schema-record
- * @static
- * @public
- */
-
-function fromIdentity(record, options, key) {
-  const identifier = record[Identifier];
-  macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Cannot compute @identity for a record without an identifier`);
-    }
-  })(identifier) : {};
-  macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Expected to receive a key to compute @identity, but got ${String(options)}`);
-    }
-  })(options?.key && ['lid', 'id', 'type', '^'].includes(options.key)) : {};
-  return options.key === '^' ? identifier : identifier[options.key];
-}
-fromIdentity[Type] = '@identity';
-
-/**
- * Registers the default derivations for records that want
- * to use the PolarisMode defaults provided by
- *
- * ```ts
- * import { withDefaults } from '@warp-drive-mirror/schema-record';
- * ```
- *
- * @method registerDerivations
- * @for @warp-drive-mirror/schema-record
- * @static
- * @public
- * @param {SchemaService} schema
- */
-function registerDerivations(schema) {
-  schema.registerDerivation(fromIdentity);
-  schema.registerDerivation(_constructor);
-}
-/**
- * Wraps a derivation in a new function with Derivation signature but that looks
- * up the value in the cache before recomputing.
- *
- * @internal
- */
-function makeCachedDerivation(derivation) {
-  const memoizedDerivation = (record, options, prop) => {
-    const signals = withSignalStore(record);
-    let signal = signals.get(prop);
-    if (!signal) {
-      signal = createMemo(record, prop, () => {
-        return derivation(record, options, prop);
-      }); // a total lie, for convenience of reusing the storage
-      signals.set(prop, signal);
-    }
-    return signal();
-  };
-  memoizedDerivation[Type] = derivation[Type];
-  return memoizedDerivation;
-}
-/**
- * A SchemaService designed to work with dynamically registered schemas.
- *
- * @class SchemaService
- * @public
- */
-class SchemaService {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-  constructor() {
-    this._schemas = new Map();
-    this._transforms = new Map();
-    this._hashFns = new Map();
-    this._derivations = new Map();
-    this._traits = new Set();
-  }
-  resourceTypes() {
-    return Array.from(this._schemas.keys());
-  }
-  hasTrait(type) {
-    return this._traits.has(type);
-  }
-  resourceHasTrait(resource, trait) {
-    return this._schemas.get(resource.type).traits.has(trait);
-  }
-  transformation(field) {
-    const kind = 'kind' in field ? field.kind : '<unknown kind>';
-    const name = 'name' in field ? field.name : '<unknown name>';
-    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`'${kind}' fields cannot be transformed. Only fields of kind 'field' 'object' or 'array' can specify a transformation. Attempted to find '${field.type ?? '<unknown type>'}' on field '${name}'.`);
-      }
-    })(!('kind' in field) || ['field', 'object', 'array'].includes(kind)) : {};
-    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Expected the '${kind}' field '${name}' to specify a transformation via 'field.type', but none was present`);
-      }
-    })(field.type) : {};
-    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`No transformation registered with name '${field.type}' for '${kind}' field '${name}'`);
-      }
-    })(this._transforms.has(field.type)) : {};
-    return this._transforms.get(field.type);
-  }
-  derivation(field) {
-    const kind = 'kind' in field ? field.kind : '<unknown kind>';
-    const name = 'name' in field ? field.name : '<unknown name>';
-    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`The '${kind}' field '${name}' is not derived and so cannot be used to lookup a derivation`);
-      }
-    })(!('kind' in field) || kind === 'derived') : {};
-    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Expected the '${kind}' field '${name}' to specify a derivation via 'field.type', but no value was present`);
-      }
-    })(field.type) : {};
-    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`No '${field.type}' derivation registered for use by the '${kind}' field '${name}'`);
-      }
-    })(this._derivations.has(field.type)) : {};
-    return this._derivations.get(field.type);
-  }
-  hashFn(field) {
-    const kind = 'kind' in field ? field.kind : '<unknown kind>';
-    const name = 'name' in field ? field.name : '<unknown name>';
-    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`The '${kind}' field '${name}' is not a HashField and so cannot be used to lookup a hash function`);
-      }
-    })(!('kind' in field) || kind === '@hash') : {};
-    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Expected the '${kind}' field '${name}' to specify a hash function via 'field.type', but no value was present`);
-      }
-    })(field.type) : {};
-    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`No '${field.type}' hash function is registered for use by the '${kind}' field '${name}'`);
-      }
-    })(this._hashFns.has(field.type)) : {};
-    return this._hashFns.get(field.type);
-  }
-  resource(resource) {
-    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`No resource registered with name '${resource.type}'`);
-      }
-    })(this._schemas.has(resource.type)) : {};
-    return this._schemas.get(resource.type).original;
-  }
-  registerResources(schemas) {
-    schemas.forEach(schema => {
-      this.registerResource(schema);
-    });
-  }
-  registerResource(schema) {
-    const fields = new Map();
-    const relationships = {};
-    const attributes = {};
-    schema.fields.forEach(field => {
-      macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-        if (!test) {
-          throw new Error(`${field.kind} is not valid inside a ResourceSchema's fields.`);
-        }
-      })(
-      // @ts-expect-error we are checking for mistakes at runtime
-      field.kind !== '@id' && field.kind !== '@hash') : {};
-      fields.set(field.name, field);
-      if (field.kind === 'attribute') {
-        attributes[field.name] = field;
-      } else if (field.kind === 'belongsTo' || field.kind === 'hasMany') {
-        relationships[field.name] = field;
-      }
-    });
-    const traits = new Set(isResourceSchema(schema) ? schema.traits : []);
-    traits.forEach(trait => {
-      this._traits.add(trait);
-    });
-    const internalSchema = {
-      original: schema,
-      fields,
-      relationships,
-      attributes,
-      traits
-    };
-    this._schemas.set(schema.type, internalSchema);
-  }
-  registerTransformation(transformation) {
-    this._transforms.set(transformation[Type], transformation);
-  }
-  registerDerivation(derivation) {
-    this._derivations.set(derivation[Type], makeCachedDerivation(derivation));
-  }
-  registerHashFn(hashFn) {
-    this._hashFns.set(hashFn[Type], hashFn);
-  }
-  fields({
-    type
-  }) {
-    const schema = this._schemas.get(type);
-    if (!schema) {
-      throw new Error(`No schema defined for ${type}`);
-    }
-    return schema.fields;
-  }
-  hasResource(resource) {
-    return this._schemas.has(resource.type);
-  }
-}
-if (macroCondition(getGlobalConfig().WarpDriveMirror.deprecations.ENABLE_LEGACY_SCHEMA_SERVICE)) {
-  SchemaService.prototype.attributesDefinitionFor = function ({
-    type
-  }) {
-    deprecate(`Use \`schema.fields({ type })\` instead of \`schema.attributesDefinitionFor({ type })\``, false, {
-      id: 'ember-data-mirror:schema-service-updates',
-      until: '6.0',
-      for: 'ember-data-mirror',
-      since: {
-        available: '4.13',
-        enabled: '5.4'
-      }
-    });
-    const schema = this._schemas.get(type);
-    if (!schema) {
-      throw new Error(`No schema defined for ${type}`);
-    }
-    return schema.attributes;
-  };
-  SchemaService.prototype.relationshipsDefinitionFor = function ({
-    type
-  }) {
-    deprecate(`Use \`schema.fields({ type })\` instead of \`schema.relationshipsDefinitionFor({ type })\``, false, {
-      id: 'ember-data-mirror:schema-service-updates',
-      until: '6.0',
-      for: 'ember-data-mirror',
-      since: {
-        available: '4.13',
-        enabled: '5.4'
-      }
-    });
-    const schema = this._schemas.get(type);
-    if (!schema) {
-      throw new Error(`No schema defined for ${type}`);
-    }
-    return schema.relationships;
-  };
-  SchemaService.prototype.doesTypeExist = function (type) {
-    deprecate(`Use \`schema.hasResource({ type })\` instead of \`schema.doesTypeExist(type)\``, false, {
-      id: 'ember-data-mirror:schema-service-updates',
-      until: '6.0',
-      for: 'ember-data-mirror',
-      since: {
-        available: '4.13',
-        enabled: '5.4'
-      }
-    });
-    return this._schemas.has(type);
-  };
-}
-export { Checkout, SchemaService, fromIdentity, instantiateRecord, registerDerivations, teardownRecord, withDefaults };
+export { Checkout, SchemaService, fromIdentity, instantiateRecord, registerDerivations, teardownRecord, withDefaults } from '@warp-drive-mirror/core/reactive';