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

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

@@ -3,30 +3,28 @@ export { storeFor } from "./-private/store-service.js";
 export { recordIdentifierFor } from "./-private/caches/instance-cache.js";
 export { CacheHandler, type StoreRequestContext } from "./-private/cache-handler/handler.js";
 export { type CachePolicy } from "./-private/cache-handler/types.js";
-export { isStableIdentifier, isDocumentIdentifier } from "./-private/caches/identifier-cache.js";
+export { isResourceKey, isRequestKey } from "./-private/managers/cache-key-manager.js";
 export { constructResource } from "./-private/utils/construct-resource.js";
 export type { InstanceCache } from "./-private/caches/instance-cache.js";
 export type { FindRecordQuery, Request, SaveRecordMutation, RequestCacheRequestState, RequestStateService } from "./-private/network/request-cache.js";
 export type { CreateRecordProperties } from "./-private/store-service.js";
-// TODO this should be a deprecated helper but we have so much usage of it
-// to also eliminate
 export { coerceId, ensureStringId } from "./-private/utils/coerce-id.js";
 export type { NativeProxy } from "./-private/record-arrays/native-proxy-type-fix.js";
-export { IdentifierArray as LiveArray, Collection as CollectionRecordArray, SOURCE, MUTATE } from "./-private/record-arrays/identifier-array.js";
+export { type ReactiveResourceArray, type PrivateReactiveResourceArray } from "./-private/record-arrays/resource-array.js";
+export { type LegacyLiveArray, type LegacyLiveArray as LiveArray } from "./-private/record-arrays/legacy-live-array.js";
+export { type LegacyQueryArray, type LegacyQueryArray as CollectionRecordArray } from "./-private/record-arrays/legacy-query.js";
 export { RecordArrayManager, fastPush } from "./-private/managers/record-array-manager.js";
-// leaked for private use / test use, should investigate removing
+export { assertPrivateStore, isPrivateStore, type PrivateStore } from "./-private/store-service.js";
+export { assertPrivateCapabilities, type PrivateCacheCapabilitiesManager } from "./-private/managers/cache-capabilities-manager.js";
 export { _clearCaches } from "./-private/caches/instance-cache.js";
-export { peekCache, removeRecordDataFor } from "./-private/caches/cache-utils.js";
-// @ember-data/model needs these temporarily
 export { setRecordIdentifier, StoreMap } from "./-private/caches/instance-cache.js";
-export { setCacheFor } from "./-private/caches/cache-utils.js";
 export { normalizeModelName as _deprecatingNormalize } from "./-private/utils/normalize-model-name.js";
 export type { StoreRequestInput } from "./-private/cache-handler/handler.js";
-export { RelatedCollection } from "./-private/record-arrays/many-array.js";
+export { type LegacyManyArray, type LegacyManyArray as RelatedCollection, createLegacyManyArray } from "./-private/record-arrays/legacy-many-array.js";
 export { log, logGroup } from "./-private/debug/utils.js";
 export { getPromiseState, type PromiseState } from "./-private/new-core-tmp/promise-state.js";
-export { DISPOSE, createRequestSubscription, type SubscriptionArgs, type RequestSubscription } from "./-private/new-core-tmp/request-subscription.js";
+export { DISPOSE, createRequestSubscription, type RequestArgs, type SubscriptionArgs, type RequestComponentArgs, type RequestSubscription, type ContentFeatures, type RecoveryFeatures, type AutorefreshBehaviorCombos, type AutorefreshBehaviorType } from "./-private/new-core-tmp/request-subscription.js";
 export { getRequestState, type RequestLoadingState, type RequestCacheRequestState as RequestState } from "./-private/new-core-tmp/request-state.js";
-export { createMemo, type SignalHooks, waitFor } from "./-private/new-core-tmp/reactivity/configure.js";
-export { memoized, gate, entangleSignal, defineSignal, defineGate, defineNonEnumerableSignal } from "./-private/new-core-tmp/reactivity/signal.js";
-export { ARRAY_SIGNAL, OBJECT_SIGNAL, Signals, type WarpDriveSignal, peekInternalSignal, withSignalStore, notifyInternalSignal, consumeInternalSignal, getOrCreateInternalSignal } from "./-private/new-core-tmp/reactivity/internal.js";
+export { type SignalHooks, waitFor } from "./-private/new-core-tmp/reactivity/configure.js";
+export { signal, memoized, gate, entangleSignal, entangleInitiallyStaleSignal, defineSignal, defineGate, defineNonEnumerableSignal } from "./-private/new-core-tmp/reactivity/signal.js";
+export { ARRAY_SIGNAL, OBJECT_SIGNAL, Signals, type WarpDriveSignal, peekInternalSignal, createInternalMemo, withSignalStore, notifyInternalSignal, consumeInternalSignal, getOrCreateInternalSignal } from "./-private/new-core-tmp/reactivity/internal.js";

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,6 +1,6 @@
 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, CacheableFieldSchema, DerivedField, FieldSchema, GenericField, HashField, IdentityField, LegacyAttributeField, LegacyRelationshipField, ObjectField, Schema, Trait } from "../../../types/schema/fields.js";
@@ -74,7 +74,7 @@ export interface SchemaService {
 	*
 	* @public
 	*/
-	hasResource(resource: ObjectWithStringTypeProperty | StableRecordIdentifier): boolean;
+	hasResource(resource: ObjectWithStringTypeProperty | ResourceKey): boolean;
 	/**
 	* Queries whether the SchemaService recognizes `type` as a resource trait
 	*
@@ -86,7 +86,7 @@ export interface SchemaService {
 	*
 	* @public
 	*/
-	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.
 	*
@@ -94,7 +94,7 @@ export interface SchemaService {
 	*
 	* @public
 	*/
-	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.
 	*
@@ -102,7 +102,7 @@ export interface SchemaService {
 	*
 	* @public
 	*/
-	cacheFields?(resource: ObjectWithStringTypeProperty | StableRecordIdentifier): Map<string, Exclude<CacheableFieldSchema, IdentityField>>;
+	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.
@@ -129,7 +129,7 @@ export interface SchemaService {
 	*
 	* @public
 	*/
-	resource(resource: ObjectWithStringTypeProperty | StableRecordIdentifier): Schema;
+	resource(resource: ObjectWithStringTypeProperty | ResourceKey): Schema;
 	/**
 	* Enables registration of multiple Schemas at once.
 	*
@@ -253,7 +253,7 @@ export interface SchemaService {
 	* @public
 	* @deprecated
 	*/
-	attributesDefinitionFor?(identifier: RecordIdentifier | ObjectWithStringTypeProperty): AttributesSchema;
+	attributesDefinitionFor?(key: ResourceKey | ObjectWithStringTypeProperty): AttributesSchema;
 	/**
 	* DEPRECATED - use `fields` instead
 	*
@@ -332,7 +332,7 @@ export interface SchemaService {
 	* @public
 	* @deprecated
 	*/
-	relationshipsDefinitionFor?(identifier: RecordIdentifier | ObjectWithStringTypeProperty): RelationshipsSchema;
+	relationshipsDefinitionFor?(key: ResourceKey | ObjectWithStringTypeProperty): RelationshipsSchema;
 	/**
 	* Returns all known resource types
 	*
@@ -350,7 +350,7 @@ export interface SchemaService {
 	*
 	* @public
 	*/
-	CAUTION_MEGA_DANGER_ZONE_resourceExtensions?(resource: StableRecordIdentifier | {
+	CAUTION_MEGA_DANGER_ZONE_resourceExtensions?(resource: ResourceKey | {
 		type: string;
 	}): null | ProcessedExtension["features"];
 	/**

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
@@ -221,7 +210,6 @@ export declare class RecordReference {
 	reload(): Promise<unknown>;
 }
 export declare function getShimClass<T>(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string): ShimModelClass<T>;
-// Mimics the static apis of @ember-data/model
 export declare class ShimModelClass<T = unknown> implements ModelSchema<T> {
 	__store: Store;
 	modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;

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

@@ -1,13 +1,9 @@
 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";
-/////////////// IMPORTANT ///////////////////
-///// Move Module Augmentation Into The /////
-///// Legacy Package Once Removed Here  /////
-/////////////////////////////////////////////
 declare module "../-private/store-service" {
 	interface Store {
 		/**
@@ -363,11 +359,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 +544,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 +561,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 +587,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 +597,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 +699,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,12 +1 @@
-// 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
-// whether by default or due to configuration.
-// (2) it should be in a format expected by the Cache.
-// This format is Cache declared.
-//
-// this Opaqueness allows arbitrary storage of any
-// serializable / transferable state including such things
-// as Buffers and Strings.
 export type ResourceBlob = unknown;

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,62 +1,38 @@
-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;
-	// if field is a collection,
-	//  the value we are swapping with
-	prior?: StableRecordIdentifier;
+	value: ResourceKey | null;
+	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[];
-	// if this is a "splice" the
-	//  records we expect to be removed
-	prior?: StableRecordIdentifier[];
-	// if this is a "splice" the
-	//   index to start from
+	value: ResourceKey[];
+	prior?: ResourceKey[];
 	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
-// manner.
-// Most Mutations are in theory also
-// Operations; with the difference being
-// that the change should be applied as
-// "local" or "dirty" state instead of
-// as "remote" or "clean" state.
-//
-// Note: this RFC does not publicly surface
-// any of the mutations listed here as
-// "operations", though the (private) Graph
-// already expects and utilizes these.
-// and we look forward to an RFC that makes
-// the Graph a fully public API.
 export type Mutation = ReplaceRelatedRecordsMutation | ReplaceRelatedRecordMutation | RemoveFromResourceRelationshipMutation | AddToResourceRelationshipMutation | SortRelatedRecordsMutation;