@warp-drive/legacy 5.7.0-alpha.13 → 5.7.0-alpha.15

package/declarations/compat/builders/save-record.d.ts

@@ -1,5 +1,5 @@
 import { type StoreRequestInput } from "@warp-drive/core";
-import type { StableRecordIdentifier } from "@warp-drive/core/types";
+import type { ResourceKey } from "@warp-drive/core/types";
 import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
 import type { RequestSignature } from "@warp-drive/core/types/symbols";
 type SaveRecordRequestInput<
@@ -8,10 +8,10 @@ type SaveRecordRequestInput<
 > = StoreRequestInput & {
 	op: "createRecord" | "deleteRecord" | "updateRecord";
 	data: {
-		record: StableRecordIdentifier<T>;
+		record: ResourceKey<T>;
 		options: SaveRecordBuilderOptions;
 	};
-	records: [StableRecordIdentifier<T>];
+	records: [ResourceKey<T>];
 	[RequestSignature]?: RT;
 };
 type SaveRecordBuilderOptions = Record<string, unknown>;

package/declarations/compat/legacy-network-handler/fetch-manager.d.ts

@@ -2,7 +2,7 @@ import type { Store } from "@warp-drive/core";
 import { createDeferred } from "@warp-drive/core/request";
 import type { Request, RequestStateService } from "@warp-drive/core/store/-private";
 import type { FindRecordOptions } from "@warp-drive/core/types";
-import type { StableExistingRecordIdentifier, StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { PersistedResourceKey, ResourceKey } from "@warp-drive/core/types/identifier";
 import type { TypeFromInstance } from "@warp-drive/core/types/record";
 import type { ImmutableRequestInfo } from "@warp-drive/core/types/request";
 import type { SingleResourceDocument } from "@warp-drive/core/types/spec/json-api-raw";
@@ -13,23 +13,23 @@ export type FetchMutationOptions = FindRecordOptions & {
 	[SaveOp]: "createRecord" | "deleteRecord" | "updateRecord";
 };
 interface PendingFetchItem {
-	identifier: StableExistingRecordIdentifier;
+	identifier: PersistedResourceKey;
 	queryRequest: Request;
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	resolver: Deferred<any>;
 	options: FindRecordOptions;
 	trace?: unknown;
-	promise: Promise<StableExistingRecordIdentifier>;
+	promise: Promise<PersistedResourceKey>;
 }
 export declare class FetchManager {
 	isDestroyed: boolean;
 	requestCache: RequestStateService;
 	// fetches pending in the runloop, waiting to be coalesced
-	_pendingFetch: Map<string, Map<StableExistingRecordIdentifier, PendingFetchItem[]>>;
+	_pendingFetch: Map<string, Map<PersistedResourceKey, PendingFetchItem[]>>;
 	_store: Store;
 	constructor(store: Store);
-	createSnapshot<T>(identifier: StableRecordIdentifier<TypeFromInstance<T>>, options?: FindRecordOptions): Snapshot<T>;
-	createSnapshot(identifier: StableRecordIdentifier, options?: FindRecordOptions): Snapshot;
+	createSnapshot<T>(identifier: ResourceKey<TypeFromInstance<T>>, options?: FindRecordOptions): Snapshot<T>;
+	createSnapshot(identifier: ResourceKey, options?: FindRecordOptions): Snapshot;
 	/**
 	This method is called by `record.save`, and gets passed a
 	resolver for the promise that `record.save` returns.
@@ -38,11 +38,11 @@ export declare class FetchManager {
 	
 	@internal
 	*/
-	scheduleSave(identifier: StableRecordIdentifier, options: FetchMutationOptions): Promise<null | SingleResourceDocument>;
-	scheduleFetch(identifier: StableExistingRecordIdentifier, options: FindRecordOptions, request: ImmutableRequestInfo): Promise<StableExistingRecordIdentifier>;
-	getPendingFetch(identifier: StableExistingRecordIdentifier, options: FindRecordOptions): Promise<StableExistingRecordIdentifier> | undefined;
+	scheduleSave(identifier: ResourceKey, options: FetchMutationOptions): Promise<null | SingleResourceDocument>;
+	scheduleFetch(identifier: PersistedResourceKey, options: FindRecordOptions, request: ImmutableRequestInfo): Promise<PersistedResourceKey>;
+	getPendingFetch(identifier: PersistedResourceKey, options: FindRecordOptions): Promise<PersistedResourceKey> | undefined;
 	flushAllPendingFetches(): void;
-	fetchDataIfNeededForIdentifier(identifier: StableExistingRecordIdentifier, options: FindRecordOptions | undefined, request: ImmutableRequestInfo): Promise<StableExistingRecordIdentifier>;
+	fetchDataIfNeededForIdentifier(identifier: PersistedResourceKey, options: FindRecordOptions | undefined, request: ImmutableRequestInfo): Promise<PersistedResourceKey>;
 	destroy(): void;
 }
 export {};

package/declarations/compat/legacy-network-handler/identifier-has-id.d.ts

@@ -1,2 +1,2 @@
-import type { StableExistingRecordIdentifier } from "@warp-drive/core/types/identifier";
-export declare function assertIdentifierHasId(identifier: unknown): asserts identifier is StableExistingRecordIdentifier;
+import type { PersistedResourceKey } from "@warp-drive/core/types/identifier";
+export declare function assertIdentifierHasId(identifier: unknown): asserts identifier is PersistedResourceKey;

package/declarations/compat/legacy-network-handler/legacy-data-fetch.d.ts

@@ -1,11 +1,11 @@
 import type { Store } from "@warp-drive/core";
 import type { BaseFinderOptions } from "@warp-drive/core/types";
-import type { StableExistingRecordIdentifier, StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { PersistedResourceKey, ResourceKey } from "@warp-drive/core/types/identifier";
 import type { LegacyRelationshipField as RelationshipSchema } from "@warp-drive/core/types/schema/fields";
 import type { MinimumAdapterInterface } from "./minimum-adapter-interface.js";
-export declare function _findHasMany(adapter: MinimumAdapterInterface, store: Store, identifier: StableRecordIdentifier, link: string | null | {
+export declare function _findHasMany(adapter: MinimumAdapterInterface, store: Store, identifier: ResourceKey, link: string | null | {
 	href: string;
-}, relationship: RelationshipSchema, options: BaseFinderOptions): Promise<StableExistingRecordIdentifier[]>;
-export declare function _findBelongsTo(store: Store, identifier: StableRecordIdentifier, link: string | null | {
+}, relationship: RelationshipSchema, options: BaseFinderOptions): Promise<PersistedResourceKey[]>;
+export declare function _findBelongsTo(store: Store, identifier: ResourceKey, link: string | null | {
 	href: string;
-}, relationship: RelationshipSchema, options: BaseFinderOptions): Promise<StableExistingRecordIdentifier | null>;
+}, relationship: RelationshipSchema, options: BaseFinderOptions): Promise<PersistedResourceKey | null>;

package/declarations/compat/legacy-network-handler/minimum-adapter-interface.d.ts

@@ -1,5 +1,5 @@
 import type { Store } from "@warp-drive/core";
-import type { CollectionRecordArray } from "@warp-drive/core/store/-private";
+import type { LegacyQueryArray } from "@warp-drive/core/store/-private";
 import type { ModelSchema } from "@warp-drive/core/types";
 import type { LegacyRelationshipField as RelationshipSchema } from "@warp-drive/core/types/schema/fields";
 import type { Snapshot } from "./snapshot.js";
@@ -113,11 +113,11 @@ export interface MinimumAdapterInterface {
 	* @param {ModelSchema} schema An object with methods for accessing information about
 	*  the type, attributes and relationships of the primary type associated with the request.
 	* @param {Object} query
-	* @param {CollectionRecordArray} recordArray
+	* @param {LegacyQueryArray} recordArray
 	* @param {Object} options
 	* @return {Promise} a promise resolving with resource data to feed to the associated serializer
 	*/
-	query(store: Store, schema: ModelSchema, query: Record<string, unknown>, recordArray: CollectionRecordArray, options: {
+	query(store: Store, schema: ModelSchema, query: Record<string, unknown>, recordArray: LegacyQueryArray, options: {
 		adapterOptions?: unknown;
 	}): Promise<AdapterPayload>;
 	/**

package/declarations/compat/legacy-network-handler/snapshot-record-array.d.ts

@@ -1,5 +1,5 @@
 import type { Store } from "@warp-drive/core";
-import type { LiveArray } from "@warp-drive/core/store/-private";
+import type { LegacyLiveArray } from "@warp-drive/core/store/-private";
 import type { FindAllOptions, ModelSchema } from "@warp-drive/core/types";
 import type { Snapshot } from "./snapshot.js";
 /**
@@ -36,7 +36,7 @@ export declare class SnapshotRecordArray {
 	@private
 	@type {Array}
 	*/
-	get _recordArray(): LiveArray;
+	get _recordArray(): LegacyLiveArray;
 	/**
 	Number of records in the array
 	

package/declarations/compat/legacy-network-handler/snapshot.d.ts

@@ -1,7 +1,7 @@
 import type { Store } from "@warp-drive/core";
 import type { FindRecordOptions } from "@warp-drive/core/types";
 import type { ChangedAttributesHash } from "@warp-drive/core/types/cache";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
 import type { LegacyAttributeField, LegacyRelationshipField } from "@warp-drive/core/types/schema/fields";
 import type { SerializerOptions } from "./minimum-serializer-interface.js";
@@ -29,11 +29,11 @@ export declare class Snapshot<R = unknown> {
 	private _changedAttributes;
 	private _store;
 	/**
-	The unique RecordIdentifier associated with this Snapshot.
+	The unique ResourceKey associated with this Snapshot.
 	
 	@public
 	*/
-	identifier: StableRecordIdentifier<R extends TypedRecordInstance ? TypeFromInstance<R> : string>;
+	identifier: ResourceKey<R extends TypedRecordInstance ? TypeFromInstance<R> : string>;
 	/**
 	The ResourceType of the underlying record for this Snapshot, as a string.
 	
@@ -66,7 +66,7 @@ export declare class Snapshot<R = unknown> {
 	@public
 	*/
 	adapterOptions?: Record<string, unknown>;
-	constructor(options: FindRecordOptions, identifier: StableRecordIdentifier<R extends TypedRecordInstance ? TypeFromInstance<R> : string>, store: Store);
+	constructor(options: FindRecordOptions, identifier: ResourceKey<R extends TypedRecordInstance ? TypeFromInstance<R> : string>, store: Store);
 	/**
 	The underlying record for this snapshot. Can be used to access methods and
 	properties defined on the record.

package/declarations/model/-private/debug/assert-polymorphic-type.d.ts

@@ -1,6 +1,6 @@
 import type { Store } from "@warp-drive/core";
 import type { UpgradedMeta } from "@warp-drive/core/graph/-private";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 /*
 Assert that `addedRecord` has a valid type so it can be added to the
 relationship of the `record`.
@@ -13,5 +13,5 @@ be stable record identifiers and the `relationshipMeta` needs to be the meta
 information about the relationship, retrieved via
 `record.relationshipFor(key)`.
 */
-declare let assertPolymorphicType: (parentIdentifier: StableRecordIdentifier, parentDefinition: UpgradedMeta, addedIdentifier: StableRecordIdentifier, store: Store) => void;
+declare let assertPolymorphicType: (parentIdentifier: ResourceKey, parentDefinition: UpgradedMeta, addedIdentifier: ResourceKey, store: Store) => void;
 export { assertPolymorphicType };

package/declarations/model/-private/hooks.d.ts

@@ -1,8 +1,8 @@
 import { type Store } from "@warp-drive/core/store/-private";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { TypeFromInstance } from "@warp-drive/core/types/record";
 import type { Model } from "./model.js";
-export declare function instantiateRecord(this: Store, identifier: StableRecordIdentifier, createRecordArgs: {
+export declare function instantiateRecord(this: Store, identifier: ResourceKey, createRecordArgs: {
 	[key: string]: unknown;
 }): Model;
 export declare function teardownRecord(record: Model): void;

package/declarations/model/-private/legacy-relationships-support.d.ts

@@ -1,8 +1,7 @@
 import type { Store } from "@warp-drive/core";
 import type { CollectionEdge, Graph, ResourceEdge, UpgradedMeta } from "@warp-drive/core/graph/-private";
-import type { LiveArray } from "@warp-drive/core/store/-private";
-import { RelatedCollection as ManyArray } from "@warp-drive/core/store/-private";
-import type { BaseFinderOptions, StableRecordIdentifier } from "@warp-drive/core/types";
+import type { LegacyManyArray } from "@warp-drive/core/store/-private";
+import type { BaseFinderOptions, ResourceKey } from "@warp-drive/core/types";
 import type { Cache } from "@warp-drive/core/types/cache";
 import type { CollectionRelationship } from "@warp-drive/core/types/cache/relationship";
 import type { LocalRelationshipOperation } from "@warp-drive/core/types/graph";
@@ -15,7 +14,7 @@ import type { HasManyProxyCreateArgs } from "./promise-many-array.js";
 import { PromiseManyArray } from "./promise-many-array.js";
 import BelongsToReference from "./references/belongs-to.js";
 import HasManyReference from "./references/has-many.js";
-export declare const LEGACY_SUPPORT: Map<StableRecordIdentifier | MinimalLegacyRecord, LegacySupport>;
+export declare const LEGACY_SUPPORT: Map<ResourceKey | MinimalLegacyRecord, LegacySupport>;
 export declare function lookupLegacySupport(record: MinimalLegacyRecord): LegacySupport;
 export declare class LegacySupport {
 	record: MinimalLegacyRecord;
@@ -23,25 +22,25 @@ export declare class LegacySupport {
 	graph: Graph;
 	cache: Cache;
 	references: Record<string, BelongsToReference | HasManyReference>;
-	identifier: StableRecordIdentifier;
-	_manyArrayCache: Record<string, ManyArray>;
-	_relationshipPromisesCache: Record<string, Promise<ManyArray | OpaqueRecordInstance>>;
+	identifier: ResourceKey;
+	_manyArrayCache: Record<string, LegacyManyArray>;
+	_relationshipPromisesCache: Record<string, Promise<LegacyManyArray | OpaqueRecordInstance>>;
 	_relationshipProxyCache: Record<string, PromiseManyArray | PromiseBelongsTo | undefined>;
-	_pending: Record<string, Promise<StableRecordIdentifier | null> | undefined>;
+	_pending: Record<string, Promise<ResourceKey | null> | undefined>;
 	isDestroying: boolean;
 	isDestroyed: boolean;
-	constructor(record: MinimalLegacyRecord);
-	_syncArray(array: LiveArray): void;
+	constructor(record: MinimalLegacyRecord, identifier: ResourceKey);
+	_syncArray(array: LegacyManyArray): void;
 	mutate(mutation: LocalRelationshipOperation): void;
 	_findBelongsTo(key: string, resource: SingleResourceRelationship, relationship: ResourceEdge, options?: BaseFinderOptions): Promise<OpaqueRecordInstance | null>;
 	reloadBelongsTo(key: string, options?: BaseFinderOptions): Promise<OpaqueRecordInstance | null>;
 	getBelongsTo(key: string, options?: BaseFinderOptions): PromiseBelongsTo | OpaqueRecordInstance | null;
 	setDirtyBelongsTo(key: string, value: OpaqueRecordInstance | null): void;
-	_getCurrentState<T>(identifier: StableRecordIdentifier, field: string): [StableRecordIdentifier<TypeFromInstanceOrString<T>>[], CollectionRelationship];
-	getManyArray<T>(key: string, definition?: UpgradedMeta): ManyArray<T>;
-	fetchAsyncHasMany(key: string, relationship: CollectionEdge, manyArray: ManyArray, options?: BaseFinderOptions): Promise<ManyArray>;
-	reloadHasMany<T>(key: string, options?: BaseFinderOptions): Promise<ManyArray<T>> | PromiseManyArray<T>;
-	getHasMany(key: string, options?: BaseFinderOptions): PromiseManyArray | ManyArray;
+	_getCurrentState<T>(identifier: ResourceKey, field: string): [ResourceKey<TypeFromInstanceOrString<T>>[], CollectionRelationship];
+	getManyArray<T>(key: string, definition?: UpgradedMeta): LegacyManyArray<T>;
+	fetchAsyncHasMany(key: string, relationship: CollectionEdge, manyArray: LegacyManyArray, options?: BaseFinderOptions): Promise<LegacyManyArray>;
+	reloadHasMany<T>(key: string, options?: BaseFinderOptions): Promise<LegacyManyArray<T>> | PromiseManyArray<T>;
+	getHasMany(key: string, options?: BaseFinderOptions): PromiseManyArray | LegacyManyArray;
 	_updatePromiseProxyFor(kind: "hasMany", key: string, args: HasManyProxyCreateArgs): PromiseManyArray;
 	_updatePromiseProxyFor(kind: "belongsTo", key: string, args: BelongsToProxyCreateArgs): PromiseBelongsTo;
 	_updatePromiseProxyFor(kind: "belongsTo", key: string, args: {
@@ -49,8 +48,8 @@ export declare class LegacySupport {
 	}): PromiseBelongsTo;
 	referenceFor(kind: "belongsTo", name: string): BelongsToReference;
 	referenceFor(kind: "hasMany", name: string): HasManyReference;
-	_findHasManyByJsonApiResource(resource: CollectionResourceRelationship, parentIdentifier: StableRecordIdentifier, relationship: CollectionEdge, options?: BaseFinderOptions): Promise<void | unknown[]> | void;
-	_findBelongsToByJsonApiResource(resource: SingleResourceRelationship, parentIdentifier: StableRecordIdentifier, relationship: ResourceEdge, options?: BaseFinderOptions): Promise<StableRecordIdentifier | null>;
+	_findHasManyByJsonApiResource(resource: CollectionResourceRelationship, parentIdentifier: ResourceKey, relationship: CollectionEdge, options?: BaseFinderOptions): Promise<void | unknown[]> | void;
+	_findBelongsToByJsonApiResource(resource: SingleResourceRelationship, parentIdentifier: ResourceKey, relationship: ResourceEdge, options?: BaseFinderOptions): Promise<ResourceKey | null>;
 	destroy(): void;
 }
 export declare function areAllInverseRecordsLoaded(store: Store, resource: InnerRelationshipDocument): boolean;

package/declarations/model/-private/model.d.ts

@@ -1,6 +1,6 @@
 import EmberObject from "@ember/object";
 import type { Store } from "@warp-drive/core";
-import type { ModelSchema, StableRecordIdentifier } from "@warp-drive/core/types";
+import type { ModelSchema, ResourceKey } from "@warp-drive/core/types";
 import type { ChangedAttributesHash } from "@warp-drive/core/types/cache";
 import type { LegacyAttributeField, LegacyRelationshipField } from "@warp-drive/core/types/schema/fields";
 import { RecordStore } from "@warp-drive/core/types/symbols";
@@ -15,9 +15,9 @@ export type ModelCreateArgs = {
 	_createProps: Record<string, unknown>;
 	// TODO @deprecate consider deprecating accessing record properties during init which the below is necessary for
 	_secretInit: {
-		identifier: StableRecordIdentifier;
+		identifier: ResourceKey;
 		store: Store;
-		cb: (record: Model, identifier: StableRecordIdentifier, store: Store) => void;
+		cb: (record: Model, identifier: ResourceKey, store: Store) => void;
 	};
 };
 export type StaticModel = typeof Model & {

package/declarations/model/-private/notify-changes.d.ts

@@ -1,4 +1,4 @@
 import type { NotificationType, Store } from "@warp-drive/core";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { Model } from "./model.js";
-export default function notifyChanges(identifier: StableRecordIdentifier, value: NotificationType, key: string | undefined, record: Model, store: Store): void;
+export default function notifyChanges(identifier: ResourceKey, value: NotificationType, key: string | undefined, record: Model, store: Store): void;

package/declarations/model/-private/record-state.d.ts

@@ -1,7 +1,7 @@
 import type { Store } from "@warp-drive/core";
 import type { RequestCacheRequestState, RequestStateService } from "@warp-drive/core/store/-private";
 import type { Cache } from "@warp-drive/core/types/cache";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { Errors } from "./errors.js";
 import type { MinimalLegacyRecord } from "./model-methods.js";
 /**
@@ -45,7 +45,7 @@ inFlight
 */
 export default class RecordState {
 	store: Store;
-	identifier: StableRecordIdentifier;
+	identifier: ResourceKey;
 	record: MinimalLegacyRecord;
 	rs: RequestStateService;
 	pendingCount: number;

package/declarations/model/-private/references/belongs-to.d.ts

@@ -1,6 +1,6 @@
 import type { Store } from "@warp-drive/core";
 import type { Graph, ResourceEdge } from "@warp-drive/core/graph/-private";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { TypeFromInstance, TypeFromInstanceOrString } from "@warp-drive/core/types/record";
 import type { Links, Meta, SingleResourceDocument, SingleResourceRelationship } from "@warp-drive/core/types/spec/json-api-raw";
 import type { IsUnknown } from "../belongs-to.js";
@@ -59,20 +59,20 @@ export default class BelongsToReference<
 	type: TypeFromInstanceOrString<Related>;
 	// unsubscribe tokens given to us by the notification manager
 	___token: object;
-	___identifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>;
+	___identifier: ResourceKey<TypeFromInstanceOrString<T>>;
 	___relatedToken: object | null;
 	_ref: number;
-	constructor(store: Store, graph: Graph, parentIdentifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>, belongsToRelationship: ResourceEdge, key: K);
+	constructor(store: Store, graph: Graph, parentIdentifier: ResourceKey<TypeFromInstanceOrString<T>>, belongsToRelationship: ResourceEdge, key: K);
 	destroy(): void;
 	/**
 	* The identifier of the record that this reference refers to.
 	* `null` if no related record is known.
 	*
 	* @property identifier
-	* @type {StableRecordIdentifier | null}
+	* @type {ResourceKey | null}
 	* @public
 	*/
-	get identifier(): StableRecordIdentifier<TypeFromInstanceOrString<Related>> | null;
+	get identifier(): ResourceKey<TypeFromInstanceOrString<Related>> | null;
 	/**
 	The `id` of the record that this reference refers to. Together, the
 	`type()` and `id()` methods form a composite key for the identity
@@ -198,7 +198,7 @@ export default class BelongsToReference<
 	@return {Object} The meta information for the belongs-to relationship.
 	*/
 	meta(): Meta | null;
-	_resource(): SingleResourceRelationship<StableRecordIdentifier<TypeFromInstance<Related>>>;
+	_resource(): SingleResourceRelationship<ResourceKey<TypeFromInstance<Related>>>;
 	/**
 	This returns a string that represents how the reference will be
 	looked up when it is loaded. If the relationship has a link it will

package/declarations/model/-private/references/has-many.d.ts

@@ -2,7 +2,7 @@ import type { Store } from "@warp-drive/core";
 import type { CollectionEdge, Graph } from "@warp-drive/core/graph/-private";
 import type { RelatedCollection as ManyArray } from "@warp-drive/core/store/-private";
 import type { BaseFinderOptions } from "@warp-drive/core/types";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { TypeFromInstanceOrString } from "@warp-drive/core/types/record";
 import type { CollectionResourceDocument, CollectionResourceRelationship, ExistingResourceObject, LinkObject, Meta, PaginationLinks } from "@warp-drive/core/types/spec/json-api-raw";
 import type { IsUnknown } from "../belongs-to.js";
@@ -68,10 +68,10 @@ export default class HasManyReference<
 	type: TypeFromInstanceOrString<Related>;
 	// unsubscribe tokens given to us by the notification manager
 	___token: object;
-	___identifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>;
-	___relatedTokenMap: Map<StableRecordIdentifier, object>;
+	___identifier: ResourceKey<TypeFromInstanceOrString<T>>;
+	___relatedTokenMap: Map<ResourceKey, object>;
 	_ref: number;
-	constructor(store: Store, graph: Graph, parentIdentifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>, hasManyRelationship: CollectionEdge, key: K);
+	constructor(store: Store, graph: Graph, parentIdentifier: ResourceKey<TypeFromInstanceOrString<T>>, hasManyRelationship: CollectionEdge, key: K);
 	/**
 	* This method should never be called by user code.
 	*
@@ -82,10 +82,10 @@ export default class HasManyReference<
 	* An array of identifiers for the records that this reference refers to.
 	*
 	* @property identifiers
-	* @type {StableRecordIdentifier[]}
+	* @type {ResourceKey[]}
 	* @public
 	*/
-	get identifiers(): StableRecordIdentifier<TypeFromInstanceOrString<Related>>[];
+	get identifiers(): ResourceKey<TypeFromInstanceOrString<Related>>[];
 	_resource(): CollectionResourceRelationship;
 	/**
 	This returns a string that represents how the reference will be

package/declarations/model/-private/schema-provider.d.ts

@@ -1,6 +1,6 @@
 import type { Store } from "@warp-drive/core";
 import type { SchemaService } from "@warp-drive/core/types";
-import type { RecordIdentifier, StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { ObjectValue } from "@warp-drive/core/types/json/raw";
 import type { Derivation, HashFn, Transformation } from "@warp-drive/core/types/schema/concepts";
 import type { ArrayField, DerivedField, GenericField, HashField, LegacyField, ObjectField, ObjectSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
@@ -8,10 +8,10 @@ import type { ModelFactory, ModelStore } from "./model.js";
 type AttributesSchema = ReturnType<Exclude<SchemaService["attributesDefinitionFor"], undefined>>;
 type RelationshipsSchema = ReturnType<Exclude<SchemaService["relationshipsDefinitionFor"], undefined>>;
 export interface ModelSchemaProvider {
-	attributesDefinitionFor(resource: RecordIdentifier | {
+	attributesDefinitionFor(resource: ResourceKey | {
 		type: string;
 	}): AttributesSchema;
-	relationshipsDefinitionFor(resource: RecordIdentifier | {
+	relationshipsDefinitionFor(resource: ResourceKey | {
 		type: string;
 	}): RelationshipsSchema;
 	doesTypeExist(type: string): boolean;
@@ -23,7 +23,7 @@ export declare class ModelSchemaProvider implements SchemaService {
 	constructor(store: ModelStore);
 	resourceTypes(): Readonly<string[]>;
 	hasTrait(type: string): boolean;
-	resourceHasTrait(resource: StableRecordIdentifier | {
+	resourceHasTrait(resource: ResourceKey | {
 		type: string;
 	}, trait: string): boolean;
 	transformation(field: GenericField | ObjectField | ArrayField | {
@@ -35,7 +35,7 @@ export declare class ModelSchemaProvider implements SchemaService {
 	hashFn(field: HashField | {
 		type: string;
 	}): HashFn;
-	resource(resource: StableRecordIdentifier | {
+	resource(resource: ResourceKey | {
 		type: string;
 	}): ResourceSchema | ObjectSchema;
 	registerResources(schemas: Array<ResourceSchema | ObjectSchema>): void;
@@ -48,7 +48,7 @@ export declare class ModelSchemaProvider implements SchemaService {
 	>(derivation: Derivation<R, T, FM>): void;
 	registerHashFn(hashFn: HashFn): void;
 	private _loadModelSchema;
-	fields(resource: RecordIdentifier | {
+	fields(resource: ResourceKey | {
 		type: string;
 	}): Map<string, LegacyField>;
 	hasResource(resource: {

package/declarations/model/-private.d.ts

@@ -1,7 +1,7 @@
 export { type MinimalLegacyRecord } from "./-private/model-methods.js";
 export type { ModelStore } from "./-private/model.js";
 export { Errors } from "./-private/errors.js";
-export { RelatedCollection as ManyArray } from "@warp-drive/core/store/-private";
+export type { LegacyManyArray as ManyArray } from "@warp-drive/core/store/-private";
 export { PromiseBelongsTo } from "./-private/promise-belongs-to.js";
 export { PromiseManyArray } from "./-private/promise-many-array.js";
 // // Used by tests, migration support

package/declarations/model/migration-support.d.ts

@@ -3,7 +3,7 @@ import type { CAUTION_MEGA_DANGER_ZONE_Extension, ProcessedExtension } from "@wa
 import type { ExtensibleField } from "@warp-drive/core/reactive/-private/schema";
 import type { SchemaService } from "@warp-drive/core/types";
 import type { ChangedAttributesHash } from "@warp-drive/core/types/cache";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { ObjectValue } from "@warp-drive/core/types/json/raw";
 import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
 import type { Derivation, HashFn, Transformation } from "@warp-drive/core/types/schema/concepts";
@@ -198,10 +198,10 @@ export declare function registerDerivations(schema: SchemaService): void;
 * @public
 */
 export interface DelegatingSchemaService {
-	attributesDefinitionFor?(resource: StableRecordIdentifier | {
+	attributesDefinitionFor?(resource: ResourceKey | {
 		type: string;
 	}): AttributesSchema;
-	relationshipsDefinitionFor?(resource: StableRecordIdentifier | {
+	relationshipsDefinitionFor?(resource: ResourceKey | {
 		type: string;
 	}): RelationshipsSchema;
 	doesTypeExist?(type: string): boolean;
@@ -210,18 +210,18 @@ export declare class DelegatingSchemaService implements SchemaService {
 	_preferred: SchemaService;
 	_secondary: SchemaService;
 	constructor(store: Store, schema: SchemaService);
-	isDelegated(resource: StableRecordIdentifier | {
+	isDelegated(resource: ResourceKey | {
 		type: string;
 	}): boolean;
 	resourceTypes(): Readonly<string[]>;
-	hasResource(resource: StableRecordIdentifier | {
+	hasResource(resource: ResourceKey | {
 		type: string;
 	}): boolean;
 	hasTrait(type: string): boolean;
-	resourceHasTrait(resource: StableRecordIdentifier | {
+	resourceHasTrait(resource: ResourceKey | {
 		type: string;
 	}, trait: string): boolean;
-	fields(resource: StableRecordIdentifier | {
+	fields(resource: ResourceKey | {
 		type: string;
 	}): Map<string, FieldSchema>;
 	transformation(field: GenericField | ObjectField | ArrayField | {
@@ -233,7 +233,7 @@ export declare class DelegatingSchemaService implements SchemaService {
 	derivation(field: DerivedField | {
 		type: string;
 	}): Derivation;
-	resource(resource: StableRecordIdentifier | {
+	resource(resource: ResourceKey | {
 		type: string;
 	}): ResourceSchema | ObjectSchema;
 	registerResources(schemas: Array<ResourceSchema | ObjectSchema>): void;
@@ -246,7 +246,7 @@ export declare class DelegatingSchemaService implements SchemaService {
 	>(derivation: Derivation<R, T, FM>): void;
 	registerHashFn(hashFn: HashFn): void;
 	CAUTION_MEGA_DANGER_ZONE_registerExtension(extension: CAUTION_MEGA_DANGER_ZONE_Extension): void;
-	CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource: StableRecordIdentifier | {
+	CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource: ResourceKey | {
 		type: string;
 	}): null | ProcessedExtension["features"];
 	CAUTION_MEGA_DANGER_ZONE_objectExtensions(field: ExtensibleField, resolvedType: string | null): null | ProcessedExtension["features"];

package/declarations/store/-private.d.ts

@@ -1,11 +1,11 @@
 import { type InstanceCache } from "@warp-drive/core/store/-private";
-import type { StableNewRecordIdentifier, StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { NewResourceKey, ResourceKey } from "@warp-drive/core/types/identifier";
 import type { Value } from "@warp-drive/core/types/json/raw";
 import type { OpaqueRecordInstance, TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
 import type { LegacyAttributeField, LegacyRelationshipField } from "@warp-drive/core/types/schema/fields";
 import type { SingleResourceDocument } from "@warp-drive/core/types/spec/json-api-raw";
 import type { Store } from "../store.js";
-export declare function preloadData(store: Store, identifier: StableNewRecordIdentifier, preload: Record<string, Value>): void;
+export declare function preloadData(store: Store, identifier: NewResourceKey, preload: Record<string, Value>): void;
 export interface BaseFinderOptions {
 	reload?: boolean;
 	backgroundReload?: boolean;
@@ -55,7 +55,7 @@ export interface ModelSchema<T = unknown> {
 	eachRelationship<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, relationship: LegacyRelationshipField) => void, binding?: T): void;
 	eachTransformedAttribute<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, type: string | null) => void, binding?: T): void;
 }
-export declare function resourceIsFullyDeleted(instanceCache: InstanceCache, identifier: StableRecordIdentifier): boolean;
+export declare function resourceIsFullyDeleted(instanceCache: InstanceCache, identifier: ResourceKey): boolean;
 /**
 A `RecordReference` is a low-level API that allows users and
 addon authors to perform meta-operations on a record.
@@ -73,7 +73,7 @@ export declare class RecordReference {
 	private ___identifier;
 	/** @internal */
 	private _ref;
-	constructor(store: Store, identifier: StableRecordIdentifier);
+	constructor(store: Store, identifier: ResourceKey);
 	/** @internal */
 	destroy(): void;
 	get type(): string;
@@ -112,7 +112,7 @@ export declare class RecordReference {
 	@public
 	@return The identifier of the record.
 	*/
-	identifier(): StableRecordIdentifier;
+	identifier(): ResourceKey;
 	/**
 	How the reference will be looked up when it is loaded. Currently
 	this always returns `identity` to signify that a record will be

package/dist/{-private-CsshwIY7.js → -private-CVsFOW1k.js}

@@ -1,6 +1,7 @@
-import { SOURCE, waitFor, coerceId } from '@warp-drive/core/store/-private';
+import { Context } from '@warp-drive/core/reactive/-private';
 import { warn } from '@ember/debug';
 import { createDeferred } from '@warp-drive/core/request';
+import { waitFor, coerceId } from '@warp-drive/core/store/-private';
 import { getOrSetGlobal } from '@warp-drive/core/types/-private';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 
@@ -139,7 +140,7 @@ class SnapshotRecordArray {
     const {
       _fetchManager
     } = this.__store;
-    this._snapshots = this._recordArray[SOURCE].map(identifier => _fetchManager.createSnapshot(identifier));
+    this._snapshots = this._recordArray[Context].source.map(identifier => _fetchManager.createSnapshot(identifier));
     return this._snapshots;
   }
 }
@@ -246,7 +247,7 @@ function normalizeResponseHelper(serializer, store, modelClass, payload, id, req
 */
 class Snapshot {
   /**
-    The unique RecordIdentifier associated with this Snapshot.
+    The unique ResourceKey associated with this Snapshot.
      @public
   */
 
@@ -482,7 +483,7 @@ class Snapshot {
     }
     const value = this._store.cache.getRelationship(identifier, keyName);
     const data = value && value.data;
-    const inverseIdentifier = data ? store.identifierCache.getOrCreateRecordIdentifier(data) : null;
+    const inverseIdentifier = data ? store.cacheKeyManager.getOrCreateRecordIdentifier(data) : null;
     if (value && value.data !== undefined) {
       const cache = store.cache;
       if (inverseIdentifier && !cache.isDeleted(inverseIdentifier)) {
@@ -574,7 +575,7 @@ class Snapshot {
     if (value.data) {
       results = [];
       value.data.forEach(member => {
-        const inverseIdentifier = store.identifierCache.getOrCreateRecordIdentifier(member);
+        const inverseIdentifier = store.cacheKeyManager.getOrCreateRecordIdentifier(member);
         const cache = store.cache;
         if (!cache.isDeleted(inverseIdentifier)) {
           if (returnModeIsIds) {

package/dist/adapter/-private.js

@@ -1 +1 @@
-export { d as determineBodyPromise, g as fetch, p as parseResponseHeaders, b as serializeIntoHash, s as serializeQueryParams, a as setupFastboot } from "../serialize-into-hash-DVW6-WBv.js";
+export { d as determineBodyPromise, g as fetch, p as parseResponseHeaders, b as serializeIntoHash, s as serializeQueryParams, a as setupFastboot } from "../serialize-into-hash-B59laYa4.js";

package/dist/adapter/json-api.js

@@ -1,7 +1,7 @@
 import { dasherize, pluralize } from '@warp-drive/utilities/string';
 import '@ember/debug';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
-import { b as serializeIntoHash } from "../serialize-into-hash-DVW6-WBv.js";
+import { b as serializeIntoHash } from "../serialize-into-hash-B59laYa4.js";
 import { RESTAdapter } from './rest.js';
 class JSONAPIAdapter extends RESTAdapter {
   _defaultContentType = 'application/vnd.api+json';

package/dist/adapter/rest.js

@@ -2,7 +2,7 @@ import { getOwner } from '@ember/application';
 import { warn } from '@ember/debug';
 import { computed } from '@ember/object';
 import { Adapter, BuildURLMixin } from '../adapter.js';
-import { b as serializeIntoHash, d as determineBodyPromise, g as getFetchFunction, s as serializeQueryParams, p as parseResponseHeaders } from "../serialize-into-hash-DVW6-WBv.js";
+import { b as serializeIntoHash, d as determineBodyPromise, g as getFetchFunction, s as serializeQueryParams, p as parseResponseHeaders } from "../serialize-into-hash-B59laYa4.js";
 import { InvalidError, ServerError, ConflictError, NotFoundError, ForbiddenError, UnauthorizedError, AdapterError, TimeoutError, AbortError } from './error.js';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { d as decorateMethodV2 } from "../runtime-BPCpkOf1-BKOwiRJp.js";

package/dist/compat/-private.js

@@ -1 +1 @@
-export { F as FetchManager, S as SaveOp, c as Snapshot, b as SnapshotRecordArray, u as upgradeStore } from "../-private-CsshwIY7.js";
+export { F as FetchManager, S as SaveOp, c as Snapshot, b as SnapshotRecordArray, u as upgradeStore } from "../-private-CVsFOW1k.js";

package/dist/compat.js

@@ -1,7 +1,8 @@
 import { getOwner } from '@ember/application';
 import { recordIdentifierFor } from '@warp-drive/core';
 import { waitFor, _deprecatingNormalize } from '@warp-drive/core/store/-private';
-import { p as payloadIsNotBlank, n as normalizeResponseHelper, i as iterateData, F as FetchManager, S as SaveOp, a as assertIdentifierHasId, b as SnapshotRecordArray } from "./-private-CsshwIY7.js";
+import '@warp-drive/core/reactive/-private';
+import { p as payloadIsNotBlank, n as normalizeResponseHelper, i as iterateData, F as FetchManager, S as SaveOp, a as assertIdentifierHasId, b as SnapshotRecordArray } from "./-private-CVsFOW1k.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 function _findHasMany(adapter, store, identifier, link, relationship, options) {
   const promise = Promise.resolve().then(() => {

package/dist/{errors-DOPr_dMc.js → errors-VSxXZooE.js}

@@ -1,7 +1,8 @@
-import { memoized, defineSignal, defineNonEnumerableSignal, isStableIdentifier, recordIdentifierFor, storeFor, SOURCE, fastPush, RelatedCollection, notifyInternalSignal, ARRAY_SIGNAL } from '@warp-drive/core/store/-private';
+import { Context } from '@warp-drive/core/reactive/-private';
+import { memoized, defineSignal, defineNonEnumerableSignal, isResourceKey, recordIdentifierFor, storeFor, fastPush, createLegacyManyArray, notifyInternalSignal } from '@warp-drive/core/store/-private';
 import { getOrSetGlobal } from '@warp-drive/core/types/-private';
 import { EnableHydration } from '@warp-drive/core/types/request';
-import { u as upgradeStore } from "./-private-CsshwIY7.js";
+import { u as upgradeStore } from "./-private-CVsFOW1k.js";
 import { computed, get } from '@ember/object';
 import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
 import ObjectProxy from '@ember/object/proxy';
@@ -420,7 +421,7 @@ class HasManyReference {
    * An array of identifiers for the records that this reference refers to.
    *
    * @property identifiers
-   * @type {StableRecordIdentifier[]}
+   * @type {ResourceKey[]}
    * @public
    */
   get identifiers() {
@@ -432,7 +433,7 @@ class HasManyReference {
     this.___relatedTokenMap = new Map();
     if (resource && resource.data) {
       return resource.data.map(resourceIdentifier => {
-        const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resourceIdentifier);
+        const identifier = this.store.cacheKeyManager.getOrCreateRecordIdentifier(resourceIdentifier);
         let token = map.get(identifier);
         if (token) {
           map.delete(identifier);
@@ -724,7 +725,7 @@ class HasManyReference {
         throw new Error(`You must provide at least one of 'links', 'meta' or 'data' when calling hasManyReference.push`);
       }
     })('links' in dataDoc || 'meta' in dataDoc || 'data' in dataDoc) : {};
-    const identifiers = !Array.isArray(dataDoc.data) ? [] : isResourceData ? store._push(dataDoc, true) : dataDoc.data.map(i => store.identifierCache.getOrCreateRecordIdentifier(i));
+    const identifiers = !Array.isArray(dataDoc.data) ? [] : isResourceData ? store._push(dataDoc, true) : dataDoc.data.map(i => store.cacheKeyManager.getOrCreateRecordIdentifier(i));
     const {
       identifier
     } = this.hasManyRelationship;
@@ -1022,7 +1023,7 @@ class BelongsToReference {
    * `null` if no related record is known.
    *
    * @property identifier
-   * @type {StableRecordIdentifier | null}
+   * @type {ResourceKey | null}
    * @public
    */
   get identifier() {
@@ -1032,7 +1033,7 @@ class BelongsToReference {
     }
     const resource = this._resource();
     if (resource && resource.data) {
-      const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resource.data);
+      const identifier = this.store.cacheKeyManager.getOrCreateRecordIdentifier(resource.data);
       this.___relatedToken = this.store.notifications.subscribe(identifier, (_, bucket, notifiedKey) => {
         if (bucket === 'identity' || bucket === 'attributes' && notifiedKey === 'id') {
           this._ref++;
@@ -1309,7 +1310,7 @@ class BelongsToReference {
       store
     } = this;
     const isResourceData = doc.data && isMaybeResource(doc.data);
-    const added = isResourceData ? store._push(doc, true) : doc.data ? store.identifierCache.getOrCreateRecordIdentifier(doc.data) : null;
+    const added = isResourceData ? store._push(doc, true) : doc.data ? store.cacheKeyManager.getOrCreateRecordIdentifier(doc.data) : null;
     const {
       identifier
     } = this.belongsToRelationship;
@@ -1508,17 +1509,16 @@ function lookupLegacySupport(record) {
         throw new Error(`Memory Leak Detected`);
       }
     })(!record.isDestroyed && !record.isDestroying) : {};
-    support = new LegacySupport(record);
+    support = new LegacySupport(record, identifier);
     LEGACY_SUPPORT.set(identifier, support);
-    LEGACY_SUPPORT.set(record, support);
   }
   return support;
 }
 class LegacySupport {
-  constructor(record) {
+  constructor(record, identifier) {
     this.record = record;
     this.store = storeFor(record, false);
-    this.identifier = recordIdentifierFor(record);
+    this.identifier = identifier;
     this.cache = this.store.cache;
     if (this.store._graph) {
       this.graph = this.store._graph;
@@ -1534,7 +1534,7 @@ class LegacySupport {
     if (this.isDestroyed || this.isDestroying) {
       return;
     }
-    const currentState = array[SOURCE];
+    const currentState = array[Context].source;
     const identifier = this.identifier;
     const [identifiers, jsonApi] = this._getCurrentState(identifier, array.key);
     if (jsonApi.meta) {
@@ -1588,7 +1588,7 @@ class LegacySupport {
       if (!test) {
         throw new Error(`Expected a stable identifier`);
       }
-    })(!relatedIdentifier || isStableIdentifier(relatedIdentifier)) : {};
+    })(!relatedIdentifier || isResourceKey(relatedIdentifier)) : {};
     const store = this.store;
     const relationship = this.graph.get(this.identifier, key);
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
@@ -1648,7 +1648,7 @@ class LegacySupport {
           if (!test) {
             throw new Error(`Expected a stable identifier`);
           }
-        })(isStableIdentifier(relatedIdentifier)) : {};
+        })(isResourceKey(relatedIdentifier)) : {};
         if (cache.recordIsLoaded(relatedIdentifier, true)) {
           identifiers.push(relatedIdentifier);
         }
@@ -1664,23 +1664,20 @@ class LegacySupport {
       }
       if (!manyArray) {
         const [identifiers, doc] = this._getCurrentState(this.identifier, key);
-        manyArray = new RelatedCollection({
+        manyArray = createLegacyManyArray({
           store: this.store,
-          type: definition.type,
-          identifier: this.identifier,
-          cache: this.cache,
-          field: this.store.schema.fields(this.identifier).get(key),
-          identifiers,
-          key,
-          meta: doc.meta || null,
-          links: doc.links || null,
-          isPolymorphic: definition.isPolymorphic,
-          isAsync: definition.isAsync,
-          _inverseIsAsync: definition.inverseIsAsync,
           // @ts-expect-error Typescript doesn't have a way for us to thread the generic backwards so it infers unknown instead of T
           manager: this,
+          source: identifiers,
+          type: definition.type,
           isLoaded: !definition.isAsync,
-          allowMutation: true
+          editable: true,
+          isAsync: definition.isAsync,
+          isPolymorphic: definition.isPolymorphic,
+          field: this.store.schema.fields(this.identifier).get(key),
+          identifier: this.identifier,
+          links: doc.links || null,
+          meta: doc.meta || null
         });
         this._manyArrayCache[key] = manyArray;
       }
@@ -1901,7 +1898,7 @@ class LegacySupport {
           if (!test) {
             throw new Error(`Expected stable identifiers`);
           }
-        })(!identifiers || identifiers.every(isStableIdentifier)) : {};
+        })(!identifiers || identifiers.every(isResourceKey)) : {};
         const req = field.options.linksMode ? {
           url: getRelatedLink(resource),
           op: 'findHasMany',
@@ -1936,7 +1933,7 @@ class LegacySupport {
           if (!test) {
             throw new Error(`Expected stable identifiers`);
           }
-        })(identifiers.every(isStableIdentifier)) : {};
+        })(identifiers.every(isResourceKey)) : {};
         options.reload = options.reload || !attemptLocalCache || undefined;
         return this.store.request({
           op: 'findHasMany',
@@ -1975,7 +1972,7 @@ class LegacySupport {
       if (!test) {
         throw new Error(`Expected a stable identifier`);
       }
-    })(!identifier || isStableIdentifier(identifier)) : {};
+    })(!identifier || isResourceKey(identifier)) : {};
     const {
       isStale,
       hasDematerializedInverse,
@@ -2104,7 +2101,7 @@ function handleCompletedRelationshipRequest(recordExt, key, relationship, value,
   if (isHasMany) {
     // we don't notify the record property here to avoid refetch
     // only the many array
-    notifyInternalSignal(value[ARRAY_SIGNAL]);
+    notifyInternalSignal(value[Context].signal);
   }
   if (error) {
     relationship.state.hasFailedLoadAttempt = true;
@@ -2165,7 +2162,7 @@ function areAllInverseRecordsLoaded(store, resource) {
       if (!test) {
         throw new Error(`Expected stable identifiers`);
       }
-    })(identifiers.every(isStableIdentifier)) : {};
+    })(identifiers.every(isResourceKey)) : {};
     // treat as collection
     // check for unloaded records
     return identifiers.every(identifier => instanceCache.recordIsLoaded(identifier));
@@ -2177,7 +2174,7 @@ function areAllInverseRecordsLoaded(store, resource) {
     if (!test) {
       throw new Error(`Expected stable identifiers`);
     }
-  })(isStableIdentifier(identifiers)) : {};
+  })(isResourceKey(identifiers)) : {};
   return instanceCache.recordIsLoaded(identifiers);
 }
 function isBelongsTo(relationship) {

package/dist/model/-private.js

@@ -1,2 +1 @@
-export { E as Errors, L as LEGACY_SUPPORT, P as PromiseBelongsTo, a as PromiseManyArray, l as lookupLegacySupport } from "../errors-DOPr_dMc.js";
-export { RelatedCollection as ManyArray } from '@warp-drive/core/store/-private';
+export { E as Errors, L as LEGACY_SUPPORT, P as PromiseBelongsTo, a as PromiseManyArray, l as lookupLegacySupport } from "../errors-VSxXZooE.js";

package/dist/model/migration-support.js

@@ -1,10 +1,11 @@
 import { deprecate } from '@ember/debug';
 import { recordIdentifierFor } from '@warp-drive/core';
-import { notifyInternalSignal, ARRAY_SIGNAL } from '@warp-drive/core/store/-private';
+import { Context } from '@warp-drive/core/reactive/-private';
+import { notifyInternalSignal } from '@warp-drive/core/store/-private';
 import { getOrSetGlobal } from '@warp-drive/core/types/-private';
 import { Type } from '@warp-drive/core/types/symbols';
-import { l as lookupLegacySupport, E as Errors } from "../errors-DOPr_dMc.js";
-import { b as buildSchema, u as unloadRecord, s as serialize, _ as _save, a as save, r as rollbackAttributes, c as _reload, d as reload, h as hasMany, e as _destroyRecord, f as destroyRecord, g as deleteRecord, R as RecordState, i as changedAttributes, j as belongsTo, k as createSnapshot } from "../schema-provider-0vfXIZzR.js";
+import { l as lookupLegacySupport, E as Errors } from "../errors-VSxXZooE.js";
+import { b as buildSchema, u as unloadRecord, s as serialize, _ as _save, a as save, r as rollbackAttributes, c as _reload, d as reload, h as hasMany, e as _destroyRecord, f as destroyRecord, g as deleteRecord, R as RecordState, i as changedAttributes, j as belongsTo, k as createSnapshot } from "../schema-provider-BgBPZFfc.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 
 /**
@@ -344,7 +345,7 @@ function registerDerivations(schema) {
           return false;
         }
         if (manyArray) {
-          notifyInternalSignal(manyArray[ARRAY_SIGNAL]);
+          notifyInternalSignal(manyArray[Context].signal);
           return true;
         }
         return false;

package/dist/model.js

@@ -4,10 +4,10 @@ import { RecordStore } from '@warp-drive/core/types/symbols';
 import { i as isElementDescriptor, n as normalizeModelName } from "./util-Dul6TZts.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { warn, deprecate } from '@ember/debug';
-import { l as lookupLegacySupport } from "./errors-DOPr_dMc.js";
+import { l as lookupLegacySupport } from "./errors-VSxXZooE.js";
 import { singularize, dasherize } from '@warp-drive/utilities/string';
-import { l as getModelFactory } from "./schema-provider-0vfXIZzR.js";
-export { M as Model, b as buildSchema, M as default, m as restoreDeprecatedModelRequestBehaviors } from "./schema-provider-0vfXIZzR.js";
+import { l as getModelFactory } from "./schema-provider-BgBPZFfc.js";
+export { M as Model, b as buildSchema, M as default, m as restoreDeprecatedModelRequestBehaviors } from "./schema-provider-BgBPZFfc.js";
 import { setOwner, getOwner } from '@ember/application';
 import { setRecordIdentifier, StoreMap } from '@warp-drive/core/store/-private';
 function _attr(type, options) {

package/dist/{schema-provider-0vfXIZzR.js → schema-provider-BgBPZFfc.js}

@@ -2,12 +2,13 @@ import { getOwner } from '@ember/application';
 import { deprecate } from '@ember/debug';
 import EmberObject from '@ember/object';
 import { recordIdentifierFor, storeFor } from '@warp-drive/core';
-import { notifyInternalSignal, peekInternalSignal, withSignalStore, ARRAY_SIGNAL, recordIdentifierFor as recordIdentifierFor$1, gate, memoized, defineSignal, coerceId, entangleSignal, defineGate } from '@warp-drive/core/store/-private';
+import { notifyInternalSignal, peekInternalSignal, withSignalStore, recordIdentifierFor as recordIdentifierFor$1, gate, memoized, defineSignal, coerceId, entangleSignal, defineGate } from '@warp-drive/core/store/-private';
 import { RecordStore } from '@warp-drive/core/types/symbols';
-import { l as lookupLegacySupport, L as LEGACY_SUPPORT, E as Errors } from "./errors-DOPr_dMc.js";
-import { u as upgradeStore, F as FetchManager } from "./-private-CsshwIY7.js";
+import { l as lookupLegacySupport, L as LEGACY_SUPPORT, E as Errors } from "./errors-VSxXZooE.js";
+import { u as upgradeStore, F as FetchManager } from "./-private-CVsFOW1k.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { cacheFor } from '@ember/object/internals';
+import { Context } from '@warp-drive/core/reactive/-private';
 import { d as decorateMethodV2 } from "./runtime-BPCpkOf1-BKOwiRJp.js";
 import { n as normalizeModelName } from "./util-Dul6TZts.js";
 function rollbackAttributes() {
@@ -216,7 +217,7 @@ function notifyRelationship(identifier, key, record, meta) {
       return;
     }
     if (manyArray) {
-      notifyInternalSignal(manyArray[ARRAY_SIGNAL]);
+      notifyInternalSignal(manyArray[Context].signal);
 
       //We need to notifyPropertyChange in the adding case because we need to make sure
       //we fetch the newly added record in case it is unloaded
@@ -736,9 +737,11 @@ class Model extends EmberObject {
     this.___recordState?.destroy();
     const store = storeFor(this, false);
     store.notifications.unsubscribe(this.___private_notifications);
-    LEGACY_SUPPORT.get(this)?.destroy();
-    LEGACY_SUPPORT.delete(this);
-    LEGACY_SUPPORT.delete(identifier);
+    const support = LEGACY_SUPPORT.get(identifier);
+    if (support) {
+      support.destroy();
+      LEGACY_SUPPORT.delete(identifier);
+    }
     super.destroy();
   }
 
@@ -1035,7 +1038,7 @@ class Model extends EmberObject {
     })(!didChange || identifier.id === null) : {};
     if (normalizedId !== null && didChange) {
       this.store._instanceCache.setRecordId(identifier, normalizedId);
-      this.store.notifications.notify(identifier, 'identity');
+      this.store.notifications.notify(identifier, 'identity', null);
     }
   }
   toString() {

package/dist/{serialize-into-hash-DVW6-WBv.js → serialize-into-hash-B59laYa4.js}

@@ -1,7 +1,7 @@
 import { warn } from '@ember/debug';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
-import '@warp-drive/core/store/-private';
-import "./-private-CsshwIY7.js";
+import '@warp-drive/core/reactive/-private';
+import "./-private-CVsFOW1k.js";
 const newline = /\r?\n/;
 function parseResponseHeaders(headersString) {
   const headers = Object.create(null);

package/dist/store.js

@@ -399,7 +399,7 @@ function restoreDeprecatedStoreBehaviors(StoreKlass) {
       const normalizedId = ensureStringId(id);
       resource = constructResource(type, normalizedId);
     }
-    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
+    const identifier = this.cacheKeyManager.getOrCreateRecordIdentifier(resource);
     options = options || {};
     if (options.preload) {
       // force reload if we preload to ensure we don't resolve the promise
@@ -543,7 +543,7 @@ function restoreDeprecatedStoreBehaviors(StoreKlass) {
         throw new Error('getReference expected to receive either a resource identifier or type and id as arguments');
       }
     })(isMaybeIdentifier(resourceIdentifier)) : {};
-    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resourceIdentifier);
+    const identifier = this.cacheKeyManager.getOrCreateRecordIdentifier(resourceIdentifier);
     const cache = upgradeInstanceCaches(this._instanceCache.__instances).reference;
     let reference = cache.get(identifier);
     if (!reference) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@warp-drive/legacy",
-  "version": "5.7.0-alpha.13",
+  "version": "5.7.0-alpha.15",
   "description": "Decommissioned Packages for WarpDrive | Things your app might still want to maintain use of for a little longer.",
   "keywords": [
     "ember-addon"
@@ -32,8 +32,8 @@
     }
   },
   "peerDependencies": {
-    "@warp-drive/core": "5.7.0-alpha.13",
-    "@warp-drive/utilities": "5.7.0-alpha.13"
+    "@warp-drive/core": "5.7.0-alpha.15",
+    "@warp-drive/utilities": "5.7.0-alpha.15"
   },
   "dependencies": {
     "@embroider/macros": "^1.16.12"
@@ -43,9 +43,9 @@
     "@babel/plugin-transform-typescript": "^7.27.0",
     "@babel/preset-typescript": "^7.27.0",
     "@types/jquery": "^3.5.32",
-    "@warp-drive/internal-config": "5.7.0-alpha.13",
-    "@warp-drive/core": "5.7.0-alpha.13",
-    "@warp-drive/utilities": "5.7.0-alpha.13",
+    "@warp-drive/internal-config": "5.7.0-alpha.15",
+    "@warp-drive/core": "5.7.0-alpha.15",
+    "@warp-drive/utilities": "5.7.0-alpha.15",
     "ember-source": "~6.3.0",
     "decorator-transforms": "^2.3.0",
     "expect-type": "^1.2.1",