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

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

@@ -61,12 +61,12 @@ export interface RelationshipState {
 	in this case `state.hasFailedLoadAttempt` ought to be `true`.
 	
 	false when
-	=> cache.isNew(identifier) on initial setup
+	=> cache.isNew(resourceKey) on initial setup
 	=> a previously triggered request has resolved
 	=> we get relationship data via push
 	
 	true when
-	=> !cache.isNew(identifier) on initial setup
+	=> !cache.isNew(resourceKey) on initial setup
 	=> an inverse has been unloaded
 	=> we get a new link for the relationship
 	

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,17 @@ 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;
+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: StableRecordIdentifier, silenceNotifications?: boolean): 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/debug/assert-polymorphic-type.d.ts

@@ -1,5 +1,5 @@
 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
@@ -9,10 +9,10 @@ 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
+be ResourceKeys 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";
@@ -37,8 +38,9 @@ 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,13 +48,13 @@ 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;
+	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;
 	/*
 	* Allows for the graph to dynamically discover polymorphic connections
 	* without needing to walk prototype chains.
@@ -65,13 +67,13 @@ export declare class Graph {
 	* types as equivalent for a given relationship.
 	*/
 	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;
+	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;
 	/*
 	* Remote state changes
 	*/

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

@@ -1,4 +1,4 @@
-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";
 /*
@@ -57,6 +57,6 @@ artificial (implicit) inverses, replacing a value results in 2 discrete value tr
 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,13 @@
 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"];
+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 | 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 {};

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

@@ -1,12 +1,12 @@
 import type { Store } from "../../store/-private/store-service.js";
-import type { StableDocumentIdentifier } from "../../types/identifier.js";
+import type { RequestKey } from "../../types/identifier.js";
 import type { ImmutableRequestInfo, RequestInfo } from "../../types/request.js";
 import type { ResourceDocument } from "../../types/spec/document.js";
 import type { Meta, PaginationLinks } from "../../types/spec/json-api-raw.js";
 /**
 * A Document is a class that wraps the response content from a request to the API
-* returned by `Cache.put` or `Cache.peek`, converting resource-identifiers into
-* record instances.
+* returned by `Cache.put` or `Cache.peek`, converting ResourceKeys into
+* ReactiveResource instances.
 *
 * It is not directly instantiated by the user, and its properties should not
 * be directly modified. Whether individual properties are mutable or not is
@@ -28,8 +28,6 @@ export declare class ReactiveDocument<T> {
 	* }
 	* ```
 	*
-	* @property links
-	* @type {Object|undefined} - a links object
 	* @public
 	*/
 	readonly links?: PaginationLinks;
@@ -42,41 +40,33 @@ export declare class ReactiveDocument<T> {
 	* For collections this will be an array of record instances,
 	* for single resource requests it will be a single record instance or null.
 	*
-	* @property data
 	* @public
-	* @type {Object|Array<object>|null|undefined} - a data object
 	*/
 	readonly data?: T;
 	/**
 	* The errors returned by the API for this request, if any
 	*
-	* @property errors
 	* @public
-	* @type {Object|undefined} - an errors object
 	*/
 	readonly errors?: object[];
 	/**
 	* The meta object for this document, if any
 	*
-	* @property meta
 	* @public
-	* @type {Object|undefined} - a meta object
 	*/
 	readonly meta?: Meta;
 	/**
-	* The identifier associated with this document, if any
+	* The RequestKey associated with this document, if any
 	*
-	* @property identifier
 	* @public
-	* @type {StableDocumentIdentifier|null}
 	*/
-	readonly identifier: StableDocumentIdentifier | null;
+	readonly identifier: RequestKey | null;
 	protected readonly _store: Store;
 	protected readonly _localCache: {
 		document: ResourceDocument;
 		request: ImmutableRequestInfo;
 	} | null;
-	constructor(store: Store, identifier: StableDocumentIdentifier | null, localCache: {
+	constructor(store: Store, cacheKey: RequestKey | null, localCache: {
 		document: ResourceDocument;
 		request: ImmutableRequestInfo;
 	} | null);
@@ -89,7 +79,7 @@ export declare class ReactiveDocument<T> {
 	* @param {Object} options
 	* @return {Promise<Document>}
 	*/
-	fetch(options?: RequestInfo<ReactiveDocument<T>, T>): Promise<ReactiveDocument<T>>;
+	fetch(options?: RequestInfo<ReactiveDocument<T>>): Promise<ReactiveDocument<T>>;
 	/**
 	* Fetches the next link for this document, returning a promise that resolves
 	* with the new document when the request completes, or null  if there is no
@@ -99,7 +89,7 @@ export declare class ReactiveDocument<T> {
 	* @param {Object} options
 	* @return {Promise<Document | null>}
 	*/
-	next(options?: RequestInfo<ReactiveDocument<T>, T>): Promise<ReactiveDocument<T> | null>;
+	next(options?: RequestInfo<ReactiveDocument<T>>): Promise<ReactiveDocument<T> | null>;
 	/**
 	* Fetches the prev link for this document, returning a promise that resolves
 	* with the new document when the request completes, or null if there is no
@@ -109,7 +99,7 @@ export declare class ReactiveDocument<T> {
 	* @param {Object} options
 	* @return {Promise<Document | null>}
 	*/
-	prev(options: RequestInfo<ReactiveDocument<T>, T>): Promise<ReactiveDocument<T> | null>;
+	prev(options: RequestInfo<ReactiveDocument<T>>): Promise<ReactiveDocument<T> | null>;
 	/**
 	* Fetches the first link for this document, returning a promise that resolves
 	* with the new document when the request completes, or null if there is no
@@ -119,7 +109,7 @@ export declare class ReactiveDocument<T> {
 	* @param {Object} options
 	* @return {Promise<Document | null>}
 	*/
-	first(options: RequestInfo<ReactiveDocument<T>, T>): Promise<ReactiveDocument<T> | null>;
+	first(options: RequestInfo<ReactiveDocument<T>>): Promise<ReactiveDocument<T> | null>;
 	/**
 	* Fetches the last link for this document, returning a promise that resolves
 	* with the new document when the request completes, or null if there is no
@@ -129,7 +119,7 @@ export declare class ReactiveDocument<T> {
 	* @param {Object} options
 	* @return {Promise<Document | null>}
 	*/
-	last(options: RequestInfo<ReactiveDocument<T>, T>): Promise<ReactiveDocument<T> | null>;
+	last(options: RequestInfo<ReactiveDocument<T>>): Promise<ReactiveDocument<T> | null>;
 	/**
 	* Implemented for `JSON.stringify` support.
 	*

package/declarations/reactive/-private/fields/get-field-key.d.ts

@@ -0,0 +1,8 @@
+import type { CacheableFieldSchema, FieldSchema, HashField, IdentityField } from "../../../types/schema/fields.js";
+type InvalidKind = "alias" | "derived" | "@local";
+export declare function isInvalidKind(kind: string): kind is InvalidKind;
+export declare function isNonIdentityCacheableField(field: FieldSchema | IdentityField | HashField): field is Exclude<CacheableFieldSchema, IdentityField>;
+export declare function getFieldCacheKeyStrict(field: CacheableFieldSchema): string;
+export declare function getFieldCacheKey(field: FieldSchema | IdentityField | HashField): string | null;
+export declare function assertIsCacheField(field: FieldSchema | IdentityField): asserts field is CacheableFieldSchema;
+export {};

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

@@ -1,22 +1,19 @@
-import type { Store } from "../../../index.js";
 import type { WarpDriveSignal } from "../../../store/-private.js";
 import { ARRAY_SIGNAL } from "../../../store/-private.js";
-import type { Cache } from "../../../types/cache.js";
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ResourceKey } from "../../../types/identifier.js";
 import type { ArrayField, SchemaArrayField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
 import { ReactiveResource } from "../record.js";
-import type { SchemaService } from "../schema.js";
-import { Editable, Legacy, SOURCE } from "../symbols.js";
+import { Context, SOURCE } from "../symbols.js";
 export interface ManagedArray extends Omit<Array<unknown>, "[]"> {
 	[SOURCE]: unknown[];
-	identifier: StableRecordIdentifier;
-	path: string[];
+	identifier: ResourceKey;
+	path: string | string[];
 	owner: ReactiveResource;
 	[ARRAY_SIGNAL]: WarpDriveSignal;
-	[Editable]: boolean;
-	[Legacy]: boolean;
+	[Context]: KindContext<SchemaArrayField | ArrayField>;
 }
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export declare class ManagedArray {
-	constructor(store: Store, schema: SchemaService, cache: Cache, field: ArrayField | SchemaArrayField, data: unknown[], identifier: StableRecordIdentifier, path: string[], owner: ReactiveResource, isSchemaArray: boolean, editable: boolean, legacy: boolean);
+	constructor(context: KindContext<SchemaArrayField | ArrayField>, owner: ReactiveResource, data: unknown[]);
 }

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

@@ -1,21 +1,19 @@
 import { OBJECT_SIGNAL, type WarpDriveSignal } from "../../../store/-private.js";
-import type { Cache } from "../../../types/cache.js";
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
 import type { ObjectField, SchemaObjectField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
 import type { ReactiveResource } from "../record.js";
-import type { SchemaService } from "../schema.js";
-import { Editable, EmbeddedPath, Legacy, Parent, SOURCE } from "../symbols.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;
-	[Parent]: StableRecordIdentifier;
-	[EmbeddedPath]: string[];
+	[Context]: KindContext<ObjectField>;
 	[OBJECT_SIGNAL]: WarpDriveSignal;
-	[Editable]: boolean;
-	[Legacy]: boolean;
 }
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export declare class ManagedObject {
-	constructor(schema: SchemaService, cache: Cache, field: ObjectField | SchemaObjectField, data: object, identifier: StableRecordIdentifier, path: string[], owner: ReactiveResource, editable: boolean, legacy: boolean);
+	constructor(context: KindContext<ObjectField>);
 }
+export declare const ManagedObjectMap: Map<ReactiveResource, Map<string, ManagedObject | ReactiveResource>>;
+export declare function peekManagedObject(record: ReactiveResource, field: ObjectField): ManagedObject | undefined;
+export declare function peekManagedObject(record: ReactiveResource, field: SchemaObjectField): ReactiveResource | undefined;

package/declarations/reactive/-private/fields/many-array-manager.d.ts

@@ -1,7 +1,7 @@
 import type { Store } from "../../../index.js";
 import type { RelatedCollection as ManyArray } from "../../../store/-private.js";
 import type { LocalRelationshipOperation } from "../../../types/graph.js";
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ResourceKey } from "../../../types/identifier.js";
 import type { ReactiveResource } from "../record.js";
 export interface FindHasManyOptions {
 	reload?: boolean;
@@ -10,7 +10,7 @@ export interface FindHasManyOptions {
 export declare class ManyArrayManager {
 	record: ReactiveResource;
 	store: Store;
-	identifier: StableRecordIdentifier;
+	identifier: ResourceKey;
 	editable: boolean;
 	constructor(record: ReactiveResource, editable: boolean);
 	_syncArray(array: ManyArray): void;