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

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

@@ -1,4 +1,4 @@
-import type { StableRecordIdentifier } from "../../types/identifier.js";
+import type { ResourceKey } from "../../types/identifier.js";
 import type { CollectionEdge } from "./edges/collection.js";
 import type { ResourceEdge } from "./edges/resource.js";
 import type { Graph } from "./graph.js";
@@ -10,23 +10,10 @@ type Diff<T> = {
 	changed: boolean;
 	remoteOrderChanged: boolean;
 };
-export declare function diffCollection(finalState: StableRecordIdentifier[], relationship: CollectionEdge, onAdd: (v: StableRecordIdentifier) => void, onDel: (v: StableRecordIdentifier) => void): Diff<StableRecordIdentifier>;
-export declare function computeLocalState(storage: CollectionEdge): StableRecordIdentifier[];
-/**
-* A function which attempts to add a value to the local state of a collection
-* relationship, and returns true if the value was added, or false if it was
-* already present.
-*
-* It will not generate a notification, will not update the relationships to dirty,
-* and will not update the inverse relationships, making it suitable for use as
-* an internal util to perform the just the addition to a specific side of a
-* relationship.
-*
-* @internal
-*/
-export declare function _add(graph: Graph, record: StableRecordIdentifier, relationship: CollectionEdge, value: StableRecordIdentifier, index: number | null, isRemote: boolean): boolean;
-export declare function _remove(graph: Graph, record: StableRecordIdentifier, relationship: CollectionEdge, value: StableRecordIdentifier, index: number | null, isRemote: boolean): boolean;
-export declare function _removeLocal(relationship: CollectionEdge, value: StableRecordIdentifier): boolean;
-export declare function _removeRemote(relationship: CollectionEdge, value: StableRecordIdentifier): boolean;
-export declare function rollbackRelationship(graph: Graph, identifier: StableRecordIdentifier, field: string, relationship: CollectionEdge | ResourceEdge): void;
+export declare function diffCollection(finalState: ResourceKey[], relationship: CollectionEdge, onAdd: (v: ResourceKey) => void, onDel: (v: ResourceKey) => void): Diff<ResourceKey>;
+export declare function computeLocalState(storage: CollectionEdge): ResourceKey[];
+export declare function _remove(graph: Graph, record: ResourceKey, relationship: CollectionEdge, value: ResourceKey, index: number | null, isRemote: boolean): boolean;
+export declare function _removeLocal(relationship: CollectionEdge, value: ResourceKey): boolean;
+export declare function _removeRemote(relationship: CollectionEdge, value: ResourceKey): boolean;
+export declare function rollbackRelationship(graph: Graph, key: ResourceKey, field: string, relationship: CollectionEdge | ResourceEdge): void;
 export {};

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

@@ -1,4 +1,4 @@
-import type { StableRecordIdentifier } from "../../types.js";
+import type { ResourceKey } from "../../types.js";
 import type { CollectionField, FieldSchema, LegacyBelongsToField, LegacyHasManyField, ResourceField } from "../../types/schema/fields.js";
 import type { Graph } from "./graph.js";
 export type EdgeCache = Record<string, Record<string, EdgeDefinition | null>>;
@@ -70,22 +70,17 @@ export declare function temporaryConvertToLegacy(field: ResourceField | Collecti
 * }
 * ```
 *
-*
-* @class UpgradedMeta
-* @internal
+* @private
 */
 export interface UpgradedMeta {
 	kind: "implicit" | RelationshipFieldKind;
 	/**
 	* The field name on `this` record
-	*
-	* @internal
 	*/
 	key: string;
 	/**
 	* The `type` of the related record
 	*
-	* @internal
 	*/
 	type: string;
 	isAsync: boolean;
@@ -97,12 +92,10 @@ export interface UpgradedMeta {
 	inverseKind: "implicit" | RelationshipFieldKind;
 	/**
 	* The field name on the opposing record
-	* @internal
 	*/
 	inverseKey: string;
 	/**
 	* The `type` of `this` record
-	* @internal
 	*/
 	inverseType: string;
 	inverseIsAsync: boolean;
@@ -131,7 +124,6 @@ export interface EdgeDefinition {
 	* If the relationship is polymorphic, this will be true if
 	* it points back at the same abstract type.
 	*
-	* @internal
 	*/
 	isSelfReferential: boolean;
 	/**
@@ -139,10 +131,9 @@ export interface EdgeDefinition {
 	* if the relationship also points back at the same
 	* field.
 	*
-	* @internal
 	*/
 	isReflexive: boolean;
 }
 export declare function isLHS(info: EdgeDefinition, type: string, key: string): boolean;
 export declare function isRHS(info: EdgeDefinition, type: string, key: string): boolean;
-export declare function upgradeDefinition(graph: Graph, identifier: StableRecordIdentifier, propertyName: string, isImplicit?: boolean): EdgeDefinition | null;
+export declare function upgradeDefinition(graph: Graph, key: ResourceKey, propertyName: string, isImplicit?: boolean): EdgeDefinition | null;

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(identifier) on initial setup
-	=> a previously triggered request has resolved
-	=> we get relationship data via push
-	
-	true when
-	=> !cache.isNew(identifier) 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

@@ -2,7 +2,7 @@ import type { Store } from "../../store/-private.js";
 import type { CacheCapabilitiesManager } from "../../types.js";
 import type { UpdateResourceRelationshipOperation } from "../../types/cache/operations.js";
 import type { UpdateRelationshipOperation } from "../../types/graph.js";
-import type { StableRecordIdentifier } from "../../types/identifier.js";
+import type { ResourceKey } from "../../types/identifier.js";
 import type { ResourceIdentifierObject } from "../../types/spec/json-api-raw.js";
 import type { UpgradedMeta } from "./-edge-definition.js";
 import type { CollectionEdge } from "./edges/collection.js";
@@ -15,17 +15,11 @@ export declare function getStore(wrapper: CacheCapabilitiesManager | {
 export declare function expandingGet<T>(cache: Record<string, Record<string, T>>, key1: string, key2: string): T | undefined;
 export declare function expandingSet<T>(cache: Record<string, Record<string, T>>, key1: string, key2: string, value: T): void;
 export declare function assertValidRelationshipPayload(graph: Graph, op: UpdateRelationshipOperation | UpdateResourceRelationshipOperation): void;
-export declare function isNew(identifier: StableRecordIdentifier): boolean;
+export declare function checkIfNew(store: Store, resourceKey: ResourceKey): boolean;
 export declare function isBelongsTo(relationship: GraphEdge): relationship is ResourceEdge;
 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: (identifier: StableRecordIdentifier) => 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: StableRecordIdentifier, silenceNotifications?: boolean): void;
+export declare function forAllRelatedIdentifiers(rel: GraphEdge, cb: (resourceKey: ResourceKey) => void): void;
+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, identifier: StableRecordIdentifier, data: ResourceIdentifierObject, meta: UpgradedMeta): 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 { StableRecordIdentifier } from "../../../types/identifier.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 stable record identifiers and the `relationshipMeta` needs to be the meta
-information about the relationship, retrieved via
-`record.relationshipFor(key)`.
-*/
-declare let assertPolymorphicType: (parentIdentifier: StableRecordIdentifier, parentDefinition: UpgradedMeta, addedIdentifier: StableRecordIdentifier, store: CacheCapabilitiesManager) => void;
+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/edges/collection.d.ts

@@ -1,19 +1,19 @@
 import type { CollectionRelationship } from "../../../types/cache/relationship.js";
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ResourceKey } from "../../../types/identifier.js";
 import type { Links, Meta, PaginationLinks } from "../../../types/spec/json-api-raw.js";
 import type { UpgradedMeta } from "../-edge-definition.js";
 import type { RelationshipState } from "../-state.js";
 export interface CollectionEdge {
 	definition: UpgradedMeta;
-	identifier: StableRecordIdentifier;
+	identifier: ResourceKey;
 	state: RelationshipState;
-	remoteMembers: Set<StableRecordIdentifier>;
-	remoteState: StableRecordIdentifier[];
-	additions: Set<StableRecordIdentifier> | null;
-	removals: Set<StableRecordIdentifier> | null;
+	remoteMembers: Set<ResourceKey>;
+	remoteState: ResourceKey[];
+	additions: Set<ResourceKey> | null;
+	removals: Set<ResourceKey> | null;
 	meta: Meta | null;
 	links: Links | PaginationLinks | null;
-	localState: StableRecordIdentifier[] | null;
+	localState: ResourceKey[] | null;
 	/**
 	* Whether the localState for this edge is out-of-sync
 	* with the remoteState.
@@ -31,9 +31,9 @@ export interface CollectionEdge {
 	*/
 	accessed: boolean;
 	_diff?: {
-		add: Set<StableRecordIdentifier>;
-		del: Set<StableRecordIdentifier>;
+		add: Set<ResourceKey>;
+		del: Set<ResourceKey>;
 	};
 }
-export declare function createCollectionEdge(definition: UpgradedMeta, identifier: StableRecordIdentifier): CollectionEdge;
+export declare function createCollectionEdge(definition: UpgradedMeta, identifier: ResourceKey): CollectionEdge;
 export declare function legacyGetCollectionRelationshipData(source: CollectionEdge, getRemoteState: boolean): CollectionRelationship;

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

@@ -1,4 +1,4 @@
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ResourceKey } from "../../../types/identifier.js";
 import type { UpgradedMeta } from "../-edge-definition.js";
 export type ImplicitMeta = UpgradedMeta & {
 	kind: "implicit";
@@ -36,8 +36,8 @@ to be do things like remove the comment from the post if the comment were to be
 */
 export interface ImplicitEdge {
 	definition: ImplicitMeta;
-	identifier: StableRecordIdentifier;
-	localMembers: Set<StableRecordIdentifier>;
-	remoteMembers: Set<StableRecordIdentifier>;
+	identifier: ResourceKey;
+	localMembers: Set<ResourceKey>;
+	remoteMembers: Set<ResourceKey>;
 }
-export declare function createImplicitEdge(definition: ImplicitMeta, identifier: StableRecordIdentifier): ImplicitEdge;
+export declare function createImplicitEdge(definition: ImplicitMeta, identifier: ResourceKey): ImplicitEdge;

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

@@ -1,24 +1,23 @@
 import type { ResourceRelationship } from "../../../types/cache/relationship.js";
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ResourceKey } from "../../../types/identifier.js";
 import type { Links, Meta, PaginationLinks } from "../../../types/spec/json-api-raw.js";
 import type { UpgradedMeta } from "../-edge-definition.js";
 import type { RelationshipState } from "../-state.js";
 /**
 * Stores the data for one side of a "single" resource relationship.
 *
-* @class ResourceEdge
-* @internal
+* @private
 */
 export interface ResourceEdge {
 	definition: UpgradedMeta;
-	identifier: StableRecordIdentifier;
+	identifier: ResourceKey;
 	state: RelationshipState;
-	localState: StableRecordIdentifier | null;
-	remoteState: StableRecordIdentifier | null;
+	localState: ResourceKey | null;
+	remoteState: ResourceKey | null;
 	meta: Meta | null;
 	links: Links | PaginationLinks | null;
 	transactionRef: number;
 	accessed: boolean;
 }
-export declare function createResourceEdge(definition: UpgradedMeta, identifier: StableRecordIdentifier): ResourceEdge;
+export declare function createResourceEdge(definition: UpgradedMeta, identifier: ResourceKey): ResourceEdge;
 export declare function legacyGetResourceRelationshipData(source: ResourceEdge, getRemoteState: boolean): ResourceRelationship;

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

@@ -1,4 +1,5 @@
-import type { CacheCapabilitiesManager, StableRecordIdentifier } from "../../types.js";
+import type { Store } from "../../store/-private.js";
+import type { CacheCapabilitiesManager, ResourceKey } from "../../types.js";
 import type { RelationshipDiff } from "../../types/cache.js";
 import type { MergeOperation } from "../../types/cache/operations.js";
 import type { CollectionRelationship, ResourceRelationship } from "../../types/cache/relationship.js";
@@ -14,31 +15,13 @@ 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>>;
 	_potentialPolymorphicTypes: Record<string, Record<string, boolean>>;
-	identifiers: Map<StableRecordIdentifier, Record<string, GraphEdge>>;
+	identifiers: Map<ResourceKey, Record<string, GraphEdge>>;
 	store: CacheCapabilitiesManager;
+	_realStore: Store;
 	isDestroyed: boolean;
 	_willSyncRemote: boolean;
 	_willSyncLocal: boolean;
@@ -46,39 +29,22 @@ export declare class Graph {
 	_pushedUpdates: PendingOps;
 	_updatedRelationships: Set<CollectionEdge>;
 	_transaction: number | null;
-	_removing: StableRecordIdentifier | null;
+	_removing: ResourceKey | null;
 	constructor(store: CacheCapabilitiesManager);
-	has(identifier: StableRecordIdentifier, propertyName: string): boolean;
-	getDefinition(identifier: StableRecordIdentifier, propertyName: string): UpgradedMeta;
-	get(identifier: StableRecordIdentifier, propertyName: string): GraphEdge;
-	getData(identifier: StableRecordIdentifier, propertyName: string): ResourceRelationship | CollectionRelationship;
-	getRemoteData(identifier: StableRecordIdentifier, 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.
-	*/
+	has(resourceKey: ResourceKey, propertyName: string): boolean;
+	getDefinition(resourceKey: ResourceKey, propertyName: string): UpgradedMeta;
+	get(resourceKey: ResourceKey, propertyName: string): GraphEdge;
+	getData(resourceKey: ResourceKey, propertyName: string): ResourceRelationship | CollectionRelationship;
+	getRemoteData(resourceKey: ResourceKey, propertyName: string): ResourceRelationship | CollectionRelationship;
 	registerPolymorphicType(type1: string, type2: string): void;
-	isReleasable(identifier: StableRecordIdentifier): boolean;
-	unload(identifier: StableRecordIdentifier, silenceNotifications?: boolean): void;
-	_isDirty(identifier: StableRecordIdentifier, field: string): boolean;
-	getChanged(identifier: StableRecordIdentifier): Map<string, RelationshipDiff>;
-	hasChanged(identifier: StableRecordIdentifier): boolean;
-	rollback(identifier: StableRecordIdentifier): string[];
-	remove(identifier: StableRecordIdentifier): void;
-	/*
-	* Remote state changes
-	*/
+	isReleasable(resourceKey: ResourceKey): boolean;
+	unload(resourceKey: ResourceKey, silenceNotifications?: boolean): void;
+	_isDirty(resourceKey: ResourceKey, field: string): boolean;
+	getChanged(resourceKey: ResourceKey): Map<string, RelationshipDiff>;
+	hasChanged(resourceKey: ResourceKey): boolean;
+	rollback(resourceKey: ResourceKey): string[];
+	remove(resourceKey: ResourceKey): void;
 	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,62 +1,7 @@
-import type { StableRecordIdentifier } from "../../../types.js";
+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, identifier: StableRecordIdentifier, key: string, value: StableRecordIdentifier, isRemote: boolean): void;
-export declare function notifyInverseOfPotentialMaterialization(graph: Graph, identifier: StableRecordIdentifier, key: string, value: StableRecordIdentifier, isRemote: boolean): void;
-export declare function removeFromInverse(graph: Graph, identifier: StableRecordIdentifier, key: string, value: StableRecordIdentifier, 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;
+export declare function removeFromInverse(graph: Graph, resourceKey: ResourceKey, key: string, value: ResourceKey, isRemote: boolean): void;

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

@@ -1,13 +1,9 @@
 import type { Store } from "../../../index.js";
-import type { StableRecordIdentifier } from "../../../types.js";
+import type { ResourceKey } from "../../../types.js";
 import type { UpdateResourceRelationshipOperation } from "../../../types/cache/operations.js";
 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 IdentifierCache = Store["identifierCache"];
-/*
-Updates the "canonical" or "remote" state of a relationship, replacing any existing
-state and blowing away any local changes (excepting new records).
-*/
+type CacheKeyManager = Store["cacheKeyManager"];
 export default function updateRelationshipOperation(graph: Graph, op: UpdateRelationshipOperation | UpdateResourceRelationshipOperation): void;
-export declare function upgradeIdentifiers(arr: (ExistingResourceIdentifierObject | NewResourceIdentifierObject | StableRecordIdentifier)[], cache: IdentifierCache): StableRecordIdentifier[];
+export declare function upgradeIdentifiers(arr: (ExistingResourceIdentifierObject | NewResourceIdentifierObject | ResourceKey)[], cache: CacheKeyManager): ResourceKey[];

package/declarations/index.d.ts

@@ -11,4 +11,4 @@ export { Store, type StoreRequestContext, CacheHandler, type CachePolicy, type S
 */
 export type Document<T> = ReactiveDocument<T>;
 export type { DocumentCacheOperation, CacheOperation, NotificationType } from "./store/-private/managers/notification-manager.js";
-export { setIdentifierGenerationMethod, setIdentifierUpdateMethod, setIdentifierForgetMethod, setIdentifierResetMethod, setKeyInfoForResource } from "./store/-private/caches/identifier-cache.js";
+export { setIdentifierGenerationMethod, setIdentifierUpdateMethod, setIdentifierForgetMethod, setIdentifierResetMethod, setKeyInfoForResource } from "./store/-private/managers/cache-key-manager.js";

package/declarations/reactive/-private/default-mode.d.ts

@@ -0,0 +1,73 @@
+import type { Store } from "../../store/-private.js";
+import type { SignalStore } from "../../store/-private/new-core-tmp/reactivity/internal.js";
+import type { ResourceKey } from "../../types.js";
+import type { FieldSchema, HashField, IdentityField, SchemaArrayField, SchemaObjectField } from "../../types/schema/fields.js";
+import type { ReactiveResource } from "./record.js";
+export type PathLike = string | symbol | Array<string | symbol>;
+export type ModeName = "polaris" | "legacy";
+export interface ModeInfo {
+	name: ModeName;
+	legacy: boolean;
+	editable: boolean;
+}
+export interface BaseContext {
+	store: Store;
+	resourceKey: ResourceKey;
+	modeName: ModeName;
+	legacy: boolean;
+	editable: boolean;
+}
+export interface ResourceContext extends BaseContext {
+	path: null;
+	field: null;
+	value: null;
+}
+export interface ObjectContext extends BaseContext {
+	path: string[];
+	field: SchemaObjectField | SchemaArrayField;
+	value: string;
+}
+export interface KindContext<T extends FieldSchema | IdentityField | HashField> extends BaseContext {
+	path: string[];
+	field: T;
+	value: unknown;
+	record: ReactiveResource;
+	signals: SignalStore;
+}
+export interface KindImpl<T extends FieldSchema | IdentityField | HashField> {
+	/**
+	* A function which produces the value for the field when invoked.
+	*/
+	get: (context: KindContext<T>) => unknown;
+	/**
+	* A function which updates the value for the field when invoked.
+	*
+	* This will never be invoked when the record is in a non-editable mode.
+	*
+	* This should assert in dev and return false if mutation is not allowed.
+	*/
+	set: (context: KindContext<T>) => boolean;
+	/**
+	* Whether this field is ever mutable (writable). This should be
+	* if there is ever a scenario in which the field can be written
+	* and false only if the field can never be written to.
+	*/
+	mutable: boolean;
+	/**
+	* Whether this field's of this kind should be included in the
+	* enumerated (iterable) keys of the record/object instance.
+	*
+	* This should generally be true except for fields that are not
+	* producing a value backed by the cache. For instance, locals
+	* should not be enumerable, as their value is not tied to the
+	* cache at all.
+	*/
+	enumerable: boolean;
+	/**
+	*
+	*/
+	serializable: boolean;
+}
+type Mode = { [Field in FieldSchema | IdentityField | HashField as Field["kind"]] : KindImpl<Field> };
+export declare const DefaultMode: Mode;
+export {};