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

package/declarations/store/-private/record-arrays/native-proxy-type-fix.d.ts

@@ -1,126 +1,3 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/*
-We redefine Proxy because the native Proxy type treats the `target` and
-`receiver` as the same type incorrectly.
-
-We ported this from Typescript's own Proxy types on 3/10/2024.
-*/
-interface ProxyHandler<T extends object> {
-	/**
-	* A trap method for a function call.
-	* @param target The original callable object which is being proxied.
-	* @internal
-	*/
-	apply?(target: T, thisArg: any, argArray: any[]): any;
-	/**
-	* A trap for the `new` operator.
-	* @param target The original object which is being proxied.
-	* @param newTarget The constructor that was originally called.
-	* @internal
-	*/
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-	construct?(target: T, argArray: any[], newTarget: Function): object;
-	/**
-	* A trap for `Object.defineProperty()`.
-	* @param target The original object which is being proxied.
-	* @return A `Boolean` indicating whether or not the property has been defined.
-	* @internal
-	*/
-	defineProperty?(target: T, property: string | symbol, attributes: PropertyDescriptor): boolean;
-	/**
-	* A trap for the `delete` operator.
-	* @param target The original object which is being proxied.
-	* @param p The name or `Symbol` of the property to delete.
-	* @return A `Boolean` indicating whether or not the property was deleted.
-	* @internal
-	*/
-	deleteProperty?(target: T, p: string | symbol): boolean;
-	/**
-	* A trap for getting a property value.
-	* @param target The original object which is being proxied.
-	* @param p The name or `Symbol` of the property to get.
-	* @param receiver The proxy or an object that inherits from the proxy.
-	* @internal
-	*/
-	get?(target: T, p: string | symbol, receiver: any): any;
-	/**
-	* A trap for `Object.getOwnPropertyDescriptor()`.
-	* @param target The original object which is being proxied.
-	* @param p The name of the property whose description should be retrieved.
-	* @internal
-	*/
-	getOwnPropertyDescriptor?(target: T, p: string | symbol): PropertyDescriptor | undefined;
-	/**
-	* A trap for the `[[GetPrototypeOf]]` internal method.
-	* @param target The original object which is being proxied.
-	* @internal
-	*/
-	getPrototypeOf?(target: T): object | null;
-	/**
-	* A trap for the `in` operator.
-	* @param target The original object which is being proxied.
-	* @param p The name or `Symbol` of the property to check for existence.
-	* @internal
-	*/
-	has?(target: T, p: string | symbol): boolean;
-	/**
-	* A trap for `Object.isExtensible()`.
-	* @param target The original object which is being proxied.
-	* @internal
-	*/
-	isExtensible?(target: T): boolean;
-	/**
-	* A trap for `Reflect.ownKeys()`.
-	* @param target The original object which is being proxied.
-	* @internal
-	*/
-	ownKeys?(target: T): ArrayLike<string | symbol>;
-	/**
-	* A trap for `Object.preventExtensions()`.
-	* @param target The original object which is being proxied.
-	* @internal
-	*/
-	preventExtensions?(target: T): boolean;
-	/**
-	* A trap for setting a property value.
-	* @param target The original object which is being proxied.
-	* @param p The name or `Symbol` of the property to set.
-	* @param receiver The object to which the assignment was originally directed.
-	* @return A `Boolean` indicating whether or not the property was set.
-	* @internal
-	*/
-	set?(target: T, p: string | symbol, newValue: any, receiver: any): boolean;
-	/**
-	* A trap for `Object.setPrototypeOf()`.
-	* @param target The original object which is being proxied.
-	* @param newPrototype The object's new prototype or `null`.
-	* @internal
-	*/
-	setPrototypeOf?(target: T, v: object | null): boolean;
-}
-interface ProxyConstructor {
-	/**
-	* Creates a revocable Proxy object.
-	* @param target A target object to wrap with Proxy.
-	* @param handler An object whose properties define the behavior of Proxy when an operation is attempted on it.
-	* @internal
-	*/
-	revocable<T extends object>(target: T, handler: ProxyHandler<T>): {
-		proxy: T;
-		revoke: () => void;
-	};
-	/**
-	* Creates a Proxy object. The Proxy object allows you to create an object that can be used in place of the
-	* original object, but which may redefine fundamental Object operations like getting, setting, and defining
-	* properties. Proxy objects are commonly used to log property accesses, validate, format, or sanitize inputs.
-	* @param target A target object to wrap with Proxy.
-	* @param handler An object whose properties define the behavior of Proxy when an operation is attempted on it.
-	* @internal
-	*/
-	new <
-		TSource extends object,
-		TTarget extends object
-	>(target: TSource, handler: ProxyHandler<TSource>): TTarget;
-}
+interface ProxyConstructor {}
 export declare const NativeProxy: ProxyConstructor;
 export {};

package/declarations/store/-private/record-arrays/resource-array.d.ts

@@ -0,0 +1,75 @@
+import type { ExtensionDef } from "../../../reactive.js";
+import { Context } from "../../../reactive/-private.js";
+import type { RequestKey, ResourceKey } from "../../../types/identifier.js";
+import type { ObjectValue } from "../../../types/json/raw.js";
+import type { CollectionField } from "../../../types/schema/fields.js";
+import type { SignalStore, WarpDriveSignal } from "../new-core-tmp/reactivity/internal.js";
+import type { Store } from "../store-service.js";
+import type { KeyType, MinimumManager } from "./-utils.js";
+import { NativeProxy } from "./native-proxy-type-fix.js";
+declare const IS_COLLECTION: "___(unique) Symbol(IS_COLLECTION)";
+type ProxiedMethod = (...args: unknown[]) => unknown;
+interface ReactiveResourceArrayCreateOptions {
+	// passed in
+	store: Store;
+	manager: MinimumManager;
+	editable: boolean;
+	source: ResourceKey[];
+	// reactive, passed in
+	data: ObjectValue | null;
+	// non-reactive, passed in
+	features: Record<string | symbol, unknown> | null;
+	extensions: Map<string | symbol, ExtensionDef> | null;
+	// not-accessible except by the context
+	options: Record<string, unknown> | null;
+	destroy: null | ((this: ReactiveResourceArray, clear: boolean) => void);
+	mutate: null | ((target: ResourceKey[], receiver: typeof NativeProxy<ResourceKey[], unknown[]>, prop: string, args: unknown[], _SIGNAL: WarpDriveSignal) => unknown);
+}
+interface ReactiveResourceArrayContext extends ReactiveResourceArrayCreateOptions {
+	destroy: (this: ReactiveResourceArray, clear: boolean) => void;
+	mutate: (target: ResourceKey[], receiver: typeof NativeProxy<ResourceKey[], unknown[]>, prop: string, args: unknown[], _SIGNAL: WarpDriveSignal) => unknown;
+	// generated
+	signals: SignalStore;
+	signal: WarpDriveSignal;
+	isDestroying: boolean;
+	isDestroyed: boolean;
+	transaction: boolean;
+	boundFns: Map<KeyType, ProxiedMethod>;
+}
+export interface ReactiveResourceArray<T = unknown> extends Omit<Array<T>, "[]"> {}
+export interface PrivateReactiveResourceArray<T = unknown> extends Omit<Array<T>, "[]"> {
+	isDestroying: boolean;
+	isDestroyed: boolean;
+	destroy: (this: ReactiveResourceArray, clear: boolean) => void;
+	[IS_COLLECTION]: boolean;
+	[Context]: ReactiveResourceArrayContext;
+}
+export interface TargetArray extends Array<ResourceKey> {}
+export declare function createReactiveResourceArray<T>(options: ReactiveResourceArrayCreateOptions): ReactiveResourceArray<T>;
+export declare function destroy(this: ReactiveResourceArray, clear: boolean): void;
+export interface ReactiveRequestCollectionCreateArgs {
+	// passed in
+	store: Store;
+	manager: MinimumManager;
+	source: ResourceKey[];
+	options: {
+		requestKey: RequestKey;
+	} | null;
+}
+export declare function createRequestCollection(config: ReactiveRequestCollectionCreateArgs): ReactiveResourceArray;
+export interface ReactiveRelatedCollectionCreateArgs {
+	// passed in
+	store: Store;
+	manager: MinimumManager;
+	source: ResourceKey[];
+	// not-accessible except by the context
+	options: {
+		resourceKey: ResourceKey;
+		path: string[];
+		field: CollectionField;
+	};
+	editable: boolean;
+	extensions: Map<string | symbol, ExtensionDef> | null;
+}
+export declare function createRelatedCollection(config: ReactiveRelatedCollectionCreateArgs): ReactiveResourceArray;
+export {};

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

@@ -1,8 +1,8 @@
 import type { Graph } from "../../graph/-private.js";
 import type { Future } from "../../request.js";
-import type { RequestManager } from "../../request/-private/manager.js";
+import type { PrivateRequestManager, RequestManager } from "../../request/-private/manager.js";
 import type { Cache } from "../../types/cache.js";
-import type { StableExistingRecordIdentifier, StableRecordIdentifier } from "../../types/identifier.js";
+import type { PersistedResourceKey, ResourceKey } from "../../types/identifier.js";
 import type { TypedRecordInstance, TypeFromInstance } from "../../types/record.js";
 import type { CollectionResourceDocument, EmptyResourceDocument, JsonApiDocument, ResourceIdentifierObject, SingleResourceDocument } from "../../types/spec/json-api-raw.js";
 import type { Type } from "../../types/symbols.js";
@@ -11,12 +11,15 @@ import type { OpaqueRecordInstance } from "../-types/q/record-instance.js";
 import type { SchemaService } from "../-types/q/schema-service.js";
 import type { StoreRequestInput } from "./cache-handler/handler.js";
 import type { CachePolicy } from "./cache-handler/types.js";
-import { IdentifierCache } from "./caches/identifier-cache.js";
 import { InstanceCache, storeFor } from "./caches/instance-cache.js";
+import type { PrivateCacheKeyManager } from "./managers/cache-key-manager.js";
+import { CacheKeyManager } from "./managers/cache-key-manager.js";
+import type { PrivateNotificationManager } from "./managers/notification-manager.js";
 import NotificationManager from "./managers/notification-manager.js";
-import { RecordArrayManager } from "./managers/record-array-manager.js";
+import type { PrivateRecordArrayManager } from "./managers/record-array-manager.js";
+import type { PrivateRequestStateService } from "./network/request-cache.js";
 import { RequestStateService } from "./network/request-cache.js";
-import type { IdentifierArray } from "./record-arrays/identifier-array.js";
+import type { LegacyLiveArray } from "./record-arrays/legacy-live-array.js";
 export { storeFor };
 // We inline this list of methods to avoid importing EmberObject
 type EmberObjectKey = "_debugContainerKey" | "_super" | "addObserver" | "cacheFor" | "concatenatedProperties" | "decrementProperty" | "destroy" | "get" | "getProperties" | "incrementProperty" | "init" | "isDestroyed" | "isDestroying" | "mergedProperties" | "notifyPropertyChange" | "removeObserver" | "reopen" | "set" | "setProperties" | "toggleProperty" | "toString" | "willDestroy";
@@ -45,6 +48,9 @@ type MaybeHasId = {
 *
 */
 export type CreateRecordProperties<T = MaybeHasId & Record<string, unknown>> = T extends TypedRecordInstance ? Partial<FilteredKeys<T>> : T extends MaybeHasId ? MaybeHasId & Partial<FilteredKeys<T>> : MaybeHasId & Record<string, unknown>;
+export interface CreateContext {
+	lid?: string;
+}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type ConstructorFunction = new (...args: any[]) => any;
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
@@ -76,7 +82,7 @@ export interface Store {
 	* @public
 	*/
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	instantiateRecord<T>(identifier: StableRecordIdentifier, createRecordArgs: {
+	instantiateRecord<T>(identifier: ResourceKey, createRecordArgs: {
 		[key: string]: unknown;
 	}): OpaqueRecordInstance;
 	/**
@@ -144,7 +150,6 @@ export interface Store {
 	* be sourced from directly registered schemas, then will fallback
 	* to sourcing a schema from available models if no schema is found.
 	*
-	* @return {SchemaService}
 	* @public
 	*/
 	createSchemaService(): SchemaService;
@@ -190,11 +195,11 @@ export interface Store {
 	*     return this._schema.hasResource(resource);
 	*   }
 	*
-	*   attributesDefinitionFor(identifier: RecordIdentifier | { type: string }): AttributesSchema {
+	*   attributesDefinitionFor(identifier: ResourceKey | { type: string }): AttributesSchema {
 	*     return this._schema.attributesDefinitionFor(identifier);
 	*   }
 	*
-	*   relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }): RelationshipsSchema {
+	*   relationshipsDefinitionFor(identifier: ResourceKey | { type: string }): RelationshipsSchema {
 	*     const schema = AbstractSchemas.get(identifier.type);
 	*     return schema || this._schema.relationshipsDefinitionFor(identifier);
 	*   }
@@ -244,11 +249,11 @@ export interface Store {
 	*     return this._schema.hasResource(resource);
 	*   }
 	*
-	*   attributesDefinitionFor(identifier: RecordIdentifier | { type: string }): AttributesSchema {
+	*   attributesDefinitionFor(identifier: ResourceKey | { type: string }): AttributesSchema {
 	*     return this._schema.attributesDefinitionFor(identifier);
 	*   }
 	*
-	*   relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }): RelationshipsSchema {
+	*   relationshipsDefinitionFor(identifier: ResourceKey | { type: string }): RelationshipsSchema {
 	*     const schema = AbstractSchemas.get(identifier.type);
 	*     return schema || this._schema.relationshipsDefinitionFor(identifier);
 	*   }
@@ -289,8 +294,6 @@ export interface Store {
 * @hideconstructor
 */
 export declare class Store extends BaseClass {
-	/** @internal */
-	readonly recordArrayManager: RecordArrayManager;
 	/**
 	* Provides access to the NotificationManager associated
 	* with this Store instance.
@@ -311,18 +314,17 @@ export declare class Store extends BaseClass {
 	* @public
 	*/
 	get schema(): ReturnType<this["createSchemaService"]>;
-	/** @internal */
-	_schema: SchemaService;
 	/**
-	* Provides access to the IdentifierCache instance
+	* Provides access to the CacheKeyManager
 	* for this store.
 	*
-	* The IdentifierCache can be used to generate or
-	* retrieve a stable unique identifier for any resource.
+	* The CacheKeyManager can be used to generate or
+	* retrieve a stable unique CacheKey for any resource
+	* or request.
 	*
 	* @public
 	*/
-	readonly identifierCache: IdentifierCache;
+	readonly cacheKeyManager: CacheKeyManager;
 	/**
 	* Provides access to the requestManager instance associated
 	* with this Store instance.
@@ -353,7 +355,7 @@ export declare class Store extends BaseClass {
 	*
 	* Note, when defined, these methods will only be invoked if a
 	* cache key exists for the request, either because the request
-	* contains `cacheOptions.key` or because the [IdentifierCache](/ember-data/release/classes/IdentifierCache)
+	* contains `cacheOptions.key` or because the [CacheKeyManager](/ember-data/release/classes/CacheKeyManager)
 	* was able to generate a key for the request using the configured
 	* [generation method](/ember-data/release/functions/@ember-data%2Fstore/setIdentifierGenerationMethod).
 	*
@@ -362,12 +364,12 @@ export declare class Store extends BaseClass {
 	* ```ts
 	* store.lifetimes = {
 	*   // make the request and ignore the current cache state
-	*   isHardExpired(identifier: StableDocumentIdentifier): boolean {
+	*   isHardExpired(key: RequestKey): boolean {
 	*     return false;
 	*   }
 	*
 	*   // make the request in the background if true, return cache state
-	*   isSoftExpired(identifier: StableDocumentIdentifier): boolean {
+	*   isSoftExpired(key: RequestKey): boolean {
 	*     return false;
 	*   }
 	* }
@@ -376,65 +378,16 @@ export declare class Store extends BaseClass {
 	* @public
 	*/
 	lifetimes?: CachePolicy;
-	// Private
-	/** @internal */
-	_graph?: Graph;
-	/** @internal */
-	_requestCache: RequestStateService;
-	/** @internal */
-	_instanceCache: InstanceCache;
-	/** @internal */
-	_cbs: {
-		coalesce?: () => void;
-		sync?: () => void;
-		notify?: () => void;
-	} | null;
-	/** @internal */
-	_forceShim: boolean;
-	/**
-	* Async flush buffers notifications until flushed
-	* by finalization of a future configured by store.request
-	*
-	* This is useful for ensuring that notifications are delivered
-	* prior to the promise resolving but without risk of promise
-	* interleaving.
-	*
-	* @internal
-	*/
-	_enableAsyncFlush: boolean | null;
-	// DEBUG-only properties
-	/** @internal */
-	DISABLE_WAITER?: boolean;
-	/** @internal */
-	_isDestroying: boolean;
-	/** @internal */
-	_isDestroyed: boolean;
-	/** @internal */
+	/** @private */
 	get isDestroying(): boolean;
-	/** @internal */
-	set isDestroying(value: boolean);
-	/** @internal */
+	/** @private */
 	get isDestroyed(): boolean;
-	/** @internal */
-	set isDestroyed(value: boolean);
+	/** @deprecated use {@link Store.cacheKeyManager} */
+	get identifierCache(): CacheKeyManager;
 	/**
 	@private
 	*/
 	constructor(createArgs?: unknown);
-	/** @internal */
-	_run(cb: () => void): void;
-	/**
-	* Executes the callback, ensurng that any work that calls
-	* store._schedule is executed after in the right order.
-	*
-	* When queues already exist, scheduled callbacks will
-	* join the existing queue.
-	*
-	* @internal
-	*/
-	_join(cb: () => void): void;
-	/** @internal */
-	_schedule(name: "coalesce" | "sync" | "notify", cb: () => void): void;
 	/**
 	* Retrieve the RequestStateService instance
 	* associated with this Store.
@@ -446,10 +399,6 @@ export declare class Store extends BaseClass {
 	* @public
 	*/
 	getRequestStateService(): RequestStateService;
-	/** @internal */
-	_getAllPending(): (Promise<unknown[]> & {
-		length: number;
-	}) | void;
 	/**
 	* ::: tip 💡 For a more complete overview see the [Request Guide](/guides/2-requests/1-overview)
 	* :::
@@ -464,7 +413,7 @@ export declare class Store extends BaseClass {
 	* {@link CacheOptions.key | cache key} will have the request result
 	* and document cached.
 	*
-	* The cache key used is {@link RequestInfo.cacheOptions | RequestInfo.cacheOptions.key}
+	* The cache key used is {@link RequestInfo.cacheOptions.key | RequestInfo.cacheOptions.key}
 	* if present, falling back to {@link RequestInfo.url}.
 	*
 	* Params are not serialized as part of the cache-key, so
@@ -503,40 +452,77 @@ export declare class Store extends BaseClass {
 	*
 	* @public
 	*/
-	request<
-		RT,
-		T = unknown
-	>(requestConfig: StoreRequestInput<RT, T>): Future<RT>;
+	request<RT>(requestConfig: StoreRequestInput<RT>): Future<RT>;
 	/**
-	Create a new record in the current store. The properties passed
-	to this method are set on the newly created record.
+	Creates a new record in the current store.
 	
-	To create a new instance of a `Post`:
+	> [!CAUTION]
+	> This should not be used to mock records or to create
+	> a record representing data that could be fetched from
+	> the API.
+	
+	The properties passed to this method are set on
+	the newly created record.
+	
+	For instance: to create a new `post`:
 	
 	```js
 	store.createRecord('post', {
-	title: 'Ember is awesome!'
+	title: 'WarpDrive is Stellar!'
 	});
 	```
 	
-	To create a new instance of a `Post` that has a relationship with a `User` record:
+	Relationships can be set during create. For instance,
+	to create a new `post` that has an existing user as
+	it's author:
 	
 	```js
-	let user = this.store.peekRecord('user', '1');
+	const user = store.peekRecord('user', '1');
+	
 	store.createRecord('post', {
-	title: 'Ember is awesome!',
+	title: 'WarpDrive is Stellar!',
 	user: user
 	});
 	```
 	
+	### lid handling
+	
+	All new records are assigned an `lid` that can be used to handle
+	transactional saves of multiple records, or to link the data to
+	other data in scenarios involving eventual-consistency or remote
+	syncing.
+	
+	```ts
+	const post = store.createRecord('post', {
+	title: 'WarpDrive is Stellar!'
+	});
+	const { lid } = recordIdentifierFor(post);
+	```
+	
+	The `lid` defaults to a uuidv4 string.
+	
+	In order to support receiving knowledge about unpersisted creates
+	from other sources (say a different tab in the same web-browser),
+	createRecord allows for the `lid` to be provided as part of an
+	optional third argument. **If this lid already exists in the store
+	an error will be thrown.**
+	
+	```ts
+	const post = store.createRecord(
+	'post',
+	{ title: 'WarpDrive is Stellar!' },
+	{ lid: '4d47bb88-931f-496e-986d-c4888cef7373' }
+	);
+	```
+	
 	@public
-	@param {String} type the name of the resource
-	@param {Object} inputProperties a hash of properties to set on the
+	@param type the name of the resource
+	@param inputProperties a hash of properties to set on the
 	newly created record.
-	@return {Model} record
+	@return a record in the "isNew" state
 	*/
-	createRecord<T>(type: TypeFromInstance<T>, inputProperties: CreateRecordProperties<T>): T;
-	createRecord(type: string, inputProperties: CreateRecordProperties): OpaqueRecordInstance;
+	createRecord<T>(type: TypeFromInstance<T>, inputProperties: CreateRecordProperties<T>, context?: CreateContext): T;
+	createRecord(type: string, inputProperties: CreateRecordProperties, context?: CreateContext): OpaqueRecordInstance;
 	/**
 	For symmetry, a record can be deleted via the store.
 	
@@ -644,8 +630,8 @@ export declare class Store extends BaseClass {
 	@param {String} type the name of the resource
 	@return {RecordArray}
 	*/
-	peekAll<T>(type: TypeFromInstance<T>): IdentifierArray<T>;
-	peekAll(type: string): IdentifierArray;
+	peekAll<T>(type: TypeFromInstance<T>): LegacyLiveArray<T>;
+	peekAll(type: string): LegacyLiveArray;
 	/**
 	This method unloads all records in the store.
 	It schedules unloading to happen during the next run loop.
@@ -823,9 +809,9 @@ export declare class Store extends BaseClass {
 	
 	@private
 	@param {Object} jsonApiDoc
-	@return {StableRecordIdentifier|Array<StableRecordIdentifier>|null} identifiers for the primary records that had data loaded
+	@return {ResourceKey|Array<ResourceKey>|null} identifiers for the primary records that had data loaded
 	*/
-	_push(jsonApiDoc: JsonApiDocument, asyncFlush?: boolean): StableExistingRecordIdentifier | StableExistingRecordIdentifier[] | null;
+	_push(jsonApiDoc: JsonApiDocument, asyncFlush?: boolean): PersistedResourceKey | PersistedResourceKey[] | null;
 	/**
 	* Returns the cache instance associated to this Store, instantiates the Cache
 	* if necessary via `Store.createCache`
@@ -833,7 +819,7 @@ export declare class Store extends BaseClass {
 	* @public
 	*/
 	get cache(): ReturnType<this["createCache"]>;
-	/** @internal */
+	/** @private */
 	destroy(): void;
 	/**
 	* This method
@@ -842,4 +828,73 @@ export declare class Store extends BaseClass {
 	*/
 	static create(args?: Record<string, unknown>): Store;
 }
+/**
+* This type exists for internal use only for
+* where intimate contracts still exist either for
+* the Test Suite or for Legacy code.
+*
+* @private
+*/
+export interface PrivateStore extends Store {
+	readonly recordArrayManager: PrivateRecordArrayManager;
+	notifications: PrivateNotificationManager;
+	requestManager: PrivateRequestManager;
+	cacheKeyManager: PrivateCacheKeyManager;
+	_schema: SchemaService;
+	_graph?: Graph;
+	_requestCache: PrivateRequestStateService;
+	getRequestStateService(): PrivateRequestStateService;
+	_instanceCache: InstanceCache;
+	_cbs: {
+		coalesce?: () => void;
+		sync?: () => void;
+		notify?: () => void;
+	} | null;
+	_forceShim: boolean;
+	/**
+	* Async flush buffers notifications until flushed
+	* by finalization of a future configured by store.request
+	*
+	* This is useful for ensuring that notifications are delivered
+	* prior to the promise resolving but without risk of promise
+	* interleaving.
+	*/
+	_enableAsyncFlush: boolean | null;
+	/**
+	* Available in DEBUG Only
+	*/
+	DISABLE_WAITER?: boolean;
+	_isDestroying: boolean;
+	_isDestroyed: boolean;
+	isDestroying: boolean;
+	isDestroyed: boolean;
+	_run(cb: () => void): void;
+	/**
+	* Executes the callback, ensurng that any work that calls
+	* store._schedule is executed after in the right order.
+	*
+	* When queues already exist, scheduled callbacks will
+	* join the existing queue.
+	*
+	*/
+	_join(cb: () => void): void;
+	_schedule(name: "coalesce" | "sync" | "notify", cb: () => void): void;
+	_getAllPending(): (Promise<unknown[]> & {
+		length: number;
+	}) | void;
+}
+/**
+* Upgrade the type for Store to PrivateStore, which will also
+* upgrade any associated types to their private equivalents.
+*
+* @private
+*/
+export declare function assertPrivateStore(store: unknown): asserts store is PrivateStore;
+/**
+* Upgrade the type for Store to PrivateStore, which will also
+* upgrade any associated types to their private equivalents.
+*
+* @private
+*/
+export declare function isPrivateStore(store: unknown): PrivateStore;
 export declare function isMaybeIdentifier(maybeIdentifier: string | ResourceIdentifierObject): maybeIdentifier is ResourceIdentifierObject;

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

@@ -3,7 +3,7 @@ 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";
@@ -12,21 +12,24 @@ export type { CreateRecordProperties } from "./-private/store-service.js";
 // 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 test/legacy use. You will get in trouble for this.
+export { assertPrivateStore, isPrivateStore, type PrivateStore } from "./-private/store-service.js";
+export { assertPrivateCapabilities, type PrivateCacheCapabilitiesManager } from "./-private/managers/cache-capabilities-manager.js";
 // leaked for private use / test use, should investigate removing
 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 { signal, 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";