@warp-drive/core 5.7.0-alpha.3 → 5.7.0-alpha.31

package/declarations/store/-types/q/cache-capabilities-manager.d.ts

@@ -1,5 +1,5 @@
-import type { StableDocumentIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
-import type { IdentifierCache } from "../../-private/caches/identifier-cache.js";
+import type { RequestKey, ResourceKey } from "../../../types/identifier.js";
+import type { CacheKeyManager } from "../../-private/managers/cache-key-manager.js";
 import type { NotificationType } from "../../-private/managers/notification-manager.js";
 import type { SchemaService } from "./schema-service.js";
 /**
@@ -11,22 +11,21 @@ import type { SchemaService } from "./schema-service.js";
 *
 * This class cannot be directly instantiated.
 *
-* @class CacheCapabilitiesManager
 * @public
 */
 export type CacheCapabilitiesManager = {
 	/**
-	* Provides access to the IdentifierCache instance
+	* Provides access to the CacheKeyManager instance
 	* for this Store instance.
 	*
-	* The IdentifierCache can be used to peek, generate or
+	* The CacheKeyManager can be used to peek, generate or
 	* retrieve a stable unique identifier for any resource.
 	*
-	* @property identifierCache
-	* @type {IdentifierCache}
 	* @public
 	*/
-	identifierCache: IdentifierCache;
+	cacheKeyManager: CacheKeyManager;
+	/** @deprecated use {@link CacheCapabilitiesManager.cacheKeyManager} */
+	identifierCache: CacheKeyManager;
 	/**
 	* DEPRECATED - use the schema property
 	*
@@ -36,7 +35,7 @@ export type CacheCapabilitiesManager = {
 	* The SchemaService can be used to query for
 	* information about the schema of a resource.
 	*
-	* @deprecated
+	* @deprecated use {@link CacheCapabilitiesManager.schema}
 	* @public
 	*/
 	getSchemaDefinitionService(): SchemaService;
@@ -55,30 +54,25 @@ export type CacheCapabilitiesManager = {
 	* Update the `id` for the record corresponding to the identifier
 	* This operation can only be done for records whose `id` is `null`.
 	*
-	* @param {StableRecordIdentifier} identifier;
-	* @param {String} id;
 	* @public
 	*/
-	setRecordId(identifier: StableRecordIdentifier, id: string): void;
+	setRecordId(identifier: ResourceKey, id: string): void;
 	/**
 	* Signal to the store that the specified record may be considered fully
 	* removed from the cache. Generally this means that not only does no
 	* data exist for the identified resource, no known relationships still
 	* point to it either.
 	*
-	* @param {StableRecordIdentifier} identifier
 	* @public
 	*/
-	disconnectRecord(identifier: StableRecordIdentifier): void;
+	disconnectRecord(identifier: ResourceKey): void;
 	/**
 	* Use this method to determine if the Store has an instantiated record associated
 	* with an identifier.
 	*
-	* @param identifier
-	* @return {Boolean}
 	* @public
 	*/
-	hasRecord(identifier: StableRecordIdentifier): boolean;
+	hasRecord(identifier: ResourceKey): boolean;
 	/**
 	* Notify subscribers of the NotificationManager that cache state has changed.
 	*
@@ -87,13 +81,10 @@ export type CacheCapabilitiesManager = {
 	*
 	* No other namespaces currently expect the `key` argument.
 	*
-	* @param {StableRecordIdentifier} identifier
-	* @param {'attributes' | 'relationships' | 'identity' | 'errors' | 'meta' | 'state'} namespace
-	* @param {string|undefined} key
 	* @public
 	*/
-	notifyChange(identifier: StableRecordIdentifier, namespace: "added" | "removed", key: null): void;
-	notifyChange(identifier: StableDocumentIdentifier, namespace: "added" | "updated" | "removed", key: null): void;
-	notifyChange(identifier: StableRecordIdentifier, namespace: NotificationType, key: string | null): void;
-	notifyChange(identifier: StableRecordIdentifier | StableDocumentIdentifier, namespace: NotificationType | "added" | "removed" | "updated", key: string | null): void;
+	notifyChange(identifier: ResourceKey, namespace: "added" | "removed", key: null): void;
+	notifyChange(identifier: RequestKey, namespace: "added" | "updated" | "removed", key: null): void;
+	notifyChange(identifier: ResourceKey, namespace: NotificationType, key: string | null): void;
+	notifyChange(identifier: ResourceKey | RequestKey, namespace: NotificationType | "added" | "removed" | "updated", key: string | null): void;
 };

package/declarations/store/-types/q/identifier.d.ts

@@ -1,20 +1,23 @@
-import type { IdentifierBucket, StableIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
+import type { CacheKeyType, RequestKey, ResourceKey } from "../../../types/identifier.js";
 import type { ImmutableRequestInfo } from "../../../types/request.js";
 export interface GenerationMethod {
 	(data: ImmutableRequestInfo, bucket: "document"): string | null;
 	(data: unknown | {
 		type: string;
 	}, bucket: "record"): string;
-	(data: unknown, bucket: IdentifierBucket): string | null;
+	(data: unknown, bucket: CacheKeyType): string | null;
 }
 export type UpdateMethod = {
-	(identifier: StableRecordIdentifier, newData: unknown, bucket: "record"): void;
-	(identifier: StableIdentifier, newData: unknown, bucket: never): void;
+	(identifier: ResourceKey, newData: unknown, bucket: "record"): void;
+	(identifier: RequestKey, newData: unknown, bucket: "document"): void;
+	(identifier: {
+		lid: string;
+	}, newData: unknown, bucket: never): void;
 };
-export type ForgetMethod = (identifier: StableIdentifier | StableRecordIdentifier, bucket: IdentifierBucket) => void;
+export type ForgetMethod = (identifier: RequestKey | ResourceKey, bucket: CacheKeyType) => void;
 export type ResetMethod = () => void;
 export type KeyInfo = {
 	id: string | null;
 	type: string;
 };
-export type KeyInfoMethod = (resource: unknown, known: StableRecordIdentifier | null) => KeyInfo;
+export type KeyInfoMethod = (resource: unknown, known: ResourceKey | null) => KeyInfo;

package/declarations/store/-types/q/record-instance.d.ts

@@ -18,6 +18,5 @@ also allows WarpDrive to provide typechecking and intellisense for the record
 based on a special symbol prsent on record instances that implement the
 `TypedRecordInstance` interface.
 
-@internal
 */
 export type OpaqueRecordInstance = unknown;

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

@@ -1,9 +1,9 @@
 import type { CAUTION_MEGA_DANGER_ZONE_Extension, ProcessedExtension } from "../../../reactive.js";
 import type { ExtensibleField } from "../../../reactive/-private/schema.js";
-import type { RecordIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ResourceKey } from "../../../types/identifier.js";
 import type { ObjectValue } from "../../../types/json/raw.js";
 import type { Derivation, HashFn, Transformation } from "../../../types/schema/concepts.js";
-import type { ArrayField, DerivedField, FieldSchema, GenericField, HashField, LegacyAttributeField, LegacyRelationshipField, ObjectField, Schema, Trait } from "../../../types/schema/fields.js";
+import type { ArrayField, CacheableFieldSchema, DerivedField, FieldSchema, GenericField, HashField, IdentityField, LegacyAttributeField, LegacyRelationshipField, ObjectField, Schema, Trait } from "../../../types/schema/fields.js";
 export type AttributesSchema = Record<string, LegacyAttributeField>;
 export type RelationshipsSchema = Record<string, LegacyRelationshipField>;
 interface ObjectWithStringTypeProperty {
@@ -57,7 +57,6 @@ interface ObjectWithStringTypeProperty {
 * }
 * ```
 *
-* @class (Interface) SchemaService
 * @public
 */
 export interface SchemaService {
@@ -68,52 +67,47 @@ export interface SchemaService {
 	*
 	* @public
 	* @deprecated
-	* @param {String} type
-	* @return {Boolean}
 	*/
 	doesTypeExist?(type: string): boolean;
 	/**
 	* Queries whether the SchemaService recognizes `type` as a resource type
 	*
 	* @public
-	* @param {StableRecordIdentifier|ObjectWithStringTypeProperty} resource
-	* @return {Boolean}
 	*/
-	hasResource(resource: ObjectWithStringTypeProperty | StableRecordIdentifier): boolean;
+	hasResource(resource: ObjectWithStringTypeProperty | ResourceKey): boolean;
 	/**
 	* Queries whether the SchemaService recognizes `type` as a resource trait
 	*
 	* @public
-	* @param {String} type
-	* @return {Boolean}
 	*/
 	hasTrait(type: string): boolean;
 	/**
 	* Queries whether the given resource has the given trait
 	*
 	* @public
-	* @param {StableRecordIdentifier|ObjectWithStringTypeProperty} resource
-	* @param {String} trait
-	* @return {Boolean}
 	*/
-	resourceHasTrait(resource: ObjectWithStringTypeProperty | StableRecordIdentifier, trait: string): boolean;
+	resourceHasTrait(resource: ObjectWithStringTypeProperty | ResourceKey, trait: string): boolean;
 	/**
 	* Queries for the fields of a given resource type or resource identity.
 	*
 	* Should error if the resource type is not recognized.
 	*
 	* @public
-	* @param {StableRecordIdentifier|ObjectWithStringTypeProperty} resource
-	* @return {Map<string, FieldSchema>}
 	*/
-	fields(resource: ObjectWithStringTypeProperty | StableRecordIdentifier): Map<string, FieldSchema>;
+	fields(resource: ObjectWithStringTypeProperty | ResourceKey): Map<string, FieldSchema>;
+	/**
+	* Queries for the fields of a given resource type or resource identity.
+	*
+	* Should error if the resource type is not recognized.
+	*
+	* @public
+	*/
+	cacheFields?(resource: ObjectWithStringTypeProperty | ResourceKey): Map<string, Exclude<CacheableFieldSchema, IdentityField>>;
 	/**
 	* Returns the transformation registered with the name provided
 	* by `field.type`. Validates that the field is a valid transformable.
 	*
 	* @public
-	* @param {TransformableField|ObjectWithStringTypeProperty} field
-	* @return {Transformation}
 	*/
 	transformation(field: GenericField | ObjectField | ArrayField | ObjectWithStringTypeProperty): Transformation;
 	/**
@@ -121,8 +115,6 @@ export interface SchemaService {
 	* by `field.type`. Validates that the field is a valid HashField.
 	*
 	* @public
-	* @param {HashField|ObjectWithStringTypeProperty} field
-	* @return {HashFn}
 	*/
 	hashFn(field: HashField | ObjectWithStringTypeProperty): HashFn;
 	/**
@@ -130,18 +122,14 @@ export interface SchemaService {
 	* by `field.type`. Validates that the field is a valid DerivedField.
 	*
 	* @public
-	* @param {DerivedField|ObjectWithStringTypeProperty} field
-	* @return {Derivation}
 	*/
 	derivation(field: DerivedField | ObjectWithStringTypeProperty): Derivation;
 	/**
 	* Returns the schema for the provided resource type.
 	*
 	* @public
-	* @param {StableRecordIdentifier|ObjectWithStringTypeProperty} resource
-	* @return {ResourceSchema}
 	*/
-	resource(resource: ObjectWithStringTypeProperty | StableRecordIdentifier): Schema;
+	resource(resource: ObjectWithStringTypeProperty | ResourceKey): Schema;
 	/**
 	* Enables registration of multiple Schemas at once.
 	*
@@ -150,7 +138,6 @@ export interface SchemaService {
 	* or other sources just-in-time.
 	*
 	* @public
-	* @param {Schema[]} schemas
 	*/
 	registerResources(schemas: Schema[]): void;
 	/**
@@ -163,7 +150,6 @@ export interface SchemaService {
 	* or other sources just-in-time.
 	*
 	* @public
-	* @param {Schema} schema
 	*/
 	registerResource(schema: Schema): void;
 	/**
@@ -173,7 +159,6 @@ export interface SchemaService {
 	* attached to it's `[Type]` property.
 	*
 	* @public
-	* @param {Transformation} transform
 	*/
 	registerTransformation(transform: Transformation): void;
 	/**
@@ -183,7 +168,6 @@ export interface SchemaService {
 	* attached to it's `[Type]` property.
 	*
 	* @public
-	* @param {Derivation} derivation
 	*/
 	registerDerivation<
 		R,
@@ -197,7 +181,6 @@ export interface SchemaService {
 	* attached to it's `[Type]` property.
 	*
 	* @public
-	* @param {HashFn} hashfn
 	*/
 	registerHashFn(hashFn: HashFn): void;
 	/**
@@ -269,10 +252,8 @@ export interface SchemaService {
 	*
 	* @public
 	* @deprecated
-	* @param {RecordIdentifier|ObjectWithStringTypeProperty} identifier
-	* @return {AttributesSchema}
 	*/
-	attributesDefinitionFor?(identifier: RecordIdentifier | ObjectWithStringTypeProperty): AttributesSchema;
+	attributesDefinitionFor?(key: ResourceKey | ObjectWithStringTypeProperty): AttributesSchema;
 	/**
 	* DEPRECATED - use `fields` instead
 	*
@@ -350,37 +331,44 @@ export interface SchemaService {
 	*
 	* @public
 	* @deprecated
-	* @param {RecordIdentifier|ObjectWithStringTypeProperty} identifier
-	* @return {RelationshipsSchema}
 	*/
-	relationshipsDefinitionFor?(identifier: RecordIdentifier | ObjectWithStringTypeProperty): RelationshipsSchema;
+	relationshipsDefinitionFor?(key: ResourceKey | ObjectWithStringTypeProperty): RelationshipsSchema;
 	/**
 	* Returns all known resource types
 	*
 	* @public
-	* @return {String[]}
 	*/
 	resourceTypes(): Readonly<string[]>;
 	/**
 	* Register an extension for either objects or arrays
+	*
+	* @public
 	*/
 	CAUTION_MEGA_DANGER_ZONE_registerExtension?(extension: CAUTION_MEGA_DANGER_ZONE_Extension): void;
 	/**
 	* Retrieve the extension map for a resource
+	*
+	* @public
 	*/
-	CAUTION_MEGA_DANGER_ZONE_resourceExtensions?(resource: StableRecordIdentifier | {
+	CAUTION_MEGA_DANGER_ZONE_resourceExtensions?(resource: ResourceKey | {
 		type: string;
 	}): null | ProcessedExtension["features"];
 	/**
 	* Retrieve the extension map for an object field
+	*
+	* @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
+	*
+	* @public
 	*/
 	CAUTION_MEGA_DANGER_ZONE_arrayExtensions?(field: ExtensibleField): null | ProcessedExtension["features"];
 	/**
 	* Check if a specific extension has been registered previously
+	*
+	* @public
 	*/
 	CAUTION_MEGA_DANGER_ZONE_hasExtension?(ext: {
 		kind: "object" | "array";

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

@@ -1,12 +1,11 @@
 import type { Value } from "../../../types/json/raw.js";
-import type { Includes, TypedRecordInstance } from "../../../types/record.js";
-export interface BaseFinderOptions<T = unknown> {
+export interface BaseFinderOptions {
 	reload?: boolean;
 	backgroundReload?: boolean;
-	include?: T extends TypedRecordInstance ? Includes<T>[] : string | string[];
+	include?: string | string[];
 	adapterOptions?: Record<string, unknown>;
 }
-export interface FindRecordOptions<T = unknown> extends BaseFinderOptions<T> {
+export interface FindRecordOptions extends BaseFinderOptions {
 	/**
 	* Data to preload into the store before the request is made.
 	* This feature is *highly* discouraged and has no corresponding
@@ -25,8 +24,8 @@ export interface FindRecordOptions<T = unknown> extends BaseFinderOptions<T> {
 	preload?: Record<string, Value>;
 }
 export type QueryOptions = { [K in string | "adapterOptions"]? : K extends "adapterOptions" ? Record<string, unknown> : unknown };
-export type FindAllOptions<T = unknown> = BaseFinderOptions<T>;
-export type LegacyResourceQuery<T = unknown> = {
-	include?: T extends TypedRecordInstance ? Includes<T>[] : string | string[];
+export type FindAllOptions = BaseFinderOptions;
+export type LegacyResourceQuery = {
+	include?: string | string[];
 	[key: string]: Value | undefined;
 };

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

@@ -1,18 +1,18 @@
-import type { StableNewRecordIdentifier, StableRecordIdentifier } from "../../types/identifier.js";
+import type { NewResourceKey, ResourceKey } from "../../types/identifier.js";
 import type { Value } from "../../types/json/raw.js";
-import type { Includes, OpaqueRecordInstance, TypedRecordInstance, TypeFromInstance } from "../../types/record.js";
+import type { OpaqueRecordInstance, TypedRecordInstance, TypeFromInstance } from "../../types/record.js";
 import type { LegacyAttributeField, LegacyRelationshipField } from "../../types/schema/fields.js";
 import type { SingleResourceDocument } from "../../types/spec/json-api-raw.js";
 import { type InstanceCache } from "../-private.js";
 import type { Store } from "./store.js";
-export declare function preloadData(store: Store, identifier: StableNewRecordIdentifier, preload: Record<string, Value>): void;
-export interface BaseFinderOptions<T = unknown> {
+export declare function preloadData(store: Store, identifier: NewResourceKey, preload: Record<string, Value>): void;
+export interface BaseFinderOptions {
 	reload?: boolean;
 	backgroundReload?: boolean;
-	include?: T extends TypedRecordInstance ? Includes<T>[] : string | string[];
+	include?: string | string[];
 	adapterOptions?: Record<string, unknown>;
 }
-export interface FindRecordOptions<T = unknown> extends BaseFinderOptions<T> {
+export interface FindRecordOptions extends BaseFinderOptions {
 	/**
 	* Data to preload into the store before the request is made.
 	* This feature is *highly* discouraged and has no corresponding
@@ -31,9 +31,9 @@ export interface FindRecordOptions<T = unknown> extends BaseFinderOptions<T> {
 	preload?: Record<string, Value>;
 }
 export type QueryOptions = { [K in string | "adapterOptions"]? : K extends "adapterOptions" ? Record<string, unknown> : unknown };
-export type FindAllOptions<T = unknown> = BaseFinderOptions<T>;
-export type LegacyResourceQuery<T = unknown> = {
-	include?: T extends TypedRecordInstance ? Includes<T>[] : string | string[];
+export type FindAllOptions = BaseFinderOptions;
+export type LegacyResourceQuery = {
+	include?: string | string[];
 	[key: string]: Value | undefined;
 };
 export type KeyOrString<T> = keyof T & string extends never ? string : keyof T & string;
@@ -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.
@@ -64,18 +64,7 @@ addon authors to perform meta-operations on a record.
 @public
 */
 export declare class RecordReference {
-	/** @internal */
-	private store;
-	// unsubscribe token given to us by the notification manager
-	/** @internal */
-	private ___token;
-	/** @internal */
-	private ___identifier;
-	/** @internal */
-	private _ref;
-	constructor(store: Store, identifier: StableRecordIdentifier);
-	/** @internal */
-	destroy(): void;
+	constructor(store: Store, identifier: ResourceKey);
 	get type(): string;
 	/**
 	The `id` of the record that this reference refers to.
@@ -112,7 +101,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/declarations/store/deprecated/store.d.ts

@@ -1,6 +1,6 @@
 import type { TypeFromInstance } from "../../types/record.js";
 import type { ResourceIdentifierObject } from "../../types/spec/json-api-raw.js";
-import type { CollectionRecordArray, LiveArray } from "../-private.js";
+import type { LegacyLiveArray, LegacyQueryArray } from "../-private.js";
 import { Store } from "../-private/store-service.js";
 import type { FindAllOptions, FindRecordOptions, LegacyResourceQuery, ModelSchema, QueryOptions } from "./-private.js";
 import { RecordReference } from "./-private.js";
@@ -363,11 +363,11 @@ declare module "../-private/store-service" {
 		@param id - optional object with options for the request only if the first param is a ResourceIdentifier, else the string id of the record to be retrieved
 		@param options - if the first param is a string this will be the optional options for the request. See examples for available options.
 		*/
-		findRecord<T>(type: TypeFromInstance<T>, id: string | number, options?: FindRecordOptions<T>): Promise<T>;
+		findRecord<T>(type: TypeFromInstance<T>, id: string | number, options?: FindRecordOptions): Promise<T>;
 		/** @deprecated */
 		findRecord(type: string, id: string | number, options?: FindRecordOptions): Promise<unknown>;
 		/** @deprecated */
-		findRecord<T>(resource: ResourceIdentifierObject<TypeFromInstance<T>>, options?: FindRecordOptions<T>): Promise<T>;
+		findRecord<T>(resource: ResourceIdentifierObject<TypeFromInstance<T>>, options?: FindRecordOptions): Promise<T>;
 		/** @deprecated */
 		findRecord(resource: ResourceIdentifierObject, options?: FindRecordOptions): Promise<unknown>;
 		/**
@@ -548,9 +548,9 @@ declare module "../-private/store-service" {
 		@param type the name of the resource
 		@param options
 		*/
-		findAll<T>(type: TypeFromInstance<T>, options?: FindAllOptions<T>): Promise<LiveArray<T>>;
+		findAll<T>(type: TypeFromInstance<T>, options?: FindAllOptions): Promise<LegacyLiveArray<T>>;
 		/** @deprecated */
-		findAll(type: string, options?: FindAllOptions): Promise<LiveArray>;
+		findAll(type: string, options?: FindAllOptions): Promise<LegacyLiveArray>;
 		/**
 		This method delegates a query to the adapter. This is the one place where
 		adapter-level semantics are exposed to the application.
@@ -565,13 +565,13 @@ declare module "../-private/store-service" {
 		
 		If you do something like this:
 		
-		```javascript
+		```js
 		store.query('person', { page: 1 });
 		```
 		
 		The request made to the server will look something like this:
 		
-		```
+		```http
 		GET "/api/v1/person?page=1"
 		```
 		
@@ -591,8 +591,7 @@ declare module "../-private/store-service" {
 		```
 		
 		This method returns a promise, which is resolved with a
-		[`Collection`](/ember-data/release/classes/Collection)
-		once the server returns.
+		{@link LegacyQueryArray} once the server returns.
 		
 		@public
 		@deprecated use {@link Store.request} instead
@@ -602,9 +601,9 @@ declare module "../-private/store-service" {
 		@param query a query to be used by the adapter
 		@param options optional, may include `adapterOptions` hash which will be passed to adapter.query
 		*/
-		query<T>(type: TypeFromInstance<T>, query: LegacyResourceQuery<T>, options?: QueryOptions): Promise<CollectionRecordArray<T>>;
+		query<T>(type: TypeFromInstance<T>, query: LegacyResourceQuery, options?: QueryOptions): Promise<LegacyQueryArray<T>>;
 		/** @deprecated */
-		query(type: string, query: LegacyResourceQuery, options?: QueryOptions): Promise<CollectionRecordArray>;
+		query(type: string, query: LegacyResourceQuery, options?: QueryOptions): Promise<LegacyQueryArray>;
 		/**
 		This method makes a request for one record, where the `id` is not known
 		beforehand (if the `id` is known, use [`findRecord`](../methods/findRecord?anchor=findRecord)
@@ -704,7 +703,7 @@ declare module "../-private/store-service" {
 		@param options optional, may include `adapterOptions` hash which will be passed to adapter.queryRecord
 		@return promise which resolves with the found record or `null`
 		*/
-		queryRecord<T>(type: TypeFromInstance<T>, query: LegacyResourceQuery<T>, options?: QueryOptions): Promise<T | null>;
+		queryRecord<T>(type: TypeFromInstance<T>, query: LegacyResourceQuery, options?: QueryOptions): Promise<T | null>;
 		/** @deprecated */
 		queryRecord(type: string, query: LegacyResourceQuery, options?: QueryOptions): Promise<unknown | null>;
 		/**

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

@@ -1,7 +1,7 @@
 type UniversalTransientKey = "REQ_ID";
 type UniversalKey = `(transient) ${UniversalTransientKey}` | "RequestMap" | "PromiseCache" | "RequestCache" | "SkipCache" | "EnableHydration" | "WarpDriveRuntimeConfig";
 type TransientKey = "transactionRef" | "configuredGenerationMethod" | "configuredUpdateMethod" | "configuredForgetMethod" | "configuredResetMethod" | "configuredKeyInfoMethod" | "signalHooks";
-type GlobalKey = `(transient) ${TransientKey}` | "AdapterError" | "InvalidError" | "TimeoutError" | "AbortError" | "UnauthorizedError" | "ForbiddenError" | "NotFoundError" | "ConflictError" | "ServerError" | "#{}" | "#[]" | "Signals" | "AvailableShims" | "FAKE_ARR" | "#source" | "#update" | "#notify" | "IS_COLLECTION" | "Touching" | "RequestPromise" | "SaveOp" | "LEGACY_SUPPORT" | "LegacySupport" | "Graphs" | "IS_FROZEN" | "IS_CACHE_HANDLER" | "CONFIG" | "DEBUG_MAP" | "IDENTIFIERS" | "DOCUMENTS" | "CacheForIdentifierCache" | "RecordCache" | "StoreMap" | "Store" | "$type" | "TransformName" | "RequestSignature" | "IS_FUTURE" | "DOC" | "ManagedArrayMap" | "ManagedObjectMap" | "Support" | "SOURCE" | "MUTATE" | "Destroy" | "Identifier" | "Editable" | "EmbeddedPath" | "EmbeddedField" | "Parent" | "Checkout" | "Legacy";
+type GlobalKey = `(transient) ${TransientKey}` | "AdapterError" | "InvalidError" | "TimeoutError" | "AbortError" | "UnauthorizedError" | "ForbiddenError" | "NotFoundError" | "ConflictError" | "ServerError" | "#{}" | "#[]" | "Signals" | "AvailableShims" | "FAKE_ARR" | "#source" | "#update" | "#notify" | "IS_COLLECTION" | "Touching" | "RequestPromise" | "SaveOp" | "LEGACY_SUPPORT" | "LegacySupport" | "Graphs" | "IS_FROZEN" | "IS_CACHE_HANDLER" | "CONFIG" | "DEBUG_MAP" | "IDENTIFIERS" | "DOCUMENTS" | "RecordCache" | "StoreMap" | "Store" | "$type" | "TransformName" | "RequestSignature" | "IS_FUTURE" | "DOC" | "ManagedArrayMap" | "ManagedObjectMap" | "Support" | "SOURCE" | "Destroy" | "Checkout" | "Commit" | "Context";
 type UniqueSymbol<T extends string> = `___(unique) Symbol(${T})`;
 type UniqueSymbolOr<
 	T,

package/declarations/types/cache/aliases.d.ts

@@ -1,7 +1,7 @@
 // The ResourceBlob is an opaque type that must
 // satisfy two constraints.
-// (1) it should be possible for the IdentifierCache
-// to be able to generate a RecordIdentifier for it
+// (1) it should be possible for the CacheKeyManager
+// to be able to generate a ResourceKey for it
 // whether by default or due to configuration.
 // (2) it should be in a format expected by the Cache.
 // This format is Cache declared.

package/declarations/types/cache/change.d.ts

@@ -1,6 +1,6 @@
-import type { StableDocumentIdentifier, StableRecordIdentifier } from "../identifier.js";
+import type { RequestKey, ResourceKey } from "../identifier.js";
 export interface Change {
-	identifier: StableRecordIdentifier | StableDocumentIdentifier;
+	identifier: ResourceKey | RequestKey;
 	op: "upsert" | "remove";
 	patch?: unknown;
 }

package/declarations/types/cache/mutations.d.ts

@@ -1,48 +1,48 @@
-import type { StableRecordIdentifier } from "../identifier.js";
+import type { ResourceKey } from "../identifier.js";
 export interface AddToResourceRelationshipMutation {
 	op: "add";
-	record: StableRecordIdentifier;
+	record: ResourceKey;
 	field: string;
-	value: StableRecordIdentifier | StableRecordIdentifier[];
+	value: ResourceKey | ResourceKey[];
 	index?: number;
 }
 export interface RemoveFromResourceRelationshipMutation {
 	op: "remove";
-	record: StableRecordIdentifier;
+	record: ResourceKey;
 	field: string;
-	value: StableRecordIdentifier | StableRecordIdentifier[];
+	value: ResourceKey | ResourceKey[];
 	index?: number;
 }
 export interface ReplaceRelatedRecordMutation {
 	op: "replaceRelatedRecord";
-	record: StableRecordIdentifier;
+	record: ResourceKey;
 	field: string;
 	// never null if field is a collection
-	value: StableRecordIdentifier | null;
+	value: ResourceKey | null;
 	// if field is a collection,
 	//  the value we are swapping with
-	prior?: StableRecordIdentifier;
+	prior?: ResourceKey;
 	index?: number;
 }
 export interface ReplaceRelatedRecordsMutation {
 	op: "replaceRelatedRecords";
-	record: StableRecordIdentifier;
+	record: ResourceKey;
 	field: string;
 	// the records to add. If no prior/index
 	//  specified all existing should be removed
-	value: StableRecordIdentifier[];
+	value: ResourceKey[];
 	// if this is a "splice" the
 	//  records we expect to be removed
-	prior?: StableRecordIdentifier[];
+	prior?: ResourceKey[];
 	// if this is a "splice" the
 	//   index to start from
 	index?: number;
 }
 export interface SortRelatedRecordsMutation {
 	op: "sortRelatedRecords";
-	record: StableRecordIdentifier;
+	record: ResourceKey;
 	field: string;
-	value: StableRecordIdentifier[];
+	value: ResourceKey[];
 }
 // A Mutation is an action that updates
 // the local state of the Cache in some