@warp-drive/core 5.7.0-alpha.9 → 5.7.0-beta.0

package/dist/reactive.js

@@ -1,1926 +1,16 @@
+import { L as ReactiveResource, M as isNonIdentityCacheableField, N as getFieldCacheKeyStrict, r as recordIdentifierFor, H as withSignalStore, G as createInternalMemo } from "./request-state-C955e0AL.js";
+export { O as checkout, P as commit } from "./request-state-C955e0AL.js";
 import { isResourceSchema } from './types/schema/fields.js';
-import { F as withSignalStore, T as isExtensionProp, U as performExtensionSet, H as consumeInternalSignal, V as performArrayExtensionGet, x as entangleSignal, E as peekInternalSignal, d as SOURCE$1, f as fastPush, l as RelatedCollection, J as getOrCreateInternalSignal, G as notifyInternalSignal, W as performObjectExtensionGet, y as defineSignal, B as Signals, h as setRecordIdentifier, r as recordIdentifierFor } from "./request-state-CeN66aML.js";
-import { EnableHydration, STRUCTURED } from './types/request.js';
+import { D as Destroy, C as Context } from "./symbols-sql1_mdx.js";
+export { a as Checkout } from "./symbols-sql1_mdx.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { warn, deprecate } from '@ember/debug';
+import './index.js';
+import './types/request.js';
 import './utils/string.js';
-import { A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, c as createMemo } from "./configure-B48bFHOl.js";
-import { RecordStore, Type } from './types/symbols.js';
-import { S as SOURCE, E as Editable, L as Legacy, D as Destroy, I as Identifier, P as Parent, a as EmbeddedPath, C as Checkout, b as EmbeddedField } from "./symbols-SIstXMLI.js";
+import "./configure-C3x8YXzL.js";
 import { getOrSetGlobal } from './types/-private.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']);
-function isArrayGetter(prop) {
-  return ARRAY_GETTER_METHODS.has(prop);
-}
-const ARRAY_SETTER_METHODS = new Set(['push', 'pop', 'unshift', 'shift', 'splice', 'sort']);
-function isArraySetter(prop) {
-  return ARRAY_SETTER_METHODS.has(prop);
-}
-
-// function isSelfProp<T extends object>(self: T, prop: KeyType): prop is keyof T {
-//   return prop in self;
-// }
-
-function convertToInt(prop) {
-  if (typeof prop === 'symbol') return null;
-  const num = Number(prop);
-  if (isNaN(num)) return null;
-  return num % 1 === 0 ? num : null;
-}
-function safeForEach(instance, arr, store, callback, target) {
-  if (target === undefined) {
-    target = null;
-  }
-  // clone to prevent mutation
-  arr = arr.slice();
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error('`forEach` expects a function as first argument.');
-    }
-  })(typeof callback === 'function') : {};
-
-  // because we retrieveLatest above we need not worry if array is mutated during iteration
-  // by unloadRecord/rollbackAttributes
-  // push/add/removeObject may still be problematic
-  // but this is a more traditionally expected forEach bug.
-  const length = arr.length; // we need to access length to ensure we are consumed
-
-  for (let index = 0; index < length; index++) {
-    callback.call(target, arr[index], index, instance);
-  }
-  return instance;
-}
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-class ManagedArray {
-  constructor(context, owner, data) {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const self = this;
-    this[SOURCE] = data?.slice();
-    const IS_EDITABLE = this[Editable] = context.editable ?? false;
-    this[Legacy] = context.legacy;
-    const schema = context.store.schema;
-    const cache = context.store.cache;
-    const {
-      field
-    } = context;
-    const signals = withSignalStore(this);
-    let _SIGNAL = null;
-    const boundFns = new Map();
-    this.identifier = context.resourceKey;
-    this.path = context.path;
-    this.owner = owner;
-    let transaction = false;
-    const KeyMode = field.options?.key ?? '@identity';
-    // listener.
-    const RefStorage = KeyMode === '@identity' ? WeakMap :
-    // CAUTION CAUTION CAUTION
-    // this is a pile of lies
-    // the Map is Map<string, WeakRef<ReactiveResource>>
-    // 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 = field.kind === 'schema-array' ? new RefStorage() : null;
-    const extensions = context.legacy ? schema.CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field) : null;
-    const proxy = new Proxy(this[SOURCE], {
-      get(target, prop, receiver) {
-        if (prop === ARRAY_SIGNAL) {
-          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(context.resourceKey, context.path);
-          if (newData && newData !== self[SOURCE]) {
-            self[SOURCE].length = 0;
-            self[SOURCE].push(...newData);
-          }
-        }
-        if (prop === 'length') {
-          return consumeInternalSignal(_SIGNAL), target.length;
-        }
-        if (prop === '[]') return consumeInternalSignal(_SIGNAL), receiver;
-        if (index !== null) {
-          if (!transaction) {
-            consumeInternalSignal(_SIGNAL);
-          }
-          const rawValue = target[index];
-          if (field.kind === 'array') {
-            if (field.type) {
-              const transform = schema.transformation(field);
-              return transform.hydrate(rawValue, field.options ?? null, self.owner);
-            }
-            return rawValue;
-          }
-
-          /**
-           * When the array is polymorphic, we need to determine the real type
-           * in order to apply the correct identity as schema-object identity
-           * is only required to be unique by type
-           */
-          let objectType;
-          if (field.options?.polymorphic) {
-            const typePath = field.options.type ?? 'type';
-            // if we are polymorphic, then context.field.options.type will
-            // either specify a path on the rawValue to use as the type, defaulting to "type" or
-            // the special string "@hash" which tells us to treat field.type as a hashFn name with which
-            // to calc the type.
-            if (typePath === '@hash') {
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error(`Expected the field to define a hashFn as its type`);
-                }
-              })(field.type) : {};
-              const hashFn = schema.hashFn({
-                type: field.type
-              });
-              // TODO consider if there are better options and name args we could provide.
-              objectType = hashFn(rawValue, null, null);
-            } else {
-              objectType = rawValue[typePath];
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error(`Expected the type path for the field to be a value on the raw object`);
-                }
-              })(typePath && objectType && typeof objectType === 'string') : {};
-            }
-          } else {
-            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`A non-polymorphic SchemaArrayField must provide a SchemaObject type in its definition`);
-              }
-            })(field.type) : {};
-            objectType = field.type;
-          }
-
-          /**
-           * When KeyMode=@hash the ReactiveResource is keyed into
-           * ManagedRecordRefs by the return value of @hash on the rawValue.
-           *
-           * This means that we could find a way to only recompute the identity
-           * when ARRAY_SIGNAL is dirty if hash performance becomes a bottleneck.
-           */
-          let schemaObjectKeyValue;
-          if (KeyMode === '@hash') {
-            const hashField = schema.resource({
-              type: objectType
-            }).identity;
-            const hashFn = schema.hashFn(hashField);
-            schemaObjectKeyValue = hashFn(rawValue, hashField.options ?? null, hashField.name);
-          } else {
-            // if mode is not @identity or @index, then access the key path.
-            // we should assert that `mode` is a string
-            // 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 (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-              const isPathKeyMode = KeyMode !== '@identity' && KeyMode !== '@index';
-              if (isPathKeyMode) {
-                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                  if (!test) {
-                    throw new Error('mode must be a string');
-                  }
-                })(typeof KeyMode === 'string' && KeyMode !== '') : {};
-                const modeField = schema.fields({
-                  type: objectType
-                }).get(KeyMode);
-                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                  if (!test) {
-                    throw new Error('field must exist in schema');
-                  }
-                })(modeField) : {};
-                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                  if (!test) {
-                    throw new Error('field must be a GenericField or LegacyAttributeField');
-                  }
-                })(modeField.kind === 'field' || modeField.kind === 'attribute') : {};
-              }
-            }
-            schemaObjectKeyValue = KeyMode === '@identity' ? rawValue : KeyMode === '@index' ? index : rawValue[KeyMode];
-          }
-          if (!schemaObjectKeyValue) {
-            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-              {
-                throw new Error(`Unexpected out of bounds access on SchemaArray`);
-              }
-            })() : {};
-            return undefined;
-          }
-          const recordRef = ManagedRecordRefs.get(schemaObjectKeyValue);
-          const record = recordRef?.value.deref();
-
-          // confirm the type and key still match
-          if (record && recordRef.type === objectType && recordRef.identity === schemaObjectKeyValue) {
-            if (recordRef.index !== index) {
-              recordRef.index = index;
-              recordRef.context.path[recordRef.context.path.length - 1] = index;
-            }
-            return record;
-          } else if (record) {
-            // TODO schedule idle once we can
-            void Promise.resolve().then(() => {
-              record[Destroy]();
-            });
-          }
-          const recordPath = context.path.slice();
-          // this is a dirty lie since path is string[] but really we
-          // should change the types for paths to `Array<string | number>`
-          recordPath.push(index);
-          const objectContext = {
-            store: context.store,
-            resourceKey: context.resourceKey,
-            modeName: context.modeName,
-            legacy: context.legacy,
-            editable: context.editable,
-            path: recordPath,
-            field: field,
-            value: objectType
-          };
-          const schemaObject = new ReactiveResource(objectContext);
-          ManagedRecordRefs.set(schemaObjectKeyValue, {
-            type: objectType,
-            identity: schemaObjectKeyValue,
-            index,
-            context: objectContext,
-            value: new WeakRef(schemaObject)
-          });
-          return schemaObject;
-        }
-        if (isArrayGetter(prop)) {
-          let fn = boundFns.get(prop);
-          if (fn === undefined) {
-            if (prop === 'forEach') {
-              fn = function () {
-                consumeInternalSignal(_SIGNAL);
-                transaction = true;
-                const result = safeForEach(receiver, target, context.store, arguments[0], arguments[1]);
-                transaction = false;
-                return result;
-              };
-            } else {
-              fn = function () {
-                consumeInternalSignal(_SIGNAL);
-                // array functions must run through Reflect to work properly
-                // binding via other means will not work.
-                transaction = true;
-                const result = Reflect.apply(target[prop], receiver, arguments);
-                transaction = false;
-                return result;
-              };
-            }
-            boundFns.set(prop, fn);
-          }
-          return fn;
-        }
-        if (isArraySetter(prop)) {
-          let fn = boundFns.get(prop);
-          if (fn === undefined) {
-            fn = function () {
-              if (!IS_EDITABLE) {
-                throw new Error(`Mutating this array via ${String(prop)} is not allowed because the record is not editable`);
-              }
-              consumeInternalSignal(_SIGNAL);
-              transaction = true;
-              const result = Reflect.apply(target[prop], receiver, arguments);
-              transaction = false;
-              return result;
-            };
-            boundFns.set(prop, fn);
-          }
-          return fn;
-        }
-        if (isExtensionProp(extensions, prop)) {
-          return performArrayExtensionGet(receiver, extensions, signals, prop, _SIGNAL, boundFns, v => void (transaction = v));
-        }
-        return Reflect.get(target, prop, receiver);
-      },
-      set(target, prop, value, receiver) {
-        if (!IS_EDITABLE) {
-          let errorPath = 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`);
-        }
-        if (prop === 'identifier') {
-          self.identifier = value;
-          return true;
-        }
-        if (prop === 'owner') {
-          self.owner = value;
-          return true;
-        }
-        if (isExtensionProp(extensions, prop)) {
-          return performExtensionSet(receiver, extensions, signals, prop, value);
-        }
-        const reflect = Reflect.set(target, prop, value, receiver);
-        if (reflect) {
-          if (!field.type) {
-            cache.setAttr(context.resourceKey, context.path, self[SOURCE]);
-            _SIGNAL.isStale = true;
-            return true;
-          }
-          let rawValue = self[SOURCE];
-          if (field.kind !== 'schema-array') {
-            const transform = schema.transformation(field);
-            if (!transform) {
-              throw new Error(`No '${field.type}' transform defined for use by ${context.resourceKey.type}.${String(prop)}`);
-            }
-            rawValue = self[SOURCE].map(item => transform.serialize(item, field.options ?? null, self.owner));
-          }
-          cache.setAttr(context.resourceKey, context.path, rawValue);
-          _SIGNAL.isStale = true;
-        }
-        return reflect;
-      },
-      has(target, prop) {
-        if (prop === 'identifier' || prop === 'owner' || prop === ARRAY_SIGNAL) {
-          return true;
-        }
-        return Reflect.has(target, prop);
-      }
-    });
-
-    // we entangle the signal on the returned proxy since that is
-    // the object that other code will be interfacing with.
-    _SIGNAL = entangleSignal(signals, proxy, ARRAY_SIGNAL, undefined);
-    return proxy;
-  }
-}
-
-// this will error if someone tries to call
-// A(identifierArray) since it is not configurable
-// which is preferable to the `meta` override we used
-// before which required importing all of Ember
-const desc = {
-  enumerable: true,
-  configurable: false,
-  get: function () {
-    // here to support computed chains
-    // and {{#each}}
-    if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_COMPUTED_CHAINS)) {
-      return this;
-    }
-  }
-};
-// compat(desc);
-Object.defineProperty(ManagedArray.prototype, '[]', desc);
-function getArrayField(context) {
-  const signal = entangleSignal(context.signals, context.record, context.path.at(-1), null);
-  // the thing we hand out needs to know its owner and path in a private manner
-  // its "address" is the parent identifier (identifier) + field name (field.name)
-  //  in the nested object case field name here is the full dot path from root resource to this value
-  // its "key" is the field on the parent record
-  // its "owner" is the parent record
-  const {
-    record
-  } = context;
-  let managedArray = signal.value;
-  if (managedArray) {
-    return managedArray;
-  } else {
-    const {
-      store,
-      resourceKey,
-      path
-    } = context;
-    const {
-      cache
-    } = store;
-    const rawValue = context.editable ? cache.getAttr(resourceKey, path) : cache.getRemoteAttr(resourceKey, path);
-    if (!rawValue) {
-      return null;
-    }
-    managedArray = new ManagedArray(context, record, rawValue);
-    signal.value = managedArray;
-  }
-  return managedArray;
-}
-function setArrayField(context) {
-  const {
-    field,
-    record,
-    value
-  } = context;
-  const {
-    cache,
-    schema
-  } = context.store;
-  const fieldSignal = peekInternalSignal(context.signals, context.path.at(-1));
-  const peeked = fieldSignal?.value;
-  const transform = field.type ? schema.transformation(field) : null;
-  const rawValue = field.type ? value.map(item => transform.serialize(item, field.options ?? null, record)) : value?.slice();
-  cache.setAttr(context.resourceKey, context.path, rawValue);
-  if (peeked) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Expected the peekManagedArray for ${field.kind} to return a ManagedArray`);
-      }
-    })(ARRAY_SIGNAL in peeked) : {};
-    const arrSignal = peeked[ARRAY_SIGNAL];
-    arrSignal.isStale = true;
-    // TODO run array destroy?
-  }
-  if (!Array.isArray(rawValue) && fieldSignal) {
-    fieldSignal.value = null;
-  }
-  return true;
-}
-function getAttributeField(context) {
-  entangleSignal(context.signals, context.record, context.path.at(-1), null);
-  const {
-    cache
-  } = context.store;
-  return context.editable ? cache.getAttr(context.resourceKey, context.path) : cache.getRemoteAttr(context.resourceKey, context.path);
-}
-function setAttributeField(context) {
-  context.store.cache.setAttr(context.resourceKey, context.path, context.value);
-  return true;
-}
-const InvalidKinds = ['alias', 'derived', '@local'];
-function isInvalidKind(kind) {
-  return InvalidKinds.includes(kind);
-}
-function isNonIdentityCacheableField(field) {
-  return !isInvalidKind(field.kind) && field.kind !== '@id' && field.kind !== '@hash';
-}
-function getFieldCacheKeyStrict(field) {
-  return field.sourceKey || field.name;
-}
-function getFieldCacheKey(field) {
-  return 'sourceKey' in field && field.sourceKey ? field.sourceKey : field.name;
-}
-function getBelongsToField(context) {
-  entangleSignal(context.signals, context.record, context.path.at(-1), null);
-  const {
-    field,
-    resourceKey,
-    store
-  } = context;
-  const {
-    schema,
-    cache
-  } = store;
-  if (field.options.linksMode) {
-    const rawValue = context.editable ? cache.getRelationship(resourceKey, getFieldCacheKeyStrict(field)) : cache.getRemoteRelationship(resourceKey, getFieldCacheKeyStrict(field));
-    return rawValue.data ? store.peekRecord(rawValue.data) : null;
-  }
-
-  // FIXME move this to a "LegacyMode" make this part of "PolarisMode"
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Can only use belongsTo fields when the resource is in legacy mode`);
-    }
-  })(context.legacy) : {};
-  return schema._kind('@legacy', 'belongsTo').get(store, context.record, resourceKey, field);
-}
-function setBelongsToField(context) {
-  const {
-    store
-  } = context;
-  const {
-    schema
-  } = store;
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Can only mutate belongsTo fields when the resource is in legacy mode`);
-    }
-  })(context.legacy) : {};
-  schema._kind('@legacy', 'belongsTo').set(store, context.record, context.resourceKey, context.field, context.value);
-  return true;
-}
-function getCollectionField(context) {
-  entangleSignal(context.signals, context.record, context.path.at(-1), null);
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    {
-      throw new Error(`Accessing collection fields is not yet implemented`);
-    }
-  })() : {};
-}
-function setCollectionField(context) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    {
-      throw new Error(`Setting collection fields is not yet implemented`);
-    }
-  })() : {};
-  return false;
-}
-function getDerivedField(context) {
-  const {
-    schema
-  } = context.store;
-  return schema.derivation(context.field)(context.record, context.field.options ?? null, context.field.name);
-}
-function setDerivedField(context) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    {
-      throw new Error(`ILLEGAL SET: Cannot set '${context.path.join('.')}' on '${context.resourceKey.type}' as ${context.field.kind} fields are not mutable`);
-    }
-  })() : {};
-  return false;
-}
-function getGenericField(context) {
-  entangleSignal(context.signals, context.record, context.path.at(-1), null);
-  const {
-    cache,
-    schema
-  } = context.store;
-  const rawValue = context.editable ? cache.getAttr(context.resourceKey, context.path) : cache.getRemoteAttr(context.resourceKey, context.path);
-  const {
-    field
-  } = context;
-  if (!field.type) {
-    return rawValue;
-  }
-  const transform = schema.transformation(field);
-  return transform.hydrate(rawValue, field.options ?? null, context.record);
-}
-function setGenericField(context) {
-  const {
-    cache,
-    schema
-  } = context.store;
-  const {
-    field
-  } = context;
-  if (!field.type) {
-    cache.setAttr(context.resourceKey, context.path, context.value);
-    return true;
-  }
-  const transform = schema.transformation(field);
-  const rawValue = transform.serialize(context.value, field.options ?? null, context.record);
-  cache.setAttr(context.resourceKey, context.path, rawValue);
-  return true;
-}
-class ManyArrayManager {
-  constructor(record, editable) {
-    this.record = record;
-    this.store = record[RecordStore];
-    this.identifier = record[Identifier];
-    this.editable = editable;
-  }
-  _syncArray(array) {
-    const method = this.editable ? 'getRelationship' : 'getRemoteRelationship';
-    // FIXME field needs to use sourceKey
-    const rawValue = this.store.cache[method](this.identifier, array.key);
-    if (rawValue.meta) {
-      array.meta = rawValue.meta;
-    }
-    if (rawValue.links) {
-      array.links = rawValue.links;
-    }
-    const currentState = array[SOURCE$1];
-
-    // unlike in the normal RecordArray case, we don't need to divorce the reference
-    // because we don't need to worry about associate/disassociate since the graph
-    // takes care of that for us
-    if (currentState !== rawValue.data) {
-      currentState.length = 0;
-      fastPush(currentState, rawValue.data);
-    }
-  }
-  reloadHasMany(key, options) {
-    // FIXME field needs to use sourceKey
-    const field = this.store.schema.fields(this.identifier).get(key);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Expected a hasMany field for ${key}`);
-      }
-    })(field?.kind === 'hasMany') : {};
-    const cacheOptions = options ? extractCacheOptions(options) : {
-      reload: true
-    };
-    cacheOptions.types = [field.type];
-    const rawValue = this.store.cache.getRelationship(this.identifier, key);
-    const req = {
-      url: getRelatedLink(rawValue),
-      op: 'findHasMany',
-      method: 'GET',
-      records: rawValue.data,
-      cacheOptions,
-      options: {
-        field,
-        identifier: this.identifier,
-        links: rawValue.links,
-        meta: rawValue.meta
-      },
-      [EnableHydration]: false
-    };
-    return this.store.request(req);
-  }
-  mutate(mutation) {
-    this.store.cache.mutate(mutation);
-  }
-}
-function getRelatedLink(resource) {
-  const related = resource.links?.related;
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Expected a related link`);
-    }
-  })(related) : {};
-  return typeof related === 'object' ? related.href : related;
-}
-function extractCacheOptions(options) {
-  const cacheOptions = {};
-  if ('reload' in options) {
-    cacheOptions.reload = options.reload;
-  }
-  if ('backgroundReload' in options) {
-    cacheOptions.backgroundReload = options.backgroundReload;
-  }
-  return cacheOptions;
-}
-function getHasManyField(context) {
-  const signal = entangleSignal(context.signals, context.record, context.path.at(-1), null);
-  const {
-    store,
-    field
-  } = context;
-  if (field.options.linksMode) {
-    const {
-      record
-    } = context;
-    // the thing we hand out needs to know its owner and path in a private manner
-    // its "address" is the parent identifier (identifier) + field name (field.name)
-    //  in the nested object case field name here is the full dot path from root resource to this value
-    // its "key" is the field on the parent record
-    // its "owner" is the parent record
-
-    const cached = signal.value;
-    if (cached) {
-      return cached;
-    }
-    const {
-      editable,
-      resourceKey
-    } = context;
-    const {
-      cache
-    } = store;
-    const rawValue = cache.getRelationship(resourceKey, getFieldCacheKeyStrict(field));
-    if (!rawValue) {
-      return null;
-    }
-    const managedArray = new RelatedCollection({
-      store,
-      type: field.type,
-      identifier: resourceKey,
-      cache,
-      field: context.legacy ? field : undefined,
-      // we divorce the reference here because ManyArray mutates the target directly
-      // before sending the mutation op to the cache. We may be able to avoid this in the future
-      identifiers: rawValue.data?.slice(),
-      key: field.name,
-      meta: rawValue.meta || null,
-      links: rawValue.links || null,
-      isPolymorphic: field.options.polymorphic ?? false,
-      isAsync: field.options.async ?? false,
-      // TODO: Grab the proper value
-      _inverseIsAsync: false,
-      // @ts-expect-error Typescript doesn't have a way for us to thread the generic backwards so it infers unknown instead of T
-      manager: new ManyArrayManager(record, editable),
-      isLoaded: true,
-      allowMutation: editable
-    });
-    signal.value = managedArray;
-    return managedArray;
-  }
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
-    }
-  })(context.legacy) : {};
-  return store.schema._kind('@legacy', 'hasMany').get(store, context.record, context.resourceKey, field);
-}
-function setHasManyField(context) {
-  const {
-    store
-  } = context;
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
-    }
-  })(context.legacy) : {};
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`You must pass an array of records to set a hasMany relationship`);
-    }
-  })(Array.isArray(context.value)) : {};
-  store.schema._kind('@legacy', 'hasMany').set(store, context.record, context.resourceKey, context.field, context.value);
-  return true;
-}
-function getHashField(context) {
-  const {
-    field,
-    path,
-    resourceKey
-  } = context;
-  const {
-    schema,
-    cache
-  } = context.store;
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Cannot use a ${field.kind} directly on a resource.`);
-    }
-  })(Array.isArray(path) && path.length > 1) : {};
-  const realPath = path.slice(0, -1);
-  const rawData = context.editable ? cache.getAttr(resourceKey, realPath) : cache.getRemoteAttr(resourceKey, realPath);
-  return schema.hashFn(field)(rawData, field.options ?? null, field.name ?? null);
-}
-function setHashField(context) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    {
-      throw new Error(`ILLEGAL SET: Cannot set '${Array.isArray(context.path) ? context.path.join('.') : context.path}' on '${context.resourceKey.type}' as ${context.field.kind} fields are not mutable`);
-    }
-  })() : {};
-  return false;
-}
-function getIdentityField(context) {
-  entangleSignal(context.signals, context.record, '@identity', null);
-  return context.resourceKey.id;
-}
-function setIdentityField(context) {
-  const {
-    value,
-    resourceKey,
-    store
-  } = context;
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Expected to receive a string id`);
-    }
-  })(typeof value === 'string' && value.length) : {};
-  const normalizedId = String(value);
-  const didChange = normalizedId !== resourceKey.id;
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Cannot set ${resourceKey.type} record's id to ${normalizedId}, because id is already ${resourceKey.id}`);
-    }
-  })(!didChange || resourceKey.id === null) : {};
-  if (normalizedId !== null && didChange) {
-    store._instanceCache.setRecordId(resourceKey, normalizedId);
-    store.notifications.notify(resourceKey, 'identity');
-  }
-  return true;
-}
-function getLocalField(context) {
-  const {
-    field
-  } = context;
-  const signal = getOrCreateInternalSignal(context.signals, context.record, field.name, field.options?.defaultValue ?? null);
-  consumeInternalSignal(signal);
-  return signal.value;
-}
-function setLocalField(context) {
-  const {
-    value
-  } = context;
-  const signal = getOrCreateInternalSignal(context.signals, context.record, context.field.name, value);
-  if (signal.value !== value) {
-    signal.value = value;
-    notifyInternalSignal(signal);
-  }
-  return true;
-}
-const ObjectSymbols = new Set([OBJECT_SIGNAL, Parent, SOURCE, Editable, EmbeddedPath]);
-
-// const ignoredGlobalFields = new Set<string>(['setInterval', 'nodeType', 'nodeName', 'length', 'document', STRUCTURED]);
-
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-class ManagedObject {
-  constructor(context) {
-    const {
-      field,
-      path
-    } = context;
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const self = this;
-    this[SOURCE] = Object.assign({}, context.value);
-    const signals = withSignalStore(this);
-    const _SIGNAL = this[OBJECT_SIGNAL] = entangleSignal(signals, this, OBJECT_SIGNAL, undefined);
-    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 = !context.legacy ? null : schema.CAUTION_MEGA_DANGER_ZONE_objectExtensions(field, null);
-    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: context.editable,
-          enumerable: true,
-          configurable: true
-        };
-      },
-      get(target, prop, receiver) {
-        if (ObjectSymbols.has(prop)) {
-          return self[prop];
-        }
-        if (prop === Symbol.toPrimitive) {
-          return () => null;
-        }
-        if (prop === Symbol.toStringTag) {
-          return `ManagedObject<${identifier.type}:${identifier.id} (${identifier.lid})>`;
-        }
-        if (prop === 'constructor') {
-          return Object;
-        }
-        if (prop === 'toString') {
-          return function () {
-            return `ManagedObject<${identifier.type}:${identifier.id} (${identifier.lid})>`;
-          };
-        }
-        if (prop === 'toHTML') {
-          return function () {
-            return '<span>ManagedObject</span>';
-          };
-        }
-        if (_SIGNAL.isStale) {
-          _SIGNAL.isStale = false;
-          let newData = cache.getAttr(identifier, path);
-          if (newData && newData !== self[SOURCE]) {
-            if (field.type) {
-              const transform = schema.transformation(field);
-              newData = transform.hydrate(newData, field.options ?? null, context.record);
-            }
-            self[SOURCE] = Object.assign({}, newData); // Add type assertion for newData
-          }
-        }
-
-        // toJSON and extensions need to come after we update data if stale
-        if (prop === 'toJSON') {
-          return function () {
-            return structuredClone(self[SOURCE]);
-          };
-        }
-
-        // we always defer to data before extensions
-        if (prop in self[SOURCE]) {
-          consumeInternalSignal(_SIGNAL);
-          return self[SOURCE][prop];
-        }
-        if (isExtensionProp(extensions, prop)) {
-          return performObjectExtensionGet(receiver, extensions, signals, prop);
-        }
-        return Reflect.get(target, prop, receiver);
-      },
-      set(target, prop, value, receiver) {
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          if (!test) {
-            throw new Error(`Cannot set read-only property '${String(prop)}' on ManagedObject`);
-          }
-        })(context.editable) : {};
-
-        // since objects function as dictionaries, we can't defer to schema/data before extensions
-        // unless the prop is in the existing data.
-        if (!(prop in self[SOURCE]) && isExtensionProp(extensions, prop)) {
-          return performExtensionSet(receiver, extensions, signals, prop, value);
-        }
-        const reflect = Reflect.set(target, prop, value, receiver);
-        if (!reflect) {
-          return false;
-        }
-        if (!field.type) {
-          cache.setAttr(identifier, path, self[SOURCE]);
-        } else {
-          const transform = schema.transformation(field);
-          const val = transform.serialize(self[SOURCE], field.options ?? null, context.record);
-          cache.setAttr(identifier, path, val);
-        }
-        _SIGNAL.isStale = true;
-        return true;
-      }
-    });
-    return proxy;
-  }
-}
-const ManagedObjectMap = getOrSetGlobal('ManagedObjectMap', new Map());
-function peekManagedObject(record, field) {
-  const managedObjectMapForRecord = ManagedObjectMap.get(record);
-  if (managedObjectMapForRecord) {
-    return managedObjectMapForRecord.get(field.name);
-  }
-}
-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) {
-    managedObject = managedObjectMapForRecord.get(field.name);
-  }
-  if (managedObject) {
-    return managedObject;
-  } else {
-    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;
-    }
-    if (field.type) {
-      const transform = schema.transformation(field);
-      rawValue = transform.hydrate(rawValue, field.options ?? null, record);
-    }
-    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 {
-      managedObjectMapForRecord.set(field.name, managedObject);
-    }
-  }
-  return managedObject;
-}
-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);
-    }
-    cache.setAttr(context.resourceKey, context.path, newValue);
-    const peeked = peekManagedObject(record, 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, 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(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:${resourceKey.lid}.${name}`;
-    this.data = rawValue.data ? store.peekRecord(rawValue.data) : null;
-    this.name = name;
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      this.links = Object.freeze(Object.assign({}, rawValue.links));
-      this.meta = Object.freeze(Object.assign({}, rawValue.meta));
-    } else {
-      this.links = rawValue.links ?? {};
-      this.meta = rawValue.meta ?? {};
-    }
-    this[RecordStore] = store;
-    this[Parent] = context.record;
-  }
-  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 getResourceField(context) {
-  entangleSignal(context.signals, context.record, context.path.at(-1), null);
-  return new ResourceRelationship(context);
-}
-function setResourceField(context) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    {
-      throw new Error(`setting resource relationships is not yet supported`);
-    }
-  })() : {};
-  return false;
-}
-function setSchemaArrayField(context) {
-  const arrayValue = context.value?.slice();
-  const fieldSignal = peekInternalSignal(context.signals, context.path.at(-1));
-  const peeked = fieldSignal?.value;
-  context.store.cache.setAttr(context.resourceKey, context.path, arrayValue);
-  if (peeked) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Expected the peekManagedArray for ${context.field.kind} to return a ManagedArray`);
-      }
-    })(ARRAY_SIGNAL in peeked) : {};
-    const arrSignal = peeked[ARRAY_SIGNAL];
-    arrSignal.isStale = true;
-    if (!Array.isArray(arrayValue)) {
-      fieldSignal.value = null;
-    }
-  }
-  return true;
-}
-function getSchemaObjectField(context) {
-  const signal = entangleSignal(context.signals, context.record, context.path.at(-1), null);
-  const {
-    store,
-    resourceKey,
-    path
-  } = context;
-  const {
-    cache
-  } = store;
-  const rawValue = context.editable ? cache.getAttr(resourceKey, path) : cache.getRemoteAttr(resourceKey, path);
-  if (!rawValue) {
-    if (signal.value) {
-      const value = signal.value;
-      // TODO if we had idle scheduling this should be done there.
-      void Promise.resolve().then(() => {
-        value.value[Destroy]();
-      });
-      signal.value = null;
-    }
-    return null;
-  }
-  const {
-    field
-  } = context;
-  const {
-    schema
-  } = store;
-  let objectType;
-  if (field.options?.polymorphic) {
-    const typePath = field.options.type ?? 'type';
-    // if we are polymorphic, then context.field.options.type will
-    // either specify a path on the rawValue to use as the type, defaulting to "type" or
-    // the special string "@hash" which tells us to treat field.type as a hashFn name with which
-    // to calc the type.
-    if (typePath === '@hash') {
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-        if (!test) {
-          throw new Error(`Expected the field to define a hashFn as its type`);
-        }
-      })(field.type) : {};
-      const hashFn = schema.hashFn({
-        type: field.type
-      });
-      // TODO consider if there are better options and name args we could provide.
-      objectType = hashFn(rawValue, null, null);
-    } else {
-      objectType = rawValue[typePath];
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-        if (!test) {
-          throw new Error(`Expected the type path for the field to be a value on the raw object`);
-        }
-      })(typePath && objectType && typeof objectType === 'string') : {};
-    }
-  } else {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`A non-polymorphic SchemaObjectField must provide a SchemaObject type in its definition`);
-      }
-    })(field.type) : {};
-    objectType = field.type;
-  }
-  const hashField = schema.resource({
-    type: objectType
-  }).identity;
-  const identity = hashField ? schema.hashFn(hashField)(rawValue, hashField.options ?? null, hashField.name) : field.name;
-  const cachedSchemaObject = signal.value;
-  if (cachedSchemaObject) {
-    if (cachedSchemaObject.type === objectType && cachedSchemaObject.identity === identity) {
-      return cachedSchemaObject.value;
-    } else {
-      // TODO if we had idle scheduling this should be done there.
-      void Promise.resolve().then(() => {
-        cachedSchemaObject.value[Destroy]();
-      });
-    }
-  }
-  const schemaObject = new ReactiveResource({
-    store: context.store,
-    resourceKey: context.resourceKey,
-    modeName: context.modeName,
-    legacy: context.legacy,
-    editable: context.editable,
-    path: context.path,
-    field: context.field,
-    value: objectType
-  });
-  signal.value = {
-    type: objectType,
-    identity: identity,
-    value: schemaObject
-  };
-  return schemaObject;
-}
-function setSchemaObjectField(context) {
-  const {
-    store,
-    value
-  } = context;
-  let newValue = value;
-  if (value !== null) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Expected value to be an object`);
-      }
-    })(typeof value === 'object') : {};
-    newValue = {
-      ...value
-    };
-    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);
-function isPathMatch(a, b) {
-  return a.length === b.length && a.every((v, i) => v === b[i]);
-}
-function isNonEnumerableProp(prop) {
-  return prop === 'constructor' || prop === 'prototype' || prop === '__proto__' || prop === 'toString' || prop === 'toJSON' || prop === 'toHTML' || typeof prop === 'symbol';
-}
-const Editables = new WeakMap();
-/**
- * A class that uses a the ResourceSchema for a ResourceType
- * and a ResouceKey to transform data from the cache into a rich, reactive
- * object.
- *
- * This class is not directly instantiable. To use it, you should
- * configure the store's `instantiateRecord` and `teardownRecord` hooks
- * with the matching hooks provided by this package.
- *
- * @hideconstructor
- * @public
- */
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-class ReactiveResource {
-  constructor(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] = context.editable ?? false;
-    const schema = store.schema;
-    this[Legacy] = context.legacy ?? false;
-    const objectType = isEmbedded ? context.value : identifier.type;
-    const ResourceSchema = schema.resource(isEmbedded ? {
-      type: objectType
-    } : identifier);
-    const identityField = ResourceSchema.identity;
-    const BoundFns = new Map();
-
-    // prettier-ignore
-    const extensions = !context.legacy ? null : isEmbedded ? schema.CAUTION_MEGA_DANGER_ZONE_objectExtensions(embeddedField, objectType) : schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(identifier);
-    this[EmbeddedField] = embeddedField;
-    this[EmbeddedPath] = embeddedPath;
-    const fields = isEmbedded ? schema.fields({
-      type: objectType
-    }) : schema.fields(identifier);
-    const method = typeof schema.cacheFields === 'function' ? 'cacheFields' : 'fields';
-    const cacheFields = isEmbedded ? schema[method]({
-      type: objectType
-    }) : schema[method](identifier);
-    const signals = withSignalStore(this);
-    const proxy = new Proxy(this, {
-      ownKeys() {
-        const identityKey = identityField?.name;
-        const keys = Array.from(fields.keys());
-        if (identityKey) {
-          keys.unshift(identityKey);
-        }
-        return keys;
-      },
-      has(target, prop) {
-        if (prop === Destroy || prop === Checkout) {
-          return true;
-        }
-        return fields.has(prop);
-      },
-      getOwnPropertyDescriptor(target, prop) {
-        const schemaForField = prop === identityField?.name ? identityField : fields.get(prop);
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          if (!test) {
-            throw new Error(`No field named ${String(prop)} on ${identifier.type}`);
-          }
-        })(schemaForField) : {};
-        if (isNonEnumerableProp(prop)) {
-          return {
-            writable: false,
-            enumerable: false,
-            configurable: true
-          };
-        }
-        switch (schemaForField.kind) {
-          case 'derived':
-            return {
-              writable: false,
-              enumerable: true,
-              configurable: true
-            };
-          case '@id':
-            return {
-              writable: identifier.id === null,
-              enumerable: true,
-              configurable: true
-            };
-          case '@local':
-          case 'field':
-          case 'attribute':
-          case 'resource':
-          case 'alias':
-          case 'belongsTo':
-          case 'hasMany':
-          case 'collection':
-          case 'schema-array':
-          case 'array':
-          case 'schema-object':
-          case 'object':
-            return {
-              writable: IS_EDITABLE,
-              enumerable: true,
-              configurable: true
-            };
-          default:
-            return {
-              writable: false,
-              enumerable: false,
-              configurable: false
-            };
-        }
-      },
-      get(target, prop, receiver) {
-        if (RecordSymbols.has(prop)) {
-          if (prop === Destroy) {
-            return () => _DESTROY(receiver);
-          }
-          if (prop === Checkout) {
-            return () => _CHECKOUT(receiver);
-          }
-          return target[prop];
-        }
-        if (prop === Signals) {
-          return signals;
-        }
-
-        // TODO make this a symbol
-        if (prop === '___notifications') {
-          return target.___notifications;
-        }
-
-        // ReactiveResource reserves use of keys that begin with these characters
-        // for its own usage.
-        // _, @, $, *
-
-        const maybeField = prop === identityField?.name ? identityField : fields.get(prop);
-        if (!maybeField) {
-          if (IgnoredGlobalFields.has(prop)) {
-            return undefined;
-          }
-
-          /////////////////////////////////////////////////////////////
-          //// Note these bound function behaviors are essentially ////
-          //// built-in but overrideable derivations.              ////
-          ////                                                     ////
-          //// The bar for this has to be "basic expectations of   ////
-          ///  an object" – very, very high                        ////
-          /////////////////////////////////////////////////////////////
-
-          if (prop === Symbol.toStringTag || prop === 'toString') {
-            let fn = BoundFns.get('toString');
-            if (!fn) {
-              fn = function () {
-                entangleSignal(signals, receiver, '@identity', null);
-                return `Record<${identifier.type}:${identifier.id} (${identifier.lid})>`;
-              };
-              BoundFns.set(prop, fn);
-            }
-            return fn;
-          }
-          if (prop === 'toHTML') {
-            let fn = BoundFns.get('toHTML');
-            if (!fn) {
-              fn = function () {
-                entangleSignal(signals, receiver, '@identity', null);
-                return `<span>Record<${identifier.type}:${identifier.id} (${identifier.lid})></span>`;
-              };
-              BoundFns.set(prop, fn);
-            }
-            return fn;
-          }
-          if (prop === 'toJSON') {
-            let fn = BoundFns.get('toJSON');
-            if (!fn) {
-              fn = function () {
-                const json = {};
-                for (const key in receiver) {
-                  json[key] = receiver[key];
-                }
-                return json;
-              };
-              BoundFns.set(prop, fn);
-            }
-            return fn;
-          }
-          if (prop === Symbol.toPrimitive) return () => null;
-          if (prop === Symbol.iterator) {
-            let fn = BoundFns.get(Symbol.iterator);
-            if (!fn) {
-              fn = function* () {
-                for (const key in receiver) {
-                  yield [key, receiver[key]];
-                }
-              };
-              BoundFns.set(Symbol.iterator, fn);
-            }
-            return fn;
-          }
-          if (prop === 'constructor') {
-            return ReactiveResource;
-          }
-          if (isExtensionProp(extensions, prop)) {
-            return performObjectExtensionGet(receiver, extensions, signals, prop);
-          }
-
-          // too many things check for random symbols
-          if (typeof prop === 'symbol') return undefined;
-          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-            {
-              throw new Error(`No field named ${String(prop)} on ${isEmbedded ? embeddedField.type : identifier.type}`);
-            }
-          })() : {};
-          return undefined;
-        }
-        const field = maybeField.kind === 'alias' ? maybeField.options : maybeField;
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          if (!test) {
-            throw new Error(`Alias fields cannot alias '@id' '@local' '@hash' or 'derived' fields`);
-          }
-        })(maybeField.kind !== 'alias' || !['@id', '@local', '@hash', 'derived'].includes(maybeField.options.kind)) : {};
-        /**
-         * 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.
-        // 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':
-          case '@hash':
-          case '@local':
-          case 'derived':
-          case 'field':
-          case 'attribute':
-          case 'schema-array':
-          case 'array':
-          case 'schema-object':
-          case 'object':
-          case 'resource':
-          case 'belongsTo':
-          case 'hasMany':
-          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:
-            assertNeverField(identifier, field, propArray);
-        }
-      },
-      set(target, prop, value, receiver) {
-        if (!IS_EDITABLE) {
-          const type = isEmbedded ? embeddedField.type : identifier.type;
-          throw new Error(`Cannot set ${String(prop)} on ${type} because the record is not editable`);
-        }
-        const maybeField = prop === identityField?.name ? identityField : fields.get(prop);
-        if (!maybeField) {
-          const type = isEmbedded ? embeddedField.type : identifier.type;
-          if (isExtensionProp(extensions, prop)) {
-            return performExtensionSet(receiver, extensions, signals, prop, value);
-          }
-          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-            {
-              throw new Error(`There is no settable field named ${String(prop)} on ${type}`);
-            }
-          })() : {};
-          return false;
-        }
-        const field = maybeField.kind === 'alias' ? maybeField.options : maybeField;
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          if (!test) {
-            throw new Error(`Alias fields cannot alias '@id' '@local' '@hash' or 'derived' fields`);
-          }
-        })(maybeField.kind !== 'alias' || !['@id', '@local', '@hash', 'derived'].includes(maybeField.options.kind)) : {};
-        /**
-         * 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.
-        // 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':
-          case '@hash':
-          case '@local':
-          case 'field':
-          case 'attribute':
-          case 'derived':
-          case 'array':
-          case 'schema-array':
-          case 'schema-object':
-          case 'object':
-          case 'resource':
-          case 'belongsTo':
-          case 'hasMany':
-          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:
-            return assertNeverField(identifier, field, propArray);
-        }
-      }
-    });
-
-    // 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}`, proxy);
-                return;
-              }
-
-              // TODO we should add a LOGGING flag
-              // 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}`, proxy);
-              const signal = signals.get(key);
-              if (signal) {
-                notifyInternalSignal(signal);
-              }
-              const field = cacheFields.get(key);
-              if (field?.kind === 'array' || field?.kind === 'schema-array') {
-                const peeked = signal?.value;
-                if (peeked) {
-                  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                    if (!test) {
-                      throw new Error(`Expected the peekManagedArray for ${field.kind} to return a ManagedArray`);
-                    }
-                  })(ARRAY_SIGNAL in peeked) : {};
-                  const arrSignal = peeked[ARRAY_SIGNAL];
-                  notifyInternalSignal(arrSignal);
-                }
-              }
-              if (field?.kind === 'object') {
-                const peeked = peekManagedObject(proxy, 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 = cacheFields.get(key);
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                if (!test) {
-                  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}`, proxy);
-                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 signal = signals.get(key);
-                  if (signal) {
-                    const peeked = signal.value;
-                    if (peeked) {
-                      notifyInternalSignal(peeked[ARRAY_SIGNAL]);
-                    }
-                  }
-                  return;
-                }
-                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                  if (!test) {
-                    throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
-                  }
-                })(context.legacy) : {};
-                if (schema._kind('@legacy', 'hasMany').notify(store, proxy, identifier, field)) {
-                  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                    if (!test) {
-                      throw new Error(`Expected options to exist on relationship meta`);
-                    }
-                  })(field.options) : {};
-                  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                    if (!test) {
-                      throw new Error(`Expected async to exist on relationship meta options`);
-                    }
-                  })('async' in field.options) : {};
-                  if (field.options.async) {
-                    const signal = signals.get(key);
-                    if (signal) {
-                      notifyInternalSignal(signal);
-                    }
-                  }
-                }
-              } else if (field.kind === 'collection') ;
-            }
-          }
-          break;
-      }
-    });
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      Object.defineProperty(this, '__SHOW_ME_THE_DATA_(debug mode only)__', {
-        enumerable: false,
-        configurable: true,
-        get() {
-          const data = {};
-          for (const key of fields.keys()) {
-            data[key] = proxy[key];
-          }
-          return data;
-        }
-      });
-    }
-    return proxy;
-  }
-}
-function _CHECKOUT(record) {
-  // IF we are already the editable record, throw an error
-  if (record[Editable]) {
-    throw new Error(`Cannot checkout an already editable record`);
-  }
-  const editable = Editables.get(record);
-  if (editable) {
-    return Promise.resolve(editable);
-  }
-  const embeddedType = record[EmbeddedField];
-  const embeddedPath = record[EmbeddedPath];
-  const isEmbedded = embeddedType !== null && embeddedPath !== null;
-  if (isEmbedded) {
-    throw new Error(`Cannot checkout an embedded record (yet)`);
-  }
-  const legacy = record[Legacy];
-  const editableRecord = new ReactiveResource({
-    store: record[RecordStore],
-    resourceKey: record[Identifier],
-    modeName: legacy ? 'legacy' : 'polaris',
-    legacy: legacy,
-    editable: true,
-    path: null,
-    field: null,
-    value: null
-  });
-  setRecordIdentifier(editableRecord, recordIdentifierFor(record));
-  return Promise.resolve(editableRecord);
-}
-function _DESTROY(record) {
-  if (record[Legacy]) {
-    // @ts-expect-error
-    record.isDestroying = true;
-    // @ts-expect-error
-    record.isDestroyed = true;
-  }
-  record[RecordStore].notifications.unsubscribe(record.___notifications);
-
-  // FIXME we need a way to also unsubscribe all SchemaObjects when the primary
-  // resource is destroyed.
-}
-function assertNeverField(identifier, field, path) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    {
-      throw new Error(`Cannot use unknown field kind ${field.kind} on <${identifier.type}>.${Array.isArray(path) ? path.join('.') : path}`);
-    }
-  })() : {};
-  return false;
-}
+import { Type } from './types/symbols.js';
 function instantiateRecord(store, identifier, createArgs) {
   const schema = store.schema;
   const resourceSchema = schema.resource(identifier);
@@ -1930,7 +20,7 @@ function instantiateRecord(store, identifier, createArgs) {
     }
   })(isResourceSchema(resourceSchema)) : {};
   const legacy = resourceSchema?.legacy ?? false;
-  const editable = legacy || store.cache.isNew(identifier);
+  const editable = legacy;
   const record = new ReactiveResource({
     store,
     resourceKey: identifier,
@@ -1941,7 +31,7 @@ function instantiateRecord(store, identifier, createArgs) {
     field: null,
     value: null
   });
-  if (createArgs) {
+  if (createArgs && editable) {
     Object.assign(record, createArgs);
   }
   return record;
@@ -2180,7 +270,8 @@ function withDefaults(schema) {
  * @public
  */
 const fromIdentity = (record, options, key) => {
-  const identifier = record[Identifier];
+  const context = record[Context];
+  const identifier = context.resourceKey;
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
     if (!test) {
       throw new Error(`Cannot compute @identity for a record without an identifier`);
@@ -2204,7 +295,6 @@ fromIdentity[Type] = '@identity';
  * ```
  *
  * @public
- * @param {SchemaService} schema
  */
 function registerDerivations(schema) {
   schema.registerDerivation(fromIdentity);
@@ -2221,10 +311,9 @@ function makeCachedDerivation(derivation) {
     const signals = withSignalStore(record);
     let signal = signals.get(prop);
     if (!signal) {
-      signal = createMemo(record, prop, () => {
+      signal = createInternalMemo(signals, record, prop, () => {
         return derivation(record, options, prop);
       }); // a total lie, for convenience of reusing the storage
-      signals.set(prop, signal);
     }
     return signal();
   };
@@ -2234,7 +323,6 @@ function makeCachedDerivation(derivation) {
 /**
  * A SchemaService designed to work with dynamically registered schemas.
  *
- * @class SchemaService
  * @public
  */
 class SchemaService {
@@ -2253,6 +341,8 @@ class SchemaService {
 
   /** @internal */
 
+  /** @internal */
+
   constructor() {
     this._schemas = new Map();
     this._transforms = new Map();
@@ -2498,6 +588,13 @@ class SchemaService {
     })(kinds[kind]) : {};
     return kinds[kind];
   }
+
+  /**
+   * Registers a {@link HashFn} for use with a {@link HashField} for
+   * either {@link ObjectSchema} identity or polymorphic type calculation.
+   *
+   * @public
+   */
   registerHashFn(hashFn) {
     this._hashFns.set(hashFn[Type], hashFn);
   }
@@ -2682,4 +779,125 @@ function mergeMap(base, toApply) {
     base.set(key, value);
   }
 }
-export { Checkout, SchemaService, fromIdentity, instantiateRecord, registerDerivations, teardownRecord, withDefaults };
+const Subscriptions = new WeakMap();
+
+/**
+ * `ExpensiveSubscription` is a mechanism for non-reactive
+ * frameworks such as `react` to integrate with WarpDrive.
+ *
+ * This mechanism should never be used by frameworks or libraries
+ * that support fine-grained reactivity.
+ *
+ * ExpensiveSubscription is expensive *because* it doubles the number
+ * of notification callbacks required for each resource contained in
+ * the request being subscribed to. The more requests in-use, the more
+ * this cost adds up.
+ */
+class ExpensiveSubscription {
+  constructor(store, request) {
+    this._store = store;
+    this._request = request;
+    this._callbacks = new Set();
+    this._resources = new Map();
+    this._subscription = store.notifications.subscribe(request, this._notifyRequestChange);
+    this._updateResourceCallbacks();
+  }
+  _updateResourceCallbacks() {
+    const request = this._request;
+    const store = this._store;
+    const {
+      notifications
+    } = store;
+    const req = store.cache.peek(request);
+    const resources = this._resources;
+    const isInitialSubscription = resources.size === 0;
+    if (req && 'data' in req) {
+      if (Array.isArray(req.data)) {
+        for (const resourceKey of req.data) {
+          if (isInitialSubscription || !resources.has(resourceKey)) {
+            resources.set(resourceKey, notifications.subscribe(resourceKey, this._scheduleNotify));
+          }
+        }
+      } else if (req.data) {
+        if (isInitialSubscription || !resources.has(req.data)) {
+          resources.set(req.data, notifications.subscribe(req.data, this._scheduleNotify));
+        }
+      }
+    }
+    if (req && 'included' in req && Array.isArray(req.included)) {
+      for (const resourceKey of req.included) {
+        if (isInitialSubscription || !resources.has(resourceKey)) {
+          resources.set(resourceKey, notifications.subscribe(resourceKey, this._scheduleNotify));
+        }
+      }
+    }
+  }
+  _notifyRequestChange = () => {
+    this._updateResourceCallbacks();
+    this._scheduleNotify();
+  };
+  _scheduleNotify = () => {
+    this._notify = this._notify || Promise.resolve().then(() => {
+      for (const callback of this._callbacks) {
+        callback();
+      }
+      this._notify = null;
+    });
+  };
+  addWatcher(callback) {
+    this._callbacks.add(callback);
+  }
+  removeWatcher(callback) {
+    this._callbacks.delete(callback);
+    if (this._callbacks.size === 0) {
+      this.destroy();
+    }
+  }
+  destroy() {
+    Subscriptions.delete(this._request);
+    const {
+      notifications
+    } = this._store;
+    if (this._subscription) {
+      notifications.unsubscribe(this._subscription);
+    }
+    for (const token of this._resources.values()) {
+      notifications.unsubscribe(token);
+    }
+    this._callbacks.clear();
+    this._resources.clear();
+  }
+}
+
+/**
+ * Creates an {@link ExpensiveSubscription} for the {@link RequestKey}
+ * if one does not already exist and adds a watcher to it.
+ *
+ * Returns a cleanup function. This should be called on-mount by a component
+ * that wants to subscribe to a request and cleanup should be called on dismount.
+ *
+ * ::: warning ⚠️ Avoid Using If Your App Supports Fine-grained Reactivity
+ * This mechanism should never be used by frameworks or libraries
+ * that support fine-grained reactivity.
+ * :::
+ *
+ * `ExpensiveSubscription` is a mechanism for non-reactive
+ * frameworks such as `react` to integrate with WarpDrive, for instance
+ * by treating a request as an [external store](https://react.dev/reference/react/useSyncExternalStore)
+ *
+ * `ExpensiveSubscription` is expensive *because* it doubles the number
+ * of notification callbacks required for each resource contained in
+ * the request being subscribed to. The more requests in-use, the more
+ * this cost adds up.
+ */
+function getExpensiveRequestSubscription(store, requestKey, callback) {
+  let subscription = Subscriptions.get(requestKey);
+  if (!subscription) {
+    subscription = new ExpensiveSubscription(store, requestKey);
+  }
+  subscription.addWatcher(callback);
+  return () => {
+    subscription.removeWatcher(callback);
+  };
+}
+export { SchemaService, fromIdentity, getExpensiveRequestSubscription, instantiateRecord, registerDerivations, teardownRecord, withDefaults };