@warp-drive/core 5.7.0-alpha.37 → 5.7.0-alpha.39

package/declarations/graph/-private/-state.d.ts

@@ -1,96 +1,9 @@
 export interface RelationshipState {
-	/*
-	This flag indicates whether we should consider the content
-	of this relationship "known".
-	
-	If we have no relationship knowledge, and the relationship
-	is `async`, we will attempt to fetch the relationship on
-	access if it is also stale.
-	
-	Snapshot uses this to tell the difference between unknown
-	(`undefined`) or empty (`null`). The reason for this is that
-	we wouldn't want to serialize  unknown relationships as `null`
-	as that might overwrite remote state.
-	
-	All relationships for a newly created (`store.createRecord()`) are
-	considered known (`hasReceivedData === true`).
-	
-	true when
-	=> we receive a push with either new data or explicit empty (`[]` or `null`)
-	=> the relationship is a belongsTo and we have received data from
-	the other side.
-	
-	false when
-	=> we have received no signal about what data belongs in this relationship
-	=> the relationship is a hasMany and we have only received data from
-	the other side.
-	*/
 	hasReceivedData: boolean;
-	/*
-	Flag that indicates whether an empty relationship is explicitly empty
-	(signaled by push giving us an empty array or null relationship)
-	e.g. an API response has told us that this relationship is empty.
-	
-	Thus far, it does not appear that we actually need this flag; however,
-	@runspired has found it invaluable when debugging relationship tests
-	to determine whether (and why if so) we are in an incorrect state.
-	
-	true when
-	=> we receive a push with explicit empty (`[]` or `null`)
-	=> we have received no signal about what data belongs in this relationship
-	=> on initial create (as no signal is known yet)
-	
-	false at all other times
-	*/
 	isEmpty: boolean;
-	/*
-	This flag indicates whether we should
-	re-fetch the relationship the next time
-	it is accessed.
-	
-	The difference between this flag and `shouldForceReload`
-	is in how we treat the presence of partially missing data:
-	- for a forced reload, we will reload the link or EVERY record
-	- for a stale reload, we will reload the link (if present) else only MISSING records
-	
-	Ideally these flags could be merged, but because we don't give the
-	request layer the option of deciding how to resolve the data being queried
-	we are forced to differentiate for now.
-	
-	It is also possible for a relationship to remain stale after a forced reload; however,
-	in this case `state.hasFailedLoadAttempt` ought to be `true`.
-	
-	false when
-	=> cache.isNew(resourceKey) on initial setup
-	=> a previously triggered request has resolved
-	=> we get relationship data via push
-	
-	true when
-	=> !cache.isNew(resourceKey) on initial setup
-	=> an inverse has been unloaded
-	=> we get a new link for the relationship
-	
-	TODO @runspired unskip the acceptance tests and fix these flags
-	*/
 	isStale: boolean;
 	hasFailedLoadAttempt: boolean;
-	/*
-	This flag forces fetch. `true` for a single request once `reload()`
-	has been called `false` at all other times.
-	*/
 	shouldForceReload: boolean;
-	/*
-	This flag indicates whether we should
-	**partially** re-fetch the relationship the
-	next time it is accessed.
-	
-	false when
-	=> initial setup
-	=> a previously triggered request has resolved
-	
-	true when
-	=> an inverse has been unloaded
-	*/
 	hasDematerializedInverse: boolean;
 }
 export declare function createState(): RelationshipState;

package/declarations/graph/-private/-utils.d.ts

@@ -20,12 +20,6 @@ export declare function isBelongsTo(relationship: GraphEdge): relationship is Re
 export declare function isImplicit(relationship: GraphEdge): relationship is ImplicitEdge;
 export declare function isHasMany(relationship: GraphEdge): relationship is CollectionEdge;
 export declare function forAllRelatedIdentifiers(rel: GraphEdge, cb: (resourceKey: ResourceKey) => void): void;
-/*
-Removes the given identifier from BOTH remote AND local state.
-
-This method is useful when either a deletion or a rollback on a new record
-needs to entirely purge itself from an inverse relationship.
-*/
 export declare function removeIdentifierCompletelyFromRelationship(graph: Graph, relationship: GraphEdge, value: ResourceKey, silenceNotifications?: boolean): void;
 export declare function notifyChange(graph: Graph, relationship: CollectionEdge | ResourceEdge): void;
 export declare function assertRelationshipData(store: Store, resourceKey: ResourceKey, data: ResourceIdentifierObject, meta: UpgradedMeta): void;

package/declarations/graph/-private/coerce-id.d.ts

@@ -1,9 +1,3 @@
-// Used by the store to normalize IDs entering the store.  Despite the fact
-// that developers may provide IDs as numbers (e.g., `store.findRecord('person', 1)`),
-// it is important that internally we use strings, since IDs may be serialized
-// and lose type information.  For example, Ember's router may put a record's
-// ID into the URL, and if we later try to deserialize that URL and find the
-// corresponding record, we will not know if it is a string or a number.
 type Coercable = string | number | boolean | null | undefined | symbol;
 export declare function coerceId(id: Coercable): string | null;
 export declare function ensureStringId(id: Coercable): string;

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

@@ -1,18 +1,6 @@
 import type { CacheCapabilitiesManager } from "../../../types.js";
 import type { ResourceKey } from "../../../types/identifier.js";
 import { type UpgradedMeta } from "../-edge-definition.js";
-/*
-Assert that `addedRecord` has a valid type so it can be added to the
-relationship of the `record`.
-
-The assert basically checks if the `addedRecord` can be added to the
-relationship (specified via `relationshipMeta`) of the `record`.
-
-This utility should only be used internally, as both record parameters must
-be ResourceKeys and the `relationshipMeta` needs to be the meta
-information about the relationship, retrieved via
-`record.relationshipFor(key)`.
-*/
 declare let assertPolymorphicType: (parentIdentifier: ResourceKey, parentDefinition: UpgradedMeta, addedIdentifier: ResourceKey, store: CacheCapabilitiesManager) => void;
 declare let assertInheritedSchema: (definition: UpgradedMeta, type: string) => void;
 export { assertPolymorphicType, assertInheritedSchema };

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

@@ -15,25 +15,6 @@ type PendingOps = {
 	hasMany?: Map<string, Map<string, RemoteRelationshipOperation[]>>;
 	deletions: DeleteRecordOperation[];
 };
-/*
-* Graph acts as the cache for relationship data. It allows for
-* us to ask about and update relationships for a given Identifier
-* without requiring other objects for that Identifier to be
-* instantiated (such as `RecordData` or a `Record`)
-*
-* This also allows for us to make more substantive changes to relationships
-* with increasingly minor alterations to other portions of the internals
-* over time.
-*
-* The graph is made up of nodes and edges. Each unique identifier gets
-* its own node, which is a dictionary with a list of that node's edges
-* (or connections) to other nodes. In `Model` terms, a node represents a
-* record instance, with each key (an edge) in the dictionary correlating
-* to either a `hasMany` or `belongsTo` field on that record instance.
-*
-* The value for each key, or `edge` is the identifier(s) the node relates
-* to in the graph from that key.
-*/
 export declare class Graph {
 	_definitionCache: EdgeCache;
 	_metaCache: Record<string, Record<string, UpgradedMeta>>;
@@ -55,17 +36,6 @@ export declare class Graph {
 	get(resourceKey: ResourceKey, propertyName: string): GraphEdge;
 	getData(resourceKey: ResourceKey, propertyName: string): ResourceRelationship | CollectionRelationship;
 	getRemoteData(resourceKey: ResourceKey, propertyName: string): ResourceRelationship | CollectionRelationship;
-	/*
-	* Allows for the graph to dynamically discover polymorphic connections
-	* without needing to walk prototype chains.
-	*
-	* Used by edges when an added `type` does not match the expected `type`
-	* for that edge.
-	*
-	* Currently we assert before calling this. For a public API we will want
-	* to call out to the schema manager to ask if we should consider these
-	* types as equivalent for a given relationship.
-	*/
 	registerPolymorphicType(type1: string, type2: string): void;
 	isReleasable(resourceKey: ResourceKey): boolean;
 	unload(resourceKey: ResourceKey, silenceNotifications?: boolean): void;
@@ -74,13 +44,7 @@ export declare class Graph {
 	hasChanged(resourceKey: ResourceKey): boolean;
 	rollback(resourceKey: ResourceKey): string[];
 	remove(resourceKey: ResourceKey): void;
-	/*
-	* Remote state changes
-	*/
 	push(op: RemoteRelationshipOperation): void;
-	/*
-	* Local state changes
-	*/
 	update(op: RemoteRelationshipOperation | MergeOperation, isRemote: true): void;
 	update(op: LocalRelationshipOperation, isRemote?: false): void;
 	_scheduleLocalSync(relationship: CollectionEdge): void;

package/declarations/graph/-private/normalize-link.d.ts

@@ -1,8 +1,2 @@
 import type { Link, LinkObject } from "../../types/spec/json-api-raw.js";
-/*
-This method normalizes a link to an "links object". If the passed link is
-already an object it's returned without any modifications.
-
-See http://jsonapi.org/format/#document-links for more information.
-*/
 export default function _normalizeLink(link: Link): LinkObject | null;

package/declarations/graph/-private/operations/replace-related-records.d.ts

@@ -1,61 +1,6 @@
 import type { ResourceKey } from "../../../types.js";
 import type { ReplaceRelatedRecordsOperation } from "../../../types/graph.js";
 import type { Graph } from "../graph.js";
-/*
-case many:1
-========
-In a bi-directional graph with Many:1 edges, adding a value
-results in up-to 3 discrete value transitions, while removing
-a value is only 2 transitions.
-
-For adding C to A
-If: A <<-> B, C <->> D is the initial state,
-and: B <->> A <<-> C, D is the final state
-
-then we would undergo the following transitions.
-
-add C to A
-remove C from D
-add A to C
-
-For removing B from A
-If: A <<-> B, C <->> D is the initial state,
-and: A, B, C <->> D is the final state
-
-then we would undergo the following transitions.
-
-remove B from A
-remove A from B
-
-case many:many
-===========
-In a bi-directional graph with Many:Many edges, adding or
-removing a value requires only 2 value transitions.
-
-For Adding
-If: A<<->>B, C<<->>D is the initial state (double arrows representing the many side)
-And: D<<->>C<<->>A<<->>B is the final state
-
-Then we would undergo two transitions.
-
-add C to A.
-add A to C
-
-For Removing
-If: A<<->>B, C<<->>D is the initial state (double arrows representing the many side)
-And: A, B, C<<->>D is the final state
-
-Then we would undergo two transitions.
-
-remove B from A
-remove A from B
-
-case many:?
-========
-In a uni-directional graph with Many:? edges (modeled in WarpDrive with `inverse:null`) with
-artificial (implicit) inverses, replacing a value results in 2 discrete value transitions.
-This is because a Many:? relationship is effectively Many:Many.
-*/
 export default function replaceRelatedRecords(graph: Graph, op: ReplaceRelatedRecordsOperation, isRemote: boolean): void;
 export declare function addToInverse(graph: Graph, resourceKey: ResourceKey, key: string, value: ResourceKey, isRemote: boolean): void;
 export declare function notifyInverseOfPotentialMaterialization(graph: Graph, resourceKey: ResourceKey, key: string, value: ResourceKey, isRemote: boolean): void;

package/declarations/graph/-private/operations/update-relationship.d.ts

@@ -5,9 +5,5 @@ import type { UpdateRelationshipOperation } from "../../../types/graph.js";
 import type { ExistingResourceIdentifierObject, NewResourceIdentifierObject } from "../../../types/spec/json-api-raw.js";
 import type { Graph } from "../graph.js";
 type CacheKeyManager = Store["cacheKeyManager"];
-/*
-Updates the "canonical" or "remote" state of a relationship, replacing any existing
-state and blowing away any local changes (excepting new records).
-*/
 export default function updateRelationshipOperation(graph: Graph, op: UpdateRelationshipOperation | UpdateResourceRelationshipOperation): void;
 export declare function upgradeIdentifiers(arr: (ExistingResourceIdentifierObject | NewResourceIdentifierObject | ResourceKey)[], cache: CacheKeyManager): ResourceKey[];

package/declarations/reactive/-private/fields/managed-array.d.ts

@@ -13,7 +13,6 @@ export interface ManagedArray extends Omit<Array<unknown>, "[]"> {
 	[ARRAY_SIGNAL]: WarpDriveSignal;
 	[Context]: KindContext<SchemaArrayField | ArrayField>;
 }
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export declare class ManagedArray {
 	constructor(context: KindContext<SchemaArrayField | ArrayField>, owner: ReactiveResource, data: unknown[]);
 }

package/declarations/reactive/-private/fields/managed-object.d.ts

@@ -4,13 +4,11 @@ import type { KindContext } from "../default-mode.js";
 import type { ReactiveResource } from "../record.js";
 import { Context, SOURCE } from "../symbols.js";
 export declare function notifyObject(obj: ManagedObject): void;
-// const ignoredGlobalFields = new Set<string>(['setInterval', 'nodeType', 'nodeName', 'length', 'document', STRUCTURED]);
 export interface ManagedObject {
 	[SOURCE]: object;
 	[Context]: KindContext<ObjectField>;
 	[OBJECT_SIGNAL]: WarpDriveSignal;
 }
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export declare class ManagedObject {
 	constructor(context: KindContext<ObjectField>);
 }

package/declarations/reactive/-private/record.d.ts

@@ -32,7 +32,6 @@ export interface ReactiveResource {
 * @hideconstructor
 * @public
 */
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export declare class ReactiveResource {
 	constructor(context: ResourceContext | ObjectContext);
 }

package/declarations/reactive/-private/schema.d.ts

@@ -30,12 +30,10 @@ export interface CAUTION_MEGA_DANGER_ZONE_Extension {
 	* A constructable such as a Function or Class whose prototype
 	* will be iterated with getOwnPropertyNames.
 	*/
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 	features: Record<string | symbol, unknown> | Function;
 }
 export type ExtensionDef = {
 	kind: "method";
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 	fn: Function;
 } | {
 	kind: "readonly-value";

package/declarations/reactive/-private/symbols.d.ts

@@ -1,29 +1,3 @@
-// Great, got your attention with that warning didn't we?
-// Good. Here's the deal: typescript treats symbols as unique types.
-// If by accident a module creating a symbol is processed more than
-// once, the symbol will be different in each processing. This will
-// cause a type error.
-// It could also cause a runtime error if the symbol is used innapropriately.
-// However, this case is extremely hard to hit and would require other things
-// to go wrong first.
-//
-// So, why do the warning? And why do we lie about the types of the symbols?
-//
-// Because we intentionally create multiple copies of them within the types
-// at build time. This is because we rollup our d.ts files in order to give
-// our consumers a better experience.
-//
-// However, no tool today supports rolling up d.ts files with multiple entry
-// points correctly. The tool we use currently (vite-plugin-dts) uses @microsoft/api-extractor
-// which creates a fully unique stand-alone types file per-entry-point. Thus
-// every entry point that uses one of these symbols somewhere will have accidentally
-// created a new symbol type.
-//
-// This cast allows us to rollup these types using this tool while not encountering
-// the unique symbol type issue.
-//
-// Note that none of these symbols are part of the public API, these are used for
-// debugging DX and as a safe way to provide an intimate contract on public objects.
 export declare const SOURCE: "___(unique) Symbol(SOURCE)";
 export declare const Destroy: "___(unique) Symbol(Destroy)";
 export declare const Checkout: "___(unique) Symbol(Checkout)";

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

@@ -1,4 +1,3 @@
-/* eslint-disable no-irregular-whitespace */
 import type { Store } from "../../store/-private.js";
 import type { RequestKey } from "../../types/identifier.js";
 import type { RequestContext, RequestInfo, ResponseInfo, StructuredDataDocument } from "../../types/request.js";

package/declarations/store/-private/cache-handler/utils.d.ts

@@ -18,7 +18,6 @@ export type RobustError = Error & {
 	errors?: ApiError[];
 	content?: unknown;
 };
-// TODO @runspired, consider if we should deep freeze errors (potentially only in debug) vs cloning them
 export declare function cloneError(error: RobustError): RobustError;
 export declare function isErrorDocument(document: ResourceDataDocument | ResourceErrorDocument): document is ResourceErrorDocument;
 export declare function getPriority(identifier: RequestKey | null, deduped: Map<RequestKey, {

package/declarations/store/-private/caches/instance-cache.d.ts

@@ -53,7 +53,6 @@ export declare class InstanceCache {
 	disconnect(identifier: ResourceKey): void;
 	unloadRecord(identifier: ResourceKey): void;
 	clear(type?: string): void;
-	// TODO this should move into something coordinating operations
 	setRecordId(identifier: ResourceKey, id: string): void;
 }
 export declare function getNewRecord(instances: InstanceCache, identifier: ResourceKey, properties: CreateRecordProperties): OpaqueRecordInstance;

package/declarations/store/-private/default-cache-policy.d.ts

@@ -10,11 +10,9 @@ export interface NotificationCallback {
 	(resourceKey: ResourceKey, notificationType: "errors" | "meta" | "identity" | "state"): void;
 }
 interface ResourceOperationCallback {
-	// resource updates
 	(resourceKey: ResourceKey, notificationType: CacheOperation): void;
 }
 interface DocumentOperationCallback {
-	// document updates
 	(cacheKey: RequestKey, notificationType: DocumentCacheOperation): void;
 }
 type NotificationManager = {

package/declarations/store/-private/managers/cache-key-manager.d.ts

@@ -15,8 +15,6 @@ interface KeyOptions {
 type TypeMap = {
 	[key: string]: KeyOptions;
 };
-// type IdentifierTypeLookup = { all: Set<ResourceKey>; id: Map<string, ResourceKey> };
-// type IdentifiersByType = Map<string, IdentifierTypeLookup>;
 type IdentifierMap = Map<string, ResourceKey>;
 type StableCache = {
 	resources: IdentifierMap;
@@ -253,7 +251,6 @@ export declare class CacheKeyManager {
 	
 	@public
 	*/
-	// FIXME audit usage
 	updateRecordIdentifier(identifierObject: ResourceKey, data: unknown): ResourceKey;
 	/**
 	Provides the opportunity to eliminate an identifier from secondary lookup tables
@@ -265,7 +262,6 @@ export declare class CacheKeyManager {
 	
 	@public
 	*/
-	// FIXME audit usage
 	forgetRecordIdentifier(identifierObject: ResourceKey): void;
 }
 /**

package/declarations/store/-private/managers/cache-manager.d.ts

@@ -30,8 +30,6 @@ import type { StoreRequestContext } from "../cache-handler/handler.js";
 export declare class CacheManager implements Cache {
 	version: "2";
 	constructor(cache: Cache);
-	// Cache Management
-	// ================
 	/**
 	* Cache the response to a request
 	*
@@ -124,8 +122,6 @@ export declare class CacheManager implements Cache {
 	* @return if `hasRecord` is true then calculated key changes should be returned
 	*/
 	upsert(key: ResourceKey, data: unknown, hasRecord: boolean): void | string[];
-	// Cache Forking Support
-	// =====================
 	/**
 	* Create a fork of the cache from the current state.
 	*
@@ -182,8 +178,6 @@ export declare class CacheManager implements Cache {
 	* @public
 	*/
 	diff(): Promise<Change[]>;
-	// SSR Support
-	// ===========
 	/**
 	* Serialize the entire contents of the Cache into a Stream
 	* which may be fed back into a new instance of the same Cache
@@ -210,10 +204,6 @@ export declare class CacheManager implements Cache {
 	* @public
 	*/
 	hydrate(stream: ReadableStream<unknown>): Promise<void>;
-	// Cache
-	// =====
-	// Resource Support
-	// ================
 	/**
 	* [LIFECYCLE] Signal to the cache that a new record has been instantiated on the client
 	*
@@ -252,8 +242,6 @@ export declare class CacheManager implements Cache {
 	* @public
 	*/
 	unloadRecord(key: ResourceKey): void;
-	// Granular Resource Data APIs
-	// ===========================
 	/**
 	* Retrieve the data for an attribute from the cache
 	*
@@ -291,8 +279,6 @@ export declare class CacheManager implements Cache {
 	* @return the names of attributes that were restored
 	*/
 	rollbackAttrs(key: ResourceKey): string[];
-	// Relationships
-	// =============
 	/**
 	* Query the cache for the changes to relationships of a resource.
 	*
@@ -349,8 +335,6 @@ export declare class CacheManager implements Cache {
 	* @return resource relationship object
 	*/
 	getRemoteRelationship(key: ResourceKey, propertyName: string): ResourceRelationship | CollectionRelationship;
-	// Resource State
-	// ===============
 	/**
 	* Update the cache state for the given resource to be marked as locally deleted,
 	* or remove such a mark.

package/declarations/store/-private/managers/notification-manager.d.ts

@@ -10,11 +10,9 @@ export interface NotificationCallback {
 	(cacheKey: ResourceKey, notificationType: CacheOperation): void;
 }
 export interface ResourceOperationCallback {
-	// resource updates
 	(cacheKey: ResourceKey, notificationType: CacheOperation): void;
 }
 export interface DocumentOperationCallback {
-	// document updates
 	(cacheKey: RequestKey, notificationType: DocumentCacheOperation): void;
 }
 /**

package/declarations/store/-private/network/request-cache.d.ts

@@ -26,7 +26,6 @@ export interface RequestCacheRequestState {
 	response?: Response;
 }
 export interface Response {
-	// rawData: unknown;
 	data: unknown;
 }
 interface InternalRequest extends RequestCacheRequestState {

package/declarations/store/-private/new-core-tmp/request-state.d.ts

@@ -1,6 +1,5 @@
 import type { Future } from "../../../request.js";
 import type { ImmutableRequestInfo, ResponseInfo, StructuredErrorDocument } from "../../../types/request.js";
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 import type { PendingPromise, RejectedPromise, ResolvedPromise } from "./promise-state.js";
 /**
 * Lazily consumes the stream of a request, providing a number of

package/declarations/store/-private/new-core-tmp/request-subscription.d.ts

@@ -42,7 +42,6 @@ export interface RequestArgs<
 	*/
 	store?: Store | RequestManager;
 }
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 export interface SubscriptionArgs<
 	RT,
 	E
@@ -113,7 +112,6 @@ export interface RequestComponentArgs<
 	*/
 	store?: Store | RequestManager;
 }
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 export interface RequestSubscription<
 	RT,
 	E

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

@@ -10,17 +10,13 @@ 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);
@@ -28,7 +24,6 @@ interface ReactiveResourceArrayCreateOptions {
 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;
@@ -48,7 +43,6 @@ 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[];
@@ -58,11 +52,9 @@ export interface ReactiveRequestCollectionCreateArgs {
 }
 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[];

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

@@ -21,12 +21,10 @@ import type { PrivateRequestStateService } from "./network/request-cache.js";
 import { RequestStateService } from "./network/request-cache.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";
 type DSModelKeys = "___(unique) Symbol(Store)" | "___private_notifications" | "___recordState" | "_createSnapshot" | "adapterError" | "attr" | "belongsTo" | "changedAttributes" | "currentState" | "deleteRecord" | "destroyRecord" | "dirtyType" | "eachAttribute" | "eachRelationship" | "errors" | "hasDirtyAttributes" | "hasMany" | "inverseFor" | "isDeleted" | "isEmpty" | "isError" | "isLoaded" | "isLoading" | "isNew" | "isReloading" | "isSaving" | "isValid" | "relationshipFor" | "reload" | "rollbackAttributes" | "save" | "serialize" | "store" | "unloadRecord";
 type DownlevelArrays<T> = T extends Array<infer U> ? U[] : T;
 type AwaitedKeys<T> = { [K in keyof T & string] : DownlevelArrays<Awaited<T[K]>> };
-// `AwaitedKeys` is needed here to resolve any promise types like `PromiseBelongsTo`.
 type FilteredKeys<T> = AwaitedKeys<Omit<T, typeof Type | EmberObjectKey | DSModelKeys | "constructor">>;
 type MaybeHasId = {
 	id?: string | null;
@@ -51,9 +49,7 @@ export type CreateRecordProperties<T = MaybeHasId & Record<string, unknown>> = T
 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
 declare const EmptyClass: ConstructorFunction;
 declare const BaseClass: typeof EmptyClass;
 export interface Store {
@@ -81,7 +77,6 @@ export interface Store {
 	* @return A record instance
 	* @public
 	*/
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	instantiateRecord<T>(identifier: ResourceKey, createRecordArgs: {
 		[key: string]: unknown;
 	}): OpaqueRecordInstance;

package/declarations/store/-private/utils/coerce-id.d.ts

@@ -1,9 +1,3 @@
-// Used by the store to normalize IDs entering the store.  Despite the fact
-// that developers may provide IDs as numbers (e.g., `store.findRecord('person', 1)`),
-// it is important that internally we use strings, since IDs may be serialized
-// and lose type information.  For example, Ember's router may put a record's
-// ID into the URL, and if we later try to deserialize that URL and find the
-// corresponding record, we will not know if it is a string or a number.
 type Coercable = string | number | boolean | null | undefined | symbol;
 export declare function coerceId(id: unknown): string | null;
 export declare function ensureStringId(id: Coercable): string;

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

@@ -8,20 +8,15 @@ 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 { 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";
-// @ember-data/model needs these temporarily
 export { setRecordIdentifier, StoreMap } from "./-private/caches/instance-cache.js";
 export { normalizeModelName as _deprecatingNormalize } from "./-private/utils/normalize-model-name.js";
 export type { StoreRequestInput } from "./-private/cache-handler/handler.js";

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

@@ -210,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;