@warp-drive/core 5.6.0-beta.1 → 5.6.0-beta.2

package/declarations/types/cache.d.ts

@@ -3,7 +3,7 @@ import type { Change } from "./cache/change.js";
 import type { Mutation } from "./cache/mutations.js";
 import type { Operation } from "./cache/operations.js";
 import type { CollectionRelationship, ResourceRelationship } from "./cache/relationship.js";
-import type { StableDocumentIdentifier, StableRecordIdentifier } from "./identifier.js";
+import type { RequestKey, ResourceKey } from "./identifier.js";
 import type { Value } from "./json/raw.js";
 import type { TypeFromInstanceOrString } from "./record.js";
 import type { RequestContext, StructuredDataDocument, StructuredDocument } from "./request.js";
@@ -13,20 +13,19 @@ import type { ApiError } from "./spec/error.js";
 * A hash of changed attributes with the key being the attribute name and the value being an
 * array of `[oldValue, newValue]`.
 *
-* @internal
 */
 export type ChangedAttributesHash = Record<string, [Value | undefined, Value]>;
 export type RelationshipDiff = {
 	kind: "collection";
-	remoteState: StableRecordIdentifier[];
-	additions: Set<StableRecordIdentifier>;
-	removals: Set<StableRecordIdentifier>;
-	localState: StableRecordIdentifier[];
+	remoteState: ResourceKey[];
+	additions: Set<ResourceKey>;
+	removals: Set<ResourceKey>;
+	localState: ResourceKey[];
 	reordered: boolean;
 } | {
 	kind: "resource";
-	remoteState: StableRecordIdentifier | null;
-	localState: StableRecordIdentifier | null;
+	remoteState: ResourceKey | null;
+	localState: ResourceKey | null;
 };
 /**
 * The interface for WarpDrive Caches.
@@ -34,16 +33,13 @@ export type RelationshipDiff = {
 * A Cache handles in-memory storage of Document and Resource
 * data.
 *
-* @class (Interface) Cache
 * @public
 */
 export interface Cache {
 	/**
 	* The Cache Version that this implementation implements.
 	*
-	* @type {'2'}
 	* @public
-	* @property version
 	*/
 	version: "2";
 	// Cache Management
@@ -65,8 +61,6 @@ export interface Cache {
 	* a `content` member and therefor must not assume the existence
 	* of `request` and `response` on the document.
 	*
-	* @param {StructuredDocument} doc
-	* @return {ResourceDocument}
 	* @public
 	*/
 	put<T>(doc: StructuredDocument<T> | {
@@ -77,15 +71,12 @@ export interface Cache {
 	* by merging new information into the existing state.
 	*
 	* @public
-	* @param {Operation | Operation[]} op the operation(s) to perform
-	* @return {void}
+	* @param op the operation(s) to perform
 	*/
 	patch(op: Operation | Operation[]): void;
 	/**
 	* Update the "local" or "current" (unpersisted) state of the Cache
 	*
-	* @param {Mutation} mutation
-	* @return {void}
 	* @public
 	*/
 	mutate(mutation: Mutation): void;
@@ -117,11 +108,10 @@ export interface Cache {
 	* notifications for relational data.
 	*
 	* @public
-	* @param {StableRecordIdentifier | StableDocumentIdentifier} identifier
-	* @return {ResourceDocument | ResourceBlob | null} the known resource data
+	* @return the known resource data, if any
 	*/
-	peek<T = unknown>(identifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>): T | null;
-	peek(identifier: StableDocumentIdentifier): ResourceDocument | null;
+	peek<T = unknown>(cacheKey: ResourceKey<TypeFromInstanceOrString<T>>): T | null;
+	peek(cacheKey: RequestKey): ResourceDocument | null;
 	/**
 	* Peek remote resource data from the Cache.
 	*
@@ -152,11 +142,10 @@ export interface Cache {
 	* notifications for relational data.
 	*
 	* @public
-	* @param {StableRecordIdentifier | StableDocumentIdentifier} identifier
-	* @return {ResourceDocument | ResourceBlob | null} the known resource data
+	* @return the known data, if any
 	*/
-	peekRemoteState<T = unknown>(identifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>): T | null;
-	peekRemoteState(identifier: StableDocumentIdentifier): ResourceDocument | null;
+	peekRemoteState<T = unknown>(cacheKey: ResourceKey<TypeFromInstanceOrString<T>>): T | null;
+	peekRemoteState(cacheKey: RequestKey): ResourceDocument | null;
 	/**
 	* Peek the Cache for the existing request data associated with
 	* a cacheable request
@@ -165,21 +154,16 @@ export interface Cache {
 	* that it will return the the request, response, and content
 	* whereas `peek` will return just the `content`.
 	*
-	* @param {StableDocumentIdentifier}
-	* @return {StructuredDocument<ResourceDocument> | null}
 	* @public
 	*/
-	peekRequest(identifier: StableDocumentIdentifier): StructuredDocument<ResourceDocument> | null;
+	peekRequest(cacheKey: RequestKey): StructuredDocument<ResourceDocument> | null;
 	/**
-	* Push resource data from a remote source into the cache for this identifier
+	* Push resource data from a remote source into the cache for this ResourceKey
 	*
 	* @public
-	* @param identifier
-	* @param data
-	* @param hasRecord
-	* @return {void | string[]} if `hasRecord` is true then calculated key changes should be returned
+	* @return if `hasRecord` is true then calculated key changes should be returned
 	*/
-	upsert(identifier: StableRecordIdentifier, data: ResourceBlob, hasRecord: boolean): void | string[];
+	upsert(cacheKey: ResourceKey, data: ResourceBlob, hasRecord: boolean): void | string[];
 	// Cache Forking Support
 	// =====================
 	/**
@@ -190,7 +174,6 @@ export interface Cache {
 	* utilize this method to fork the cache.
 	*
 	* @public
-	* @return {Promise<Cache>}
 	*/
 	fork(): Promise<Cache>;
 	/**
@@ -200,9 +183,6 @@ export interface Cache {
 	* preferring instead to merge at the Store level, which will
 	* utilize this method to merge the caches.
 	*
-	* @param {Cache} cache
-	* @public
-	* @return {Promise<void>}
 	*/
 	merge(cache: Cache): Promise<void>;
 	/**
@@ -214,7 +194,7 @@ export interface Cache {
 	* `Change` entry in the returned array.
 	*
 	* A `Change` is described by an object containing up to
-	* three properties: (1) the `identifier` of the entity that
+	* three properties: (1) the `CacheKey` of the entity that
 	* changed; (2) the `op` code of that change being one of
 	* `upsert` or `remove`, and if the op is `upsert` a `patch`
 	* containing the data to merge into the cache for the given
@@ -229,7 +209,7 @@ export interface Cache {
 	*
 	* ```ts
 	* interface Change {
-	*  identifier: StableRecordIdentifier | StableDocumentIdentifier;
+	*  key: ResourceKey | RequestKey;
 	*  op: 'upsert' | 'remove';
 	*  patch?: unknown;
 	* }
@@ -261,8 +241,6 @@ export interface Cache {
 	* behavior supports optimizing pre/fetching of data for route transitions
 	* via data-only SSR modes.
 	*
-	* @param {ReadableStream} stream
-	* @return {Promise<void>}
 	* @public
 	*/
 	hydrate(stream: ReadableStream<unknown>): Promise<void>;
@@ -275,37 +253,31 @@ export interface Cache {
 	* process. This return value behavior is deprecated.
 	*
 	* @public
-	* @param identifier
-	* @param createArgs
 	*/
-	clientDidCreate(identifier: StableRecordIdentifier, createArgs?: Record<string, unknown>): Record<string, unknown>;
+	clientDidCreate(cacheKey: ResourceKey, createArgs?: Record<string, unknown>): Record<string, unknown>;
 	/**
 	* [LIFECYCLE] Signals to the cache that a resource
 	* will be part of a save transaction.
 	*
 	* @public
-	* @param identifier
 	*/
-	willCommit(identifier: StableRecordIdentifier, context: RequestContext): void;
+	willCommit(cacheKey: ResourceKey, context: RequestContext | null): void;
 	/**
 	* [LIFECYCLE] Signals to the cache that a resource
 	* was successfully updated as part of a save transaction.
 	*
 	* @public
-	* @param identifier - the primary identifier that was operated on
+	* @param the primary ResourceKey that was operated on
 	* @param data - a document in the cache format containing any updated data
-	* @return {SingleResourceDataDocument}
 	*/
-	didCommit(identifier: StableRecordIdentifier, result: StructuredDataDocument<unknown>): SingleResourceDataDocument;
+	didCommit(cacheKey: ResourceKey, result: StructuredDataDocument<unknown> | null): SingleResourceDataDocument;
 	/**
 	* [LIFECYCLE] Signals to the cache that a resource
 	* was update via a save transaction failed.
 	*
 	* @public
-	* @param identifier
-	* @param errors
 	*/
-	commitWasRejected(identifier: StableRecordIdentifier, errors?: ApiError[]): void;
+	commitWasRejected(cacheKey: ResourceKey, errors?: ApiError[]): void;
 	/**
 	* [LIFECYCLE] Signals to the cache that all data for a resource
 	* should be cleared.
@@ -313,40 +285,30 @@ export interface Cache {
 	* This method is a candidate to become a mutation
 	*
 	* @public
-	* @param identifier
 	*/
-	unloadRecord(identifier: StableRecordIdentifier): void;
+	unloadRecord(cacheKey: ResourceKey): void;
 	// Granular Resource Data APIs
 	// ===========================
 	/**
 	* Retrieve the data for an attribute from the cache
 	*
 	* @public
-	* @param identifier
-	* @param field
-	* @return {unknown}
 	*/
-	getAttr(identifier: StableRecordIdentifier, field: string | string[]): Value | undefined;
+	getAttr(cacheKey: ResourceKey, field: string | string[]): Value | undefined;
 	/**
 	* Retrieve remote state without any local changes for a specific attribute
 	*
 	* @public
-	* @param identifier
-	* @param field
-	* @return {unknown}
 	*/
-	getRemoteAttr(identifier: StableRecordIdentifier, field: string | string[]): Value | undefined;
+	getRemoteAttr(cacheKey: ResourceKey, field: string | string[]): Value | undefined;
 	/**
 	* Mutate the data for an attribute in the cache
 	*
 	* This method is a candidate to become a mutation
 	*
 	* @public
-	* @param identifier
-	* @param field
-	* @param value
 	*/
-	setAttr(identifier: StableRecordIdentifier, field: string | string[], value: Value): void;
+	setAttr(cacheKey: ResourceKey, field: string | string[], value: Value): void;
 	/**
 	* Query the cache for the changed attributes of a resource.
 	*
@@ -357,28 +319,23 @@ export interface Cache {
 	* ```
 	*
 	* @public
-	* @param identifier
-	* @return {Record<string, [unknown, unknown]>} `{ <field>: [<old>, <new>] }`
 	*/
-	changedAttrs(identifier: StableRecordIdentifier): ChangedAttributesHash;
+	changedAttrs(cacheKey: ResourceKey): ChangedAttributesHash;
 	/**
 	* Query the cache for whether any mutated attributes exist
 	*
 	* @public
-	* @param identifier
-	* @return {Boolean}
 	*/
-	hasChangedAttrs(identifier: StableRecordIdentifier): boolean;
+	hasChangedAttrs(cacheKey: ResourceKey): boolean;
 	/**
 	* Tell the cache to discard any uncommitted mutations to attributes
 	*
 	* This method is a candidate to become a mutation
 	*
 	* @public
-	* @param identifier
-	* @return {String[]} the names of fields that were restored
+	* @return the names of fields that were restored
 	*/
-	rollbackAttrs(identifier: StableRecordIdentifier): string[];
+	rollbackAttrs(cacheKey: ResourceKey): string[];
 	/**
 	* Query the cache for the changes to relationships of a resource.
 	*
@@ -388,32 +345,28 @@ export interface Cache {
 	* type RelationshipDiff =
 	| {
 	kind: 'collection';
-	remoteState: StableRecordIdentifier[];
-	additions: Set<StableRecordIdentifier>;
-	removals: Set<StableRecordIdentifier>;
-	localState: StableRecordIdentifier[];
+	remoteState: ResourceKey[];
+	additions: Set<ResourceKey>;
+	removals: Set<ResourceKey>;
+	localState: ResourceKey[];
 	reordered: boolean;
 	}
 	| {
 	kind: 'resource';
-	remoteState: StableRecordIdentifier | null;
-	localState: StableRecordIdentifier | null;
+	remoteState: ResourceKey | null;
+	localState: ResourceKey | null;
 	};
 	```
 	*
 	* @public
-	* @param {StableRecordIdentifier} identifier
-	* @return {Map<string, RelationshipDiff>}
 	*/
-	changedRelationships(identifier: StableRecordIdentifier): Map<string, RelationshipDiff>;
+	changedRelationships(cacheKey: ResourceKey): Map<string, RelationshipDiff>;
 	/**
 	* Query the cache for whether any mutated attributes exist
 	*
 	* @public
-	* @param {StableRecordIdentifier} identifier
-	* @return {Boolean}
 	*/
-	hasChangedRelationships(identifier: StableRecordIdentifier): boolean;
+	hasChangedRelationships(cacheKey: ResourceKey): boolean;
 	/**
 	* Tell the cache to discard any uncommitted mutations to relationships.
 	*
@@ -422,28 +375,23 @@ export interface Cache {
 	* This method is a candidate to become a mutation
 	*
 	* @public
-	* @param {StableRecordIdentifier} identifier
-	* @return {String[]} the names of relationships that were restored
+	* @return the names of relationships that were restored
 	*/
-	rollbackRelationships(identifier: StableRecordIdentifier): string[];
+	rollbackRelationships(cacheKey: ResourceKey): string[];
 	/**
 	* Query the cache for the current state of a relationship property
 	*
 	* @public
-	* @param {StableRecordIdentifier} identifier
-	* @param {String} field
 	* @return resource relationship object
 	*/
-	getRelationship(identifier: StableRecordIdentifier, field: string, isCollection?: boolean): ResourceRelationship | CollectionRelationship;
+	getRelationship(cacheKey: ResourceKey, field: string, isCollection?: boolean): ResourceRelationship | CollectionRelationship;
 	/**
 	* Query the cache for the server state of a relationship property without any local changes
 	*
 	* @public
-	* @param {StableRecordIdentifier} identifier
-	* @param {String} field
 	* @return resource relationship object
 	*/
-	getRemoteRelationship(identifier: StableRecordIdentifier, field: string, isCollection?: boolean): ResourceRelationship | CollectionRelationship;
+	getRemoteRelationship(cacheKey: ResourceKey, field: string, isCollection?: boolean): ResourceRelationship | CollectionRelationship;
 	// Resource State
 	// ===============
 	/**
@@ -453,51 +401,39 @@ export interface Cache {
 	* This method is a candidate to become a mutation
 	*
 	* @public
-	* @param identifier
-	* @param {Boolean} isDeleted
 	*/
-	setIsDeleted(identifier: StableRecordIdentifier, isDeleted: boolean): void;
+	setIsDeleted(cacheKey: ResourceKey, isDeleted: boolean): void;
 	/**
 	* Query the cache for any validation errors applicable to the given resource.
 	*
 	* @public
-	* @param identifier
-	* @return {JsonApiError[]}
 	*/
-	getErrors(identifier: StableRecordIdentifier): ApiError[];
+	getErrors(cacheKey: ResourceKey): ApiError[];
 	/**
 	* Query the cache for whether a given resource has any available data
 	*
 	* @public
-	* @param identifier
-	* @return {Boolean}
 	*/
-	isEmpty(identifier: StableRecordIdentifier): boolean;
+	isEmpty(cacheKey: ResourceKey): boolean;
 	/**
 	* Query the cache for whether a given resource was created locally and not
 	* yet persisted.
 	*
 	* @public
-	* @param identifier
-	* @return {Boolean}
 	*/
-	isNew(identifier: StableRecordIdentifier): boolean;
+	isNew(cacheKey: ResourceKey): boolean;
 	/**
 	* Query the cache for whether a given resource is marked as deleted (but not
 	* necessarily persisted yet).
 	*
 	* @public
-	* @param identifier
-	* @return {Boolean}
 	*/
-	isDeleted(identifier: StableRecordIdentifier): boolean;
+	isDeleted(cacheKey: ResourceKey): boolean;
 	/**
 	* Query the cache for whether a given resource has been deleted and that deletion
 	* has also been persisted.
 	*
 	* @public
-	* @param identifier
-	* @return {Boolean}
 	*/
-	isDeletionCommitted(identifier: StableRecordIdentifier): boolean;
+	isDeletionCommitted(cacheKey: ResourceKey): boolean;
 }

package/declarations/types/graph.d.ts

@@ -1,46 +1,46 @@
 import type { AddToResourceRelationshipMutation as AddResourceMutation, RemoveFromResourceRelationshipMutation as RemoveResourceMutation } from "./cache/mutations.js";
 import type { AddToResourceRelationshipOperation as AddResourceOperation, RemoveFromResourceRelationshipOperation as RemoveResourceOperation, UpdateResourceRelationshipOperation } from "./cache/operations.js";
-import type { StableRecordIdentifier } from "./identifier.js";
+import type { ResourceKey } from "./identifier.js";
 import type { CollectionResourceRelationship, SingleResourceRelationship } from "./spec/json-api-raw.js";
 export interface Operation {
 	op: string;
 }
 export interface UpdateRelationshipOperation {
 	op: "updateRelationship";
-	record: StableRecordIdentifier;
+	record: ResourceKey;
 	field: string;
 	value: SingleResourceRelationship | CollectionResourceRelationship;
 }
 export interface DeleteRecordOperation {
 	op: "deleteRecord";
-	record: StableRecordIdentifier;
+	record: ResourceKey;
 	isNew: boolean;
 }
 export interface UnknownOperation {
 	op: "never";
-	record: StableRecordIdentifier;
+	record: ResourceKey;
 	field: string;
 }
 export interface ReplaceRelatedRecordOperation {
 	op: "replaceRelatedRecord";
-	record: StableRecordIdentifier;
+	record: ResourceKey;
 	field: string;
-	value: StableRecordIdentifier | null;
-	prior?: StableRecordIdentifier;
+	value: ResourceKey | null;
+	prior?: ResourceKey;
 	index?: number;
 }
 export interface SortRelatedRecords {
 	op: "sortRelatedRecords";
-	record: StableRecordIdentifier;
+	record: ResourceKey;
 	field: string;
-	value: StableRecordIdentifier[];
+	value: ResourceKey[];
 }
 export interface ReplaceRelatedRecordsOperation {
 	op: "replaceRelatedRecords";
-	record: StableRecordIdentifier;
+	record: ResourceKey;
 	field: string;
-	value: StableRecordIdentifier[];
-	prior?: StableRecordIdentifier[];
+	value: ResourceKey[];
+	prior?: ResourceKey[];
 	index?: number;
 }
 export type RemoteRelationshipOperation = UpdateResourceRelationshipOperation | UpdateRelationshipOperation | ReplaceRelatedRecordOperation | ReplaceRelatedRecordsOperation | RemoveResourceOperation | AddResourceOperation | DeleteRecordOperation | SortRelatedRecords;

package/declarations/types/identifier.d.ts

@@ -1,112 +1,88 @@
 // provided for additional debuggability
 export declare const DEBUG_CLIENT_ORIGINATED: unique symbol;
-export declare const DEBUG_IDENTIFIER_BUCKET: unique symbol;
+export declare const DEBUG_KEY_TYPE: unique symbol;
 export declare const DEBUG_STALE_CACHE_OWNER: unique symbol;
 // also present in production
 export declare const CACHE_OWNER: "__$co";
-export type IdentifierBucket = "record" | "document";
-export interface Identifier {
-	lid: string;
-	clientId?: string;
-}
-export interface ExistingRecordIdentifier<T extends string = string> extends Identifier {
-	id: string;
-	type: T;
-}
-export interface NewRecordIdentifier<T extends string = string> extends Identifier {
-	id: string | null;
-	type: T;
-}
-export type StableDocumentIdentifier = {
-	lid: string;
-};
-export type RequestKey = StableDocumentIdentifier;
+export type CacheKeyType = "record" | "document";
 /**
-* An Identifier specific to a record which may or may not
-* be present in the cache.
+* A referentially stable object with a unique string (lid) that can be used
+* as a reference to request data in the cache.
 *
-* The absence of an `id` DOES NOT indicate that this
-* Identifier is for a new client-created record as it
-* may also indicate that it was generated for a secondary
-* index and the primary `id` index is not yet known.
+* Only requests that are assigned a RequestKey are retrievable/replayable from
+* the cache, though requests without RequestKeys may still update cache state.
 *
-* @internal
+* @public
 */
-export type RecordIdentifier<T extends string = string> = ExistingRecordIdentifier<T> | NewRecordIdentifier<T>;
+export interface RequestKey {
+	lid: string;
+	type: "@document";
+}
+/** @deprecated use {@link RequestKey} */
+export type StableDocumentIdentifier = RequestKey;
 /**
-* Used when an Identifier is known to be the stable version
-*
-* @internal
+* Used when an ResourceKey is known to be the stable version
 */
-export interface StableIdentifier extends Identifier {
-	[DEBUG_IDENTIFIER_BUCKET]?: string;
+interface ResourceKeyBase<T extends string = string> {
+	/**
+	* A string representing a unique identity.
+	*
+	* @public
+	*/
+	lid: string;
+	/**
+	* the primary `ResourceType` or "model name" this ResourceKey belongs to.
+	*
+	* @public
+	*/
+	type: T;
 }
 /**
-* Used when a StableRecordIdentifier was not created locally as part
+* Used when a ResourceKey was not created locally as part
 * of a call to store.createRecord
 *
-* Distinguishing between this Identifier and one for a client created
-* record that was created with an ID is generally speaking not possible
+* Distinguishing between this ResourceKey and one for a client created
+* resource that was created with an ID is generally speaking not possible
 * at runtime, so anything with an ID typically narrows to this.
-*
-* @internal
 */
-export interface StableExistingRecordIdentifier<T extends string = string> extends StableIdentifier {
+export interface PersistedResourceKey<T extends string = string> extends ResourceKeyBase<T> {
+	/**
+	* the PrimaryKey for the resource this ResourceKey represents.
+	*
+	* @public
+	*/
 	id: string;
-	type: T;
-	[DEBUG_CLIENT_ORIGINATED]?: boolean;
-	[CACHE_OWNER]: number | undefined;
-	[DEBUG_STALE_CACHE_OWNER]?: number | undefined;
 }
+/** @deprecated use {@link PersistedResourceKey} */
+export type StableExistingRecordIdentifier<T extends string = string> = PersistedResourceKey<T>;
 /**
-* Used when a StableRecordIdentifier was created locally
+* Used when a ResourceKey was created locally
 * (by a call to store.createRecord).
 *
-* It is possible in rare circumstances to have a StableRecordIdentifier
+* It is possible in rare circumstances to have a ResourceKey
 * that is not for a new record but does not have an ID. This would
 * happen if a user intentionally created one for use with a secondary-index
 * prior to the record having been fully loaded.
-*
-* @internal
 */
-export interface StableNewRecordIdentifier<T extends string = string> extends StableIdentifier {
+export interface NewResourceKey<T extends string = string> extends ResourceKeyBase<T> {
+	/**
+	* the PrimaryKey for the resource this ResourceKey represents. `null`
+	* if not yet assigned a PrimaryKey value.
+	*
+	* @public
+	*/
 	id: string | null;
-	type: T;
-	[DEBUG_CLIENT_ORIGINATED]?: boolean;
-	[CACHE_OWNER]: number | undefined;
-	[DEBUG_STALE_CACHE_OWNER]?: number | undefined;
 }
 /**
 * A referentially stable object with a unique string (lid) that can be used
 * as a reference to data in the cache.
 *
-* Every record instance has a unique identifier, and identifiers may refer
+* Every resource has a unique ResourceKey, and ResourceKeys may refer
 * to data that has never been loaded (for instance, in an async relationship).
 *
-* @class StableRecordIdentifier
-* @public
-*/
-/**
-* A string representing a unique identity.
-*
-* @property lid
-* @type {String}
-* @public
-*/
-/**
-* the primary resource `type` or `modelName` this identity belongs to.
-*
-* @property type
-* @type {String}
-* @public
-*/
-/**
-* the primary id for the record this identity belongs to. `null`
-* if not yet assigned an id.
-*
-* @property id
-* @type {String | null}
 * @public
 */
-export type StableRecordIdentifier<T extends string = string> = StableExistingRecordIdentifier<T> | StableNewRecordIdentifier<T>;
-export type ResourceKey<T extends string = string> = StableRecordIdentifier<T>;
+export type ResourceKey<T extends string = string> = PersistedResourceKey<T> | NewResourceKey<T>;
+/** @deprecated use {@link ResourceKey} */
+export type StableRecordIdentifier<T extends string = string> = ResourceKey<T>;
+export {};

package/declarations/types/params.d.ts

@@ -1,9 +1,8 @@
-import type { Includes, TypedRecordInstance } from "./record.js";
 export type SerializablePrimitive = string | number | boolean | null;
 export type Serializable = SerializablePrimitive | SerializablePrimitive[];
 export type QueryParamsSerializationOptions = {
 	arrayFormat?: "bracket" | "indices" | "repeat" | "comma";
 };
-export type QueryParamsSource<T = unknown> = ({
-	include?: T extends TypedRecordInstance ? Includes<T>[] : string | string[];
+export type QueryParamsSource = ({
+	include?: string | string[];
 } & Record<Exclude<string, "include">, Serializable>) | URLSearchParams;