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

package/declarations/reactive/-private/default-mode.d.ts

@@ -20,17 +20,19 @@ export interface BaseContext {
 export interface ResourceContext extends BaseContext {
 	path: null;
 	field: null;
+	value: null;
 }
 export interface ObjectContext extends BaseContext {
 	path: string[];
 	field: SchemaObjectField | SchemaArrayField;
+	value: string;
 }
 export interface KindContext<T extends FieldSchema | IdentityField | HashField> extends BaseContext {
 	path: string[];
 	field: T;
+	value: unknown;
 	record: ReactiveResource;
 	signals: SignalStore;
-	value: unknown;
 }
 export interface KindImpl<T extends FieldSchema | IdentityField | HashField> {
 	/**

package/declarations/reactive/-private/kind/array-field.d.ts

@@ -1,9 +1,4 @@
-import type { RelatedCollection as ManyArray } from "../../../store/-private.js";
-import type { ArrayField, FieldSchema, SchemaArrayField } from "../../../types/schema/fields.js";
+import type { ArrayField, SchemaArrayField } from "../../../types/schema/fields.js";
 import type { KindContext } from "../default-mode.js";
-import { ManagedArray } from "../fields/managed-array.js";
-import type { ReactiveResource } from "../record.js";
-export declare const ManagedArrayMap: Map<ReactiveResource, Map<string, ManagedArray | ManyArray>>;
-export declare function peekManagedArray(record: ReactiveResource, field: FieldSchema): ManyArray | ManagedArray | undefined;
 export declare function getArrayField(context: KindContext<ArrayField | SchemaArrayField>): unknown;
-export declare function setArrayField(context: KindContext<ArrayField | SchemaArrayField>): boolean;
+export declare function setArrayField(context: KindContext<ArrayField>): boolean;

package/declarations/reactive/-private/schema.d.ts

@@ -271,7 +271,7 @@ export declare class SchemaService implements SchemaServiceInterface {
 	CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource: StableRecordIdentifier | {
 		type: string;
 	}): null | ProcessedExtension["features"];
-	CAUTION_MEGA_DANGER_ZONE_objectExtensions(field: ExtensibleField): null | ProcessedExtension["features"];
+	CAUTION_MEGA_DANGER_ZONE_objectExtensions(field: ExtensibleField, resolvedType: string | null): null | ProcessedExtension["features"];
 	CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field: ExtensibleField): null | ProcessedExtension["features"];
 	CAUTION_MEGA_DANGER_ZONE_hasExtension(ext: {
 		kind: "object" | "array";

package/declarations/reactive.d.ts

@@ -2,3 +2,4 @@ export { instantiateRecord, teardownRecord } from "./reactive/-private/hooks.js"
 export { type CAUTION_MEGA_DANGER_ZONE_Extension, type ProcessedExtension, type ExtensionDef, type Transformation, SchemaService, withDefaults, fromIdentity, registerDerivations } from "./reactive/-private/schema.js";
 export { type ReactiveResource } from "./reactive/-private/record.js";
 export { Checkout } from "./reactive/-private/symbols.js";
+export { type ReactiveDocument } from "./reactive/-private/document.js";

package/declarations/store/-types/q/schema-service.d.ts

@@ -358,7 +358,7 @@ export interface SchemaService {
 	*
 	* @public
 	*/
-	CAUTION_MEGA_DANGER_ZONE_objectExtensions?(field: ExtensibleField): null | ProcessedExtension["features"];
+	CAUTION_MEGA_DANGER_ZONE_objectExtensions?(field: ExtensibleField, resolvedType: string | null): null | ProcessedExtension["features"];
 	/**
 	* Retrieve the extension map for an array field
 	*

package/declarations/types/schema/fields.d.ts

@@ -294,7 +294,7 @@ export interface IdentityField {
 * perform those itself.
 *
 * A schema-array can declare its "key" value to be `@hash` if
-* a schema-object has such a field.
+* the schema-objects it contains have such a field.
 *
 * Only one hash field is permittable per schema-object, and
 * it should be placed in the `ResourceSchema`'s `@id` field
@@ -476,11 +476,13 @@ export interface ObjectField {
 /**
 * Represents a field whose value is an object
 * with a well-defined structure described by
-* a non-resource schema.
+* a schema-object (a non-resource schema).
 *
 * If the object's structure is not well-defined,
 * use 'object' instead.
 *
+* By default, a SchemaObject within
+*
 * @public
 */
 export interface SchemaObjectField {
@@ -520,12 +522,19 @@ export interface SchemaObjectField {
 	*/
 	sourceKey?: string;
 	/**
+	* If the field is not polymorphic:
+	*
 	* The name of the ObjectSchema that describes the
 	* structure of the object.
 	*
+	* If the field is polymorphic:
+	*
+	* The name of the hashFn to use to extract
+	* the type from the contained value or null.
+	*
 	* @public
 	*/
-	type: string;
+	type: string | null;
 	/**
 	* Options for configuring the behavior of the
 	* SchemaObject.
@@ -562,7 +571,15 @@ export interface SchemaObjectField {
 		* If the SchemaObject is Polymorphic, the key on the raw cache data to use
 		* as the "resource-type" value for the schema-object.
 		*
-		* Defaults to "type".
+		* The default is `'type'`.
+		*
+		* Valid options are:
+		*
+		* - `'@hash'`                : will lookup the `@hash` function specified by
+		*       SchemaObjectField.type and use it to calculate the type for each value.
+		* - \<field-name> (string)   : the name of a field to use as the key, only GenericFields (kind `field`)
+		*       Are valid field names for this purpose. The cache state without transforms applied will be
+		*       used when comparing values.
 		*
 		* @public
 		*/
@@ -694,12 +711,19 @@ export interface SchemaArrayField {
 	*/
 	sourceKey?: string;
 	/**
+	* If the SchemaArray is not polymorphic:
+	*
 	* The name of the ObjectSchema that describes the
 	* structure of the objects in the array.
 	*
+	* If the SchemaArray is polymorphic:
+	*
+	* The name of the hashFn to use to extract
+	* the type from contained members or null.
+	*
 	* @public
 	*/
-	type: string;
+	type: string | null;
 	/**
 	* Options for configuring the behavior of the
 	* SchemaArray.
@@ -713,13 +737,13 @@ export interface SchemaArrayField {
 	*
 	* Valid options are:
 	*
-	* - `'@identity'` (default) : the cached object's referential identity will be used.
+	* - `'@identity'`(default)  : the cached object's referential identity will be used.
 	*       This may result in significant instability when resource data is updated from the API
 	* - `'@index'`              : the cached object's index in the array will be used.
 	*       This is only a good choice for arrays that rarely if ever change membership
 	* - `'@hash'`               : will lookup the `@hash` function supplied in the ResourceSchema for
 	*       The contained schema-object and use the computed result to determine and compare identity.
-	* - \<field-name> (string)   : the name of a field to use as the key, only GenericFields (kind `field`)
+	* - \<field-name> (string)  : the name of a field to use as the key, only GenericFields (kind `field`)
 	*       Are valid field names for this purpose. The cache state without transforms applied will be
 	*       used when comparing values. The field value should be unique enough to guarantee two schema-objects
 	*       of the same type will not collide.
@@ -791,8 +815,15 @@ export interface SchemaArrayField {
 		* If the SchemaArray is Polymorphic, the key on the raw cache data to use
 		* as the "resource-type" value for the schema-object.
 		*
-		* Defaults to "type".
+		* The default is `'type'`.
 		*
+		* Valid options are:
+		*
+		* - `'@hash'`                : will lookup the `@hash` function specified by
+		*       SchemaArrayField.type and use it to calculate the type for each value.
+		* - \<field-name> (string)   : the name of a field to use as the key, only GenericFields (kind `field`)
+		*       Are valid field names for this purpose. The cache state without transforms applied will be
+		*       used when comparing values.
 		*/
 		type?: string;
 	};

package/dist/graph/-private.js

@@ -1,5 +1,5 @@
 import { deprecate, warn } from '@ember/debug';
-import { p as peekCache } from "../request-state-Bj0zUw2r.js";
+import { p as peekCache } from "../request-state-CeN66aML.js";
 import '../types/request.js';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import '../utils/string.js';

package/dist/{handler-Gm-q2q05.js → handler-SdXlte1w.js}

@@ -1,4 +1,4 @@
-import { K as ReactiveDocument } from "./request-state-Bj0zUw2r.js";
+import { K as ReactiveDocument } from "./request-state-CeN66aML.js";
 import { SkipCache, EnableHydration } from './types/request.js';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 const MUTATION_OPS = new Set(['createRecord', 'updateRecord', 'deleteRecord']);

package/dist/index.js

@@ -3,8 +3,8 @@ import { a as cloneResponseProperties, I as IS_CACHE_HANDLER, b as assertValidRe
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { w as waitFor } from "./configure-B48bFHOl.js";
 import { peekUniversalTransient, setUniversalTransient } from './types/-private.js';
-export { S as Store, r as recordIdentifierFor, O as setIdentifierForgetMethod, L as setIdentifierGenerationMethod, P as setIdentifierResetMethod, N as setIdentifierUpdateMethod, Q as setKeyInfoForResource, s as storeFor } from "./request-state-Bj0zUw2r.js";
-export { C as CacheHandler } from "./handler-Gm-q2q05.js";
+export { S as Store, r as recordIdentifierFor, O as setIdentifierForgetMethod, L as setIdentifierGenerationMethod, P as setIdentifierResetMethod, N as setIdentifierUpdateMethod, Q as setKeyInfoForResource, s as storeFor } from "./request-state-CeN66aML.js";
+export { C as CacheHandler } from "./handler-SdXlte1w.js";
 import '@ember/debug';
 import './utils/string.js';
 

package/dist/reactive.js

@@ -1,13 +1,13 @@
 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, d as SOURCE$1, f as fastPush, l as RelatedCollection, J as getOrCreateInternalSignal, G as notifyInternalSignal, W as performObjectExtensionGet, y as defineSignal, B as Signals, h as setRecordIdentifier, r as recordIdentifierFor } from "./request-state-Bj0zUw2r.js";
+import { F as withSignalStore, T as isExtensionProp, U as performExtensionSet, H as consumeInternalSignal, V as performArrayExtensionGet, x as entangleSignal, E as peekInternalSignal, d as SOURCE$1, f as fastPush, l as RelatedCollection, J as getOrCreateInternalSignal, G as notifyInternalSignal, W as performObjectExtensionGet, y as defineSignal, B as Signals, h as setRecordIdentifier, r as recordIdentifierFor } from "./request-state-CeN66aML.js";
 import { EnableHydration, STRUCTURED } from './types/request.js';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { warn, deprecate } from '@ember/debug';
 import './utils/string.js';
 import { A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, c as createMemo } from "./configure-B48bFHOl.js";
 import { RecordStore, Type } from './types/symbols.js';
+import { S as SOURCE, E as Editable, L as Legacy, D as Destroy, I as Identifier, P as Parent, a as EmbeddedPath, C as Checkout, b as EmbeddedField } from "./symbols-SIstXMLI.js";
 import { getOrSetGlobal } from './types/-private.js';
-import { S as SOURCE, E as Editable, L as Legacy, I as Identifier, P as Parent, a as EmbeddedPath, D as Destroy, C as Checkout, b as EmbeddedField } from "./symbols-SIstXMLI.js";
 import './index.js';
 function getAliasField(context) {
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
@@ -78,6 +78,9 @@ class ManagedArray {
     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();
@@ -85,8 +88,9 @@ class ManagedArray {
     this.path = context.path;
     this.owner = owner;
     let transaction = false;
-    const mode = context.field.options?.key ?? '@identity';
-    const RefStorage = mode === '@identity' ? WeakMap :
+    const KeyMode = field.options?.key ?? '@identity';
+    // listener.
+    const RefStorage = KeyMode === '@identity' ? WeakMap :
     // CAUTION CAUTION CAUTION
     // this is a pile of lies
     // the Map is Map<string, WeakRef<ReactiveResource>>
@@ -94,8 +98,8 @@ class ManagedArray {
     // internal to a method like ours without us duplicating the code
     // into two separate methods.
     Map;
-    const ManagedRecordRefs = context.field.kind === 'schema-array' ? new RefStorage() : null;
-    const extensions = context.legacy ? schema.CAUTION_MEGA_DANGER_ZONE_arrayExtensions(context.field) : null;
+    const ManagedRecordRefs = field.kind === 'schema-array' ? new RefStorage() : null;
+    const extensions = context.legacy ? schema.CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field) : null;
     const proxy = new Proxy(this[SOURCE], {
       get(target, prop, receiver) {
         if (prop === ARRAY_SIGNAL) {
@@ -121,14 +125,72 @@ class ManagedArray {
         }
         if (prop === '[]') return consumeInternalSignal(_SIGNAL), receiver;
         if (index !== null) {
-          let val;
-          if (mode === '@hash') {
-            val = target[index];
+          if (!transaction) {
+            consumeInternalSignal(_SIGNAL);
+          }
+          const rawValue = target[index];
+          if (field.kind === 'array') {
+            if (field.type) {
+              const transform = schema.transformation(field);
+              return transform.hydrate(rawValue, field.options ?? null, self.owner);
+            }
+            return rawValue;
+          }
+
+          /**
+           * When the array is polymorphic, we need to determine the real type
+           * in order to apply the correct identity as schema-object identity
+           * is only required to be unique by type
+           */
+          let objectType;
+          if (field.options?.polymorphic) {
+            const typePath = field.options.type ?? 'type';
+            // if we are polymorphic, then context.field.options.type will
+            // either specify a path on the rawValue to use as the type, defaulting to "type" or
+            // the special string "@hash" which tells us to treat field.type as a hashFn name with which
+            // to calc the type.
+            if (typePath === '@hash') {
+              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                if (!test) {
+                  throw new Error(`Expected the field to define a hashFn as its type`);
+                }
+              })(field.type) : {};
+              const hashFn = schema.hashFn({
+                type: field.type
+              });
+              // TODO consider if there are better options and name args we could provide.
+              objectType = hashFn(rawValue, null, null);
+            } else {
+              objectType = rawValue[typePath];
+              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                if (!test) {
+                  throw new Error(`Expected the type path for the field to be a value on the raw object`);
+                }
+              })(typePath && objectType && typeof objectType === 'string') : {};
+            }
+          } else {
+            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              if (!test) {
+                throw new Error(`A non-polymorphic SchemaArrayField must provide a SchemaObject type in its definition`);
+              }
+            })(field.type) : {};
+            objectType = field.type;
+          }
+
+          /**
+           * When KeyMode=@hash the ReactiveResource is keyed into
+           * ManagedRecordRefs by the return value of @hash on the rawValue.
+           *
+           * This means that we could find a way to only recompute the identity
+           * when ARRAY_SIGNAL is dirty if hash performance becomes a bottleneck.
+           */
+          let schemaObjectKeyValue;
+          if (KeyMode === '@hash') {
             const hashField = schema.resource({
-              type: context.field.type
+              type: objectType
             }).identity;
             const hashFn = schema.hashFn(hashField);
-            val = hashFn(val, null, null);
+            schemaObjectKeyValue = hashFn(rawValue, hashField.options ?? null, hashField.name);
           } else {
             // if mode is not @identity or @index, then access the key path.
             // we should assert that `mode` is a string
@@ -136,74 +198,78 @@ class ManagedArray {
             // and, we likely should lookup the associated field and throw an error IF
             // the given field does not exist OR
             // the field is anything other than a GenericField or LegacyAttributeField.
-            if (mode !== '@identity' && mode !== '@index') {
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error('mode must be a string');
-                }
-              })(typeof mode === 'string') : {};
-              const modeField = schema.resource({
-                type: context.field.type
-              }).fields.find(f => f.name === mode);
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error('field must exist in schema');
-                }
-              })(modeField) : {};
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error('field must be a GenericField or LegacyAttributeField');
-                }
-              })(modeField.kind === 'field' || modeField.kind === 'attribute') : {};
-            }
-            val = mode === '@identity' ? target[index] : mode === '@index' ? '@index' : target[index][mode];
-          }
-          if (context.field.kind === 'schema-array') {
-            if (!transaction) {
-              consumeInternalSignal(_SIGNAL);
-            }
-            if (val) {
-              const recordRef = ManagedRecordRefs.get(val);
-              let record = recordRef?.deref();
-              if (!record) {
-                const recordPath = context.path.slice();
-                // this is a dirty lie since path is string[] but really we
-                // should change the types for paths to `Array<string | number>`
-                // TODO we should allow the schema for the field to define a "key"
-                // for stability. Default should be `@identity` which means that
-                // same object reference from cache should result in same ReactiveResource
-                // embedded object.
-                recordPath.push(index);
-                record = new ReactiveResource({
-                  store: context.store,
-                  resourceKey: context.resourceKey,
-                  modeName: context.modeName,
-                  legacy: context.legacy,
-                  editable: context.editable,
-                  path: recordPath,
-                  field: context.field
-                });
-
-                // if mode is not @identity or @index, then access the key path now
-                // to determine the key value.
-                // chris says we can implement this as a special kind `@hash` which
-                // would be a function that only has access to the cache value and not
-                // the record itself, so derivation is possible but intentionally limited
-                // and non-reactive?
-                ManagedRecordRefs.set(val, new WeakRef(record));
+            if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+              const isPathKeyMode = KeyMode !== '@identity' && KeyMode !== '@index';
+              if (isPathKeyMode) {
+                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                  if (!test) {
+                    throw new Error('mode must be a string');
+                  }
+                })(typeof KeyMode === 'string' && KeyMode !== '') : {};
+                const modeField = schema.fields({
+                  type: objectType
+                }).get(KeyMode);
+                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                  if (!test) {
+                    throw new Error('field must exist in schema');
+                  }
+                })(modeField) : {};
+                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                  if (!test) {
+                    throw new Error('field must be a GenericField or LegacyAttributeField');
+                  }
+                })(modeField.kind === 'field' || modeField.kind === 'attribute') : {};
               }
-              return record;
             }
-            return val;
+            schemaObjectKeyValue = KeyMode === '@identity' ? rawValue : KeyMode === '@index' ? index : rawValue[KeyMode];
           }
-          if (!transaction) {
-            consumeInternalSignal(_SIGNAL);
+          if (!schemaObjectKeyValue) {
+            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              {
+                throw new Error(`Unexpected out of bounds access on SchemaArray`);
+              }
+            })() : {};
+            return undefined;
           }
-          if (context.field.type) {
-            const transform = schema.transformation(context.field);
-            return transform.hydrate(val, context.field.options ?? null, self.owner);
+          const recordRef = ManagedRecordRefs.get(schemaObjectKeyValue);
+          const record = recordRef?.value.deref();
+
+          // confirm the type and key still match
+          if (record && recordRef.type === objectType && recordRef.identity === schemaObjectKeyValue) {
+            if (recordRef.index !== index) {
+              recordRef.index = index;
+              recordRef.context.path[recordRef.context.path.length - 1] = index;
+            }
+            return record;
+          } else if (record) {
+            // TODO schedule idle once we can
+            void Promise.resolve().then(() => {
+              record[Destroy]();
+            });
           }
-          return val;
+          const recordPath = context.path.slice();
+          // this is a dirty lie since path is string[] but really we
+          // should change the types for paths to `Array<string | number>`
+          recordPath.push(index);
+          const objectContext = {
+            store: context.store,
+            resourceKey: context.resourceKey,
+            modeName: context.modeName,
+            legacy: context.legacy,
+            editable: context.editable,
+            path: recordPath,
+            field: field,
+            value: objectType
+          };
+          const schemaObject = new ReactiveResource(objectContext);
+          ManagedRecordRefs.set(schemaObjectKeyValue, {
+            type: objectType,
+            identity: schemaObjectKeyValue,
+            index,
+            context: objectContext,
+            value: new WeakRef(schemaObject)
+          });
+          return schemaObject;
         }
         if (isArrayGetter(prop)) {
           let fn = boundFns.get(prop);
@@ -274,18 +340,18 @@ class ManagedArray {
         }
         const reflect = Reflect.set(target, prop, value, receiver);
         if (reflect) {
-          if (!context.field.type) {
+          if (!field.type) {
             cache.setAttr(context.resourceKey, context.path, self[SOURCE]);
             _SIGNAL.isStale = true;
             return true;
           }
           let rawValue = self[SOURCE];
-          if (context.field.kind !== 'schema-array') {
-            const transform = schema.transformation(context.field);
+          if (field.kind !== 'schema-array') {
+            const transform = schema.transformation(field);
             if (!transform) {
-              throw new Error(`No '${context.field.type}' transform defined for use by ${context.resourceKey.type}.${String(prop)}`);
+              throw new Error(`No '${field.type}' transform defined for use by ${context.resourceKey.type}.${String(prop)}`);
             }
-            rawValue = self[SOURCE].map(item => transform.serialize(item, context.field.options ?? null, self.owner));
+            rawValue = self[SOURCE].map(item => transform.serialize(item, field.options ?? null, self.owner));
           }
           cache.setAttr(context.resourceKey, context.path, rawValue);
           _SIGNAL.isStale = true;
@@ -324,29 +390,17 @@ const desc = {
 };
 // compat(desc);
 Object.defineProperty(ManagedArray.prototype, '[]', desc);
-const ManagedArrayMap = getOrSetGlobal('ManagedArrayMap', new Map());
-function peekManagedArray(record, field) {
-  const managedArrayMapForRecord = ManagedArrayMap.get(record);
-  if (managedArrayMapForRecord) {
-    return managedArrayMapForRecord.get(field.name);
-  }
-}
 function getArrayField(context) {
-  entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  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 {
-    field,
     record
   } = context;
-  const managedArrayMapForRecord = ManagedArrayMap.get(record);
-  let managedArray;
-  if (managedArrayMapForRecord) {
-    managedArray = managedArrayMapForRecord.get(field.name);
-  }
+  let managedArray = signal.value;
   if (managedArray) {
     return managedArray;
   } else {
@@ -363,11 +417,7 @@ function getArrayField(context) {
       return null;
     }
     managedArray = new ManagedArray(context, record, rawValue);
-    if (!managedArrayMapForRecord) {
-      ManagedArrayMap.set(record, new Map([[field.name, managedArray]]));
-    } else {
-      managedArrayMapForRecord.set(field.name, managedArray);
-    }
+    signal.value = managedArray;
   }
   return managedArray;
 }
@@ -381,27 +431,11 @@ function setArrayField(context) {
     cache,
     schema
   } = context.store;
-  if (!field.type) {
-    cache.setAttr(context.resourceKey, context.path, value?.slice());
-    const peeked = peekManagedArray(record, field);
-    if (peeked) {
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-        if (!test) {
-          throw new Error(`Expected the peekManagedArray for ${field.kind} to return a ManagedArray`);
-        }
-      })(ARRAY_SIGNAL in peeked) : {};
-      const arrSignal = peeked[ARRAY_SIGNAL];
-      arrSignal.isStale = true;
-    }
-    if (!Array.isArray(value)) {
-      ManagedArrayMap.delete(record);
-    }
-    return true;
-  }
-  const transform = schema.transformation(field);
-  const rawValue = value.map(item => transform.serialize(item, field.options ?? null, record));
+  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);
-  const peeked = peekManagedArray(record, field);
   if (peeked) {
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
@@ -410,6 +444,10 @@ function setArrayField(context) {
     })(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;
 }
@@ -619,7 +657,7 @@ function extractCacheOptions(options) {
   return cacheOptions;
 }
 function getHasManyField(context) {
-  entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  const signal = entangleSignal(context.signals, context.record, context.path.at(-1), null);
   const {
     store,
     field
@@ -634,52 +672,43 @@ function getHasManyField(context) {
     // its "key" is the field on the parent record
     // its "owner" is the parent record
 
-    const managedArrayMapForRecord = ManagedArrayMap.get(record);
-    let managedArray;
-    if (managedArrayMapForRecord) {
-      managedArray = managedArrayMapForRecord.get(getFieldCacheKeyStrict(field));
+    const cached = signal.value;
+    if (cached) {
+      return cached;
     }
-    if (managedArray) {
-      return managedArray;
-    } else {
-      const {
-        editable,
-        resourceKey
-      } = context;
-      const {
-        cache
-      } = store;
-      const rawValue = cache.getRelationship(resourceKey, getFieldCacheKeyStrict(field));
-      if (!rawValue) {
-        return null;
-      }
-      managedArray = new RelatedCollection({
-        store,
-        type: field.type,
-        identifier: resourceKey,
-        cache,
-        field: context.legacy ? field : undefined,
-        // we divorce the reference here because ManyArray mutates the target directly
-        // before sending the mutation op to the cache. We may be able to avoid this in the future
-        identifiers: rawValue.data?.slice(),
-        key: field.name,
-        meta: rawValue.meta || null,
-        links: rawValue.links || null,
-        isPolymorphic: field.options.polymorphic ?? false,
-        isAsync: field.options.async ?? false,
-        // TODO: Grab the proper value
-        _inverseIsAsync: false,
-        // @ts-expect-error Typescript doesn't have a way for us to thread the generic backwards so it infers unknown instead of T
-        manager: new ManyArrayManager(record, editable),
-        isLoaded: true,
-        allowMutation: editable
-      });
-      if (!managedArrayMapForRecord) {
-        ManagedArrayMap.set(record, new Map([[field.name, managedArray]]));
-      } else {
-        managedArrayMapForRecord.set(field.name, managedArray);
-      }
+    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 => {
@@ -807,7 +836,7 @@ class ManagedObject {
     } = context.store;
 
     // prettier-ignore
-    const extensions = !context.legacy ? null : schema.CAUTION_MEGA_DANGER_ZONE_objectExtensions(field);
+    const extensions = !context.legacy ? null : schema.CAUTION_MEGA_DANGER_ZONE_objectExtensions(field, null);
     const proxy = new Proxy(this[SOURCE], {
       ownKeys() {
         return Object.keys(self[SOURCE]);
@@ -1070,11 +1099,9 @@ function setResourceField(context) {
 }
 function setSchemaArrayField(context) {
   const arrayValue = context.value?.slice();
-  if (!Array.isArray(arrayValue)) {
-    ManagedArrayMap.delete(context.record);
-  }
+  const fieldSignal = peekInternalSignal(context.signals, context.path.at(-1));
+  const peeked = fieldSignal?.value;
   context.store.cache.setAttr(context.resourceKey, context.path, arrayValue);
-  const peeked = peekManagedArray(context.record, context.field);
   if (peeked) {
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
@@ -1083,50 +1110,104 @@ function setSchemaArrayField(context) {
     })(ARRAY_SIGNAL in peeked) : {};
     const arrSignal = peeked[ARRAY_SIGNAL];
     arrSignal.isStale = true;
+    if (!Array.isArray(arrayValue)) {
+      fieldSignal.value = null;
+    }
   }
   return true;
 }
 function getSchemaObjectField(context) {
-  entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  const signal = entangleSignal(context.signals, context.record, context.path.at(-1), null);
   const {
-    record,
-    field
+    store,
+    resourceKey,
+    path
   } = context;
-  const schemaObjectMapForRecord = ManagedObjectMap.get(record);
-  let schemaObject;
-  if (schemaObjectMapForRecord) {
-    schemaObject = schemaObjectMapForRecord.get(field.name);
-  }
-  if (schemaObject) {
-    return schemaObject;
-  } 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;
+  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;
     }
-    schemaObject = new ReactiveResource({
-      store: context.store,
-      resourceKey: context.resourceKey,
-      modeName: context.modeName,
-      legacy: context.legacy,
-      editable: context.editable,
-      path: context.path,
-      field: context.field
-    });
+    return null;
   }
-  if (!schemaObjectMapForRecord) {
-    ManagedObjectMap.set(record, new Map([[field.name, schemaObject]]));
+  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 {
-    schemaObjectMapForRecord.set(field.name, schemaObject);
+    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) {
@@ -1309,17 +1390,26 @@ class ReactiveResource {
       this[Identifier] = identifier;
     }
     const IS_EDITABLE = this[Editable] = context.editable ?? false;
-    this[Legacy] = context.legacy ?? false;
     const schema = store.schema;
-    const ResourceSchema = schema.resource(isEmbedded ? embeddedField : identifier);
+    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) : schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(identifier);
+    const extensions = !context.legacy ? null : isEmbedded ? schema.CAUTION_MEGA_DANGER_ZONE_objectExtensions(embeddedField, objectType) : schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(identifier);
     this[EmbeddedField] = embeddedField;
     this[EmbeddedPath] = embeddedPath;
-    const fields = isEmbedded ? schema.fields(embeddedField) : schema.fields(identifier);
+    const fields = isEmbedded ? schema.fields({
+      type: objectType
+    }) : schema.fields(identifier);
+    const method = typeof schema.cacheFields === 'function' ? 'cacheFields' : 'fields';
+    const cacheFields = isEmbedded ? schema[method]({
+      type: objectType
+    }) : schema[method](identifier);
     const signals = withSignalStore(this);
     const proxy = new Proxy(this, {
       ownKeys() {
@@ -1684,9 +1774,9 @@ class ReactiveResource {
               if (signal) {
                 notifyInternalSignal(signal);
               }
-              const field = fields.get(key);
+              const field = cacheFields.get(key);
               if (field?.kind === 'array' || field?.kind === 'schema-array') {
-                const peeked = peekManagedArray(proxy, field);
+                const peeked = signal?.value;
                 if (peeked) {
                   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
                     if (!test) {
@@ -1712,7 +1802,7 @@ class ReactiveResource {
             if (Array.isArray(key)) ;else {
               if (isEmbedded) return; // base paths never apply to embedded records
 
-              const field = fields.get(key);
+              const field = cacheFields.get(key);
               macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
                 if (!test) {
                   throw new Error(`Expected relationship ${key} to be the name of a field`);
@@ -1728,9 +1818,12 @@ class ReactiveResource {
                 // FIXME
               } else if (field.kind === 'resource') ;else if (field.kind === 'hasMany') {
                 if (field.options.linksMode) {
-                  const peeked = peekManagedArray(proxy, field);
-                  if (peeked) {
-                    notifyInternalSignal(peeked[ARRAY_SIGNAL]);
+                  const signal = signals.get(key);
+                  if (signal) {
+                    const peeked = signal.value;
+                    if (peeked) {
+                      notifyInternalSignal(peeked[ARRAY_SIGNAL]);
+                    }
                   }
                   return;
                 }
@@ -1801,8 +1894,9 @@ function _CHECKOUT(record) {
     modeName: legacy ? 'legacy' : 'polaris',
     legacy: legacy,
     editable: true,
-    path: embeddedPath,
-    field: embeddedType
+    path: null,
+    field: null,
+    value: null
   });
   setRecordIdentifier(editableRecord, recordIdentifierFor(record));
   return Promise.resolve(editableRecord);
@@ -1815,6 +1909,9 @@ function _DESTROY(record) {
     record.isDestroyed = true;
   }
   record[RecordStore].notifications.unsubscribe(record.___notifications);
+
+  // FIXME we need a way to also unsubscribe all SchemaObjects when the primary
+  // resource is destroyed.
 }
 function assertNeverField(identifier, field, path) {
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
@@ -1841,7 +1938,8 @@ function instantiateRecord(store, identifier, createArgs) {
     legacy: legacy,
     editable: editable,
     path: null,
-    field: null
+    field: null,
+    value: null
   });
   if (createArgs) {
     Object.assign(record, createArgs);
@@ -1978,7 +2076,7 @@ function getExt(extCache, type, extName) {
 function hasObjectSchema(field) {
   return 'kind' in field && (field.kind === 'schema-array' || field.kind === 'schema-object');
 }
-function processExtensions(schema, field, scenario) {
+function processExtensions(schema, field, scenario, resolvedType) {
   // if we're looking up extensions for a resource, there is no
   // merging required so if we have no objectExtensions
   // we are done.
@@ -2005,12 +2103,16 @@ function processExtensions(schema, field, scenario) {
     if (!hasObjectSchema(field)) {
       return null;
     }
-    return schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(field);
+    return schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resolvedType ? {
+      type: resolvedType
+    } : field);
   }
 
   // if we have made it here, we have extensions, lets check if there's
   // a cached version we can use
-  const baseExtensions = scenario === 'resource' && hasObjectSchema(field) ? schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(field) : scenario === 'object' && hasObjectSchema(field) ? schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(field) : null;
+  const baseExtensions = scenario === 'resource' && hasObjectSchema(field) ? schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(field) : scenario === 'object' && hasObjectSchema(field) ? schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resolvedType ? {
+    type: resolvedType
+  } : field) : null;
   if (!baseExtensions && extensions.length === 1) {
     const value = getExt(extCache, type, extensions[0]);
     fieldCache[type].set(field, value);
@@ -2339,13 +2441,13 @@ class SchemaService {
   }
   CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource) {
     const schema = this.resource(resource);
-    return processExtensions(this, schema, 'resource');
+    return processExtensions(this, schema, 'resource', null);
   }
-  CAUTION_MEGA_DANGER_ZONE_objectExtensions(field) {
-    return processExtensions(this, field, 'object');
+  CAUTION_MEGA_DANGER_ZONE_objectExtensions(field, resolvedType) {
+    return processExtensions(this, field, 'object', resolvedType);
   }
   CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field) {
-    return processExtensions(this, field, 'array');
+    return processExtensions(this, field, 'array', null);
   }
   CAUTION_MEGA_DANGER_ZONE_hasExtension(ext) {
     return this._extensions[ext.kind].has(ext.name);

package/dist/{request-state-Bj0zUw2r.js → request-state-CeN66aML.js}

@@ -3481,7 +3481,7 @@ function extractIdentifierFromRecord$2(record) {
   return recordIdentifierFor(record);
 }
 const FAKE_ARR = getOrSetGlobal('FAKE_ARR', {});
-const SLICE_BATCH_SIZE = 1200;
+const SLICE_BATCH_SIZE = 4761;
 /**
  * This is a clever optimization.
  *
@@ -3521,15 +3521,12 @@ const SLICE_BATCH_SIZE = 1200;
  * @param source the items to push into target
  */
 function fastPush(target, source) {
-  let startLength = 0;
-  const newLength = source.length;
-  while (newLength - startLength > SLICE_BATCH_SIZE) {
-    // eslint-disable-next-line prefer-spread
-    target.push.apply(target, source.slice(startLength, startLength + SLICE_BATCH_SIZE));
-    startLength += SLICE_BATCH_SIZE;
+  let batch;
+  while (source.length > SLICE_BATCH_SIZE) {
+    batch = source.splice(0, SLICE_BATCH_SIZE);
+    target.push(...batch);
   }
-  // eslint-disable-next-line prefer-spread
-  target.push.apply(target, source.slice(startLength));
+  target.push(...source);
 }
 /**
   @class RecordArrayManager
@@ -5078,7 +5075,7 @@ class Store extends BaseClass {
     if (!cache) {
       cache = this._instanceCache.cache = this.createCache(this._instanceCache._storeWrapper);
       if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-        cache = new CacheManager(cache);
+        cache = this._instanceCache.cache = new CacheManager(cache);
       }
     }
     return cache;

package/dist/store/-private.js

@@ -1,3 +1,3 @@
-export { C as CollectionRecordArray, D as DISPOSE, I as LiveArray, M as MUTATE, R as RecordArrayManager, l as RelatedCollection, d as SOURCE, B as Signals, S as Store, j as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, b as coerceId, c as constructResource, H as consumeInternalSignal, t as createRequestSubscription, z as defineGate, A as defineNonEnumerableSignal, y as defineSignal, e as ensureStringId, x as entangleSignal, f as fastPush, w as gate, J as getOrCreateInternalSignal, q as getPromiseState, u as getRequestState, a as isDocumentIdentifier, i as isStableIdentifier, m as log, o as logGroup, v as memoized, G as notifyInternalSignal, p as peekCache, E as peekInternalSignal, r as recordIdentifierFor, g as removeRecordDataFor, k as setCacheFor, h as setRecordIdentifier, s as storeFor, F as withSignalStore } from "../request-state-Bj0zUw2r.js";
-export { C as CacheHandler } from "../handler-Gm-q2q05.js";
+export { C as CollectionRecordArray, D as DISPOSE, I as LiveArray, M as MUTATE, R as RecordArrayManager, l as RelatedCollection, d as SOURCE, B as Signals, S as Store, j as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, b as coerceId, c as constructResource, H as consumeInternalSignal, t as createRequestSubscription, z as defineGate, A as defineNonEnumerableSignal, y as defineSignal, e as ensureStringId, x as entangleSignal, f as fastPush, w as gate, J as getOrCreateInternalSignal, q as getPromiseState, u as getRequestState, a as isDocumentIdentifier, i as isStableIdentifier, m as log, o as logGroup, v as memoized, G as notifyInternalSignal, p as peekCache, E as peekInternalSignal, r as recordIdentifierFor, g as removeRecordDataFor, k as setCacheFor, h as setRecordIdentifier, s as storeFor, F as withSignalStore } from "../request-state-CeN66aML.js";
+export { C as CacheHandler } from "../handler-SdXlte1w.js";
 export { A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, c as createMemo, w as waitFor } from "../configure-B48bFHOl.js";

package/dist/types/-private.js

@@ -1,6 +1,6 @@
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 const name = "@warp-drive/core";
-const version = "5.7.0-alpha.4";
+const version = "5.7.0-alpha.5";
 
 // in testing mode, we utilize globals to ensure only one copy exists of
 // these maps, due to bugs in ember-auto-import

package/dist/types/schema/fields.js

@@ -134,7 +134,7 @@
  * perform those itself.
  *
  * A schema-array can declare its "key" value to be `@hash` if
- * a schema-object has such a field.
+ * the schema-objects it contains have such a field.
  *
  * Only one hash field is permittable per schema-object, and
  * it should be placed in the `ResourceSchema`'s `@id` field
@@ -188,11 +188,13 @@
 /**
  * Represents a field whose value is an object
  * with a well-defined structure described by
- * a non-resource schema.
+ * a schema-object (a non-resource schema).
  *
  * If the object's structure is not well-defined,
  * use 'object' instead.
  *
+ * By default, a SchemaObject within
+ *
  * @public
  */
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@warp-drive/core",
-  "version": "5.7.0-alpha.4",
+  "version": "5.7.0-alpha.5",
   "description": "Core package for WarpDrive | All the Universal Basics",
   "keywords": [
     "ember-addon"
@@ -37,13 +37,13 @@
   },
   "dependencies": {
     "@embroider/macros": "^1.16.12",
-    "@warp-drive/build-config": "5.7.0-alpha.4"
+    "@warp-drive/build-config": "5.7.0-alpha.5"
   },
   "devDependencies": {
     "@babel/core": "^7.26.10",
     "@babel/plugin-transform-typescript": "^7.27.0",
     "@babel/preset-typescript": "^7.27.0",
-    "@warp-drive/internal-config": "5.7.0-alpha.4",
+    "@warp-drive/internal-config": "5.7.0-alpha.5",
     "decorator-transforms": "^2.3.0",
     "ember-source": "~6.3.0",
     "expect-type": "^1.2.1",