@warp-drive/core 5.6.0-alpha.15 → 5.6.0-alpha.17

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

@@ -1,40 +1,39 @@
-import type { CollectionRelationship } from '../../../types/cache/relationship.ts';
-import type { StableRecordIdentifier } from '../../../types/identifier.ts';
-import type { Links, Meta, PaginationLinks } from '../../../types/spec/json-api-raw.ts';
-import type { UpgradedMeta } from '../-edge-definition.ts';
-import type { RelationshipState } from '../-state.ts';
+import type { CollectionRelationship } from "../../../types/cache/relationship.js";
+import type { StableRecordIdentifier } 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;
-    state: RelationshipState;
-    remoteMembers: Set<StableRecordIdentifier>;
-    remoteState: StableRecordIdentifier[];
-    additions: Set<StableRecordIdentifier> | null;
-    removals: Set<StableRecordIdentifier> | null;
-    meta: Meta | null;
-    links: Links | PaginationLinks | null;
-    localState: StableRecordIdentifier[] | null;
-    /**
-     * Whether the localState for this edge is out-of-sync
-     * with the remoteState.
-     *
-     * if state.hasReceivedData=false we are also
-     * not dirty since there is nothing to sync with.
-     *
-     */
-    isDirty: boolean;
-    transactionRef: number;
-    /**
-     * Whether data for this edge has been accessed at least once
-     * via `graph.getData`
-     *
-     */
-    accessed: boolean;
-    _diff?: {
-        add: Set<StableRecordIdentifier>;
-        del: Set<StableRecordIdentifier>;
-    };
+	definition: UpgradedMeta;
+	identifier: StableRecordIdentifier;
+	state: RelationshipState;
+	remoteMembers: Set<StableRecordIdentifier>;
+	remoteState: StableRecordIdentifier[];
+	additions: Set<StableRecordIdentifier> | null;
+	removals: Set<StableRecordIdentifier> | null;
+	meta: Meta | null;
+	links: Links | PaginationLinks | null;
+	localState: StableRecordIdentifier[] | null;
+	/**
+	* Whether the localState for this edge is out-of-sync
+	* with the remoteState.
+	*
+	* if state.hasReceivedData=false we are also
+	* not dirty since there is nothing to sync with.
+	*
+	*/
+	isDirty: boolean;
+	transactionRef: number;
+	/**
+	* Whether data for this edge has been accessed at least once
+	* via `graph.getData`
+	*
+	*/
+	accessed: boolean;
+	_diff?: {
+		add: Set<StableRecordIdentifier>;
+		del: Set<StableRecordIdentifier>;
+	};
 }
 export declare function createCollectionEdge(definition: UpgradedMeta, identifier: StableRecordIdentifier): CollectionEdge;
 export declare function legacyGetCollectionRelationshipData(source: CollectionEdge, getRemoteState: boolean): CollectionRelationship;
-//# sourceMappingURL=collection.d.ts.map

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

@@ -1,44 +1,43 @@
-import type { StableRecordIdentifier } from '../../../types/identifier.ts';
-import type { UpgradedMeta } from '../-edge-definition.ts';
+import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { UpgradedMeta } from "../-edge-definition.js";
 export type ImplicitMeta = UpgradedMeta & {
-    kind: 'implicit';
-    isImplicit: true;
+	kind: "implicit";
+	isImplicit: true;
 };
 /**
-   Implicit relationships are relationships which have not been declared but the inverse side exists on
-   another record somewhere
+Implicit relationships are relationships which have not been declared but the inverse side exists on
+another record somewhere
 
-   For example consider the following two models
+For example consider the following two models
 
-   ::: code-group
+::: code-group
 
-   ```js [./models/comment.js]
-   import { Model, attr } from '@warp-drive/legacy/model';
+```js [./models/comment.js]
+import { Model, attr } from '@warp-drive/legacy/model';
 
-   export default class Comment extends Model {
-     @attr text;
-   }
-   ```
+export default class Comment extends Model {
+@attr text;
+}
+```
 
-   ```js [./models/post.js]
-    import { Model, attr, hasMany } from '@warp-drive/legacy/model';
+```js [./models/post.js]
+import { Model, attr, hasMany } from '@warp-drive/legacy/model';
 
-   export default class Post extends Model {
-     @attr title;
-     @hasMany('comment', { async: true, inverse: null }) comments;
-   }
-   ```
+export default class Post extends Model {
+@attr title;
+@hasMany('comment', { async: true, inverse: null }) comments;
+}
+```
 
-   :::
+:::
 
-   Then we would have a implicit 'post' relationship for the comment record in order
-   to be do things like remove the comment from the post if the comment were to be deleted.
+Then we would have a implicit 'post' relationship for the comment record in order
+to be do things like remove the comment from the post if the comment were to be deleted.
 */
 export interface ImplicitEdge {
-    definition: ImplicitMeta;
-    identifier: StableRecordIdentifier;
-    localMembers: Set<StableRecordIdentifier>;
-    remoteMembers: Set<StableRecordIdentifier>;
+	definition: ImplicitMeta;
+	identifier: StableRecordIdentifier;
+	localMembers: Set<StableRecordIdentifier>;
+	remoteMembers: Set<StableRecordIdentifier>;
 }
 export declare function createImplicitEdge(definition: ImplicitMeta, identifier: StableRecordIdentifier): ImplicitEdge;
-//# sourceMappingURL=implicit.d.ts.map

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

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

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

@@ -1,55 +1,90 @@
-import type { CacheCapabilitiesManager, StableRecordIdentifier } from '../../types.ts';
-import type { RelationshipDiff } from '../../types/cache.ts';
-import type { MergeOperation } from '../../types/cache/operations.ts';
-import type { CollectionRelationship, ResourceRelationship } from '../../types/cache/relationship.ts';
-import type { DeleteRecordOperation, LocalRelationshipOperation, RemoteRelationshipOperation } from '../../types/graph.ts';
-import type { EdgeCache, UpgradedMeta } from './-edge-definition.ts';
-import { type CollectionEdge } from './edges/collection.ts';
-import type { ImplicitEdge } from './edges/implicit.ts';
-import { type ResourceEdge } from './edges/resource.ts';
+import type { CacheCapabilitiesManager, StableRecordIdentifier } 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";
+import type { DeleteRecordOperation, LocalRelationshipOperation, RemoteRelationshipOperation } from "../../types/graph.js";
+import type { EdgeCache, UpgradedMeta } from "./-edge-definition.js";
+import { type CollectionEdge } from "./edges/collection.js";
+import type { ImplicitEdge } from "./edges/implicit.js";
+import { type ResourceEdge } from "./edges/resource.js";
 export type GraphEdge = ImplicitEdge | CollectionEdge | ResourceEdge;
 export declare const Graphs: Map<CacheCapabilitiesManager, Graph>;
 type PendingOps = {
-    belongsTo?: Map<string, Map<string, RemoteRelationshipOperation[]>>;
-    hasMany?: Map<string, Map<string, RemoteRelationshipOperation[]>>;
-    deletions: DeleteRecordOperation[];
+	belongsTo?: Map<string, Map<string, RemoteRelationshipOperation[]>>;
+	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>>;
-    store: CacheCapabilitiesManager;
-    isDestroyed: boolean;
-    _willSyncRemote: boolean;
-    _willSyncLocal: boolean;
-    silenceNotifications: boolean;
-    _pushedUpdates: PendingOps;
-    _updatedRelationships: Set<CollectionEdge>;
-    _transaction: number | null;
-    _removing: StableRecordIdentifier | 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;
-    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;
-    push(op: RemoteRelationshipOperation): void;
-    update(op: RemoteRelationshipOperation | MergeOperation, isRemote: true): void;
-    update(op: LocalRelationshipOperation, isRemote?: false): void;
-    _scheduleLocalSync(relationship: CollectionEdge): void;
-    _flushRemoteQueue(): void;
-    _addToTransaction(relationship: CollectionEdge | ResourceEdge): void;
-    _flushLocalQueue(): void;
-    destroy(): void;
+	_definitionCache: EdgeCache;
+	_metaCache: Record<string, Record<string, UpgradedMeta>>;
+	_potentialPolymorphicTypes: Record<string, Record<string, boolean>>;
+	identifiers: Map<StableRecordIdentifier, Record<string, GraphEdge>>;
+	store: CacheCapabilitiesManager;
+	isDestroyed: boolean;
+	_willSyncRemote: boolean;
+	_willSyncLocal: boolean;
+	silenceNotifications: boolean;
+	_pushedUpdates: PendingOps;
+	_updatedRelationships: Set<CollectionEdge>;
+	_transaction: number | null;
+	_removing: StableRecordIdentifier | 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.
+	*/
+	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
+	*/
+	push(op: RemoteRelationshipOperation): void;
+	/*
+	* Local state changes
+	*/
+	update(op: RemoteRelationshipOperation | MergeOperation, isRemote: true): void;
+	update(op: LocalRelationshipOperation, isRemote?: false): void;
+	_scheduleLocalSync(relationship: CollectionEdge): void;
+	_flushRemoteQueue(): void;
+	_addToTransaction(relationship: CollectionEdge | ResourceEdge): void;
+	_flushLocalQueue(): void;
+	destroy(): void;
 }
 export {};
-//# sourceMappingURL=graph.d.ts.map

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

@@ -1,3 +1,8 @@
-import type { Link, LinkObject } from '../../types/spec/json-api-raw.ts';
+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;
-//# sourceMappingURL=normalize-link.d.ts.map

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

@@ -1,5 +1,4 @@
-import type { AddToResourceRelationshipMutation } from '../../../types/cache/mutations.ts';
-import type { AddToResourceRelationshipOperation } from '../../../types/cache/operations.ts';
-import type { Graph } from '../graph.ts';
+import type { AddToResourceRelationshipMutation } from "../../../types/cache/mutations.js";
+import type { AddToResourceRelationshipOperation } from "../../../types/cache/operations.js";
+import type { Graph } from "../graph.js";
 export default function addToRelatedRecords(graph: Graph, op: AddToResourceRelationshipOperation | AddToResourceRelationshipMutation, isRemote: boolean): void;
-//# sourceMappingURL=add-to-related-records.d.ts.map

package/declarations/graph/-private/operations/merge-identifier.d.ts

@@ -1,4 +1,3 @@
-import type { MergeOperation } from '../../../types/cache/operations.ts';
-import type { Graph, GraphEdge } from '../graph.ts';
+import type { MergeOperation } from "../../../types/cache/operations.js";
+import type { Graph, GraphEdge } from "../graph.js";
 export declare function mergeIdentifier(graph: Graph, op: MergeOperation, relationships: Record<string, GraphEdge>): void;
-//# sourceMappingURL=merge-identifier.d.ts.map

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

@@ -1,5 +1,4 @@
-import type { RemoveFromResourceRelationshipMutation } from '../../../types/cache/mutations.ts';
-import type { RemoveFromResourceRelationshipOperation } from '../../../types/cache/operations.ts';
-import type { Graph } from '../graph.ts';
+import type { RemoveFromResourceRelationshipMutation } from "../../../types/cache/mutations.js";
+import type { RemoveFromResourceRelationshipOperation } from "../../../types/cache/operations.js";
+import type { Graph } from "../graph.js";
 export default function removeFromRelatedRecords(graph: Graph, op: RemoveFromResourceRelationshipOperation | RemoveFromResourceRelationshipMutation, isRemote: boolean): void;
-//# sourceMappingURL=remove-from-related-records.d.ts.map

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

@@ -1,4 +1,3 @@
-import type { ReplaceRelatedRecordOperation } from '../../../types/graph.ts';
-import type { Graph } from '../graph.ts';
+import type { ReplaceRelatedRecordOperation } from "../../../types/graph.js";
+import type { Graph } from "../graph.js";
 export default function replaceRelatedRecord(graph: Graph, op: ReplaceRelatedRecordOperation, isRemote?: boolean): void;
-//# sourceMappingURL=replace-related-record.d.ts.map

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

@@ -1,8 +1,62 @@
-import type { StableRecordIdentifier } from '../../../types.ts';
-import type { ReplaceRelatedRecordsOperation } from '../../../types/graph.ts';
-import type { Graph } from '../graph.ts';
+import type { StableRecordIdentifier } 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;
-//# sourceMappingURL=replace-related-records.d.ts.map

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

@@ -1,11 +1,13 @@
-import type { Store } from '../../../index.ts';
-import type { StableRecordIdentifier } from '../../../types.ts';
-import type { UpdateResourceRelationshipOperation } from '../../../types/cache/operations.ts';
-import type { UpdateRelationshipOperation } from '../../../types/graph.ts';
-import type { ExistingResourceIdentifierObject, NewResourceIdentifierObject } from '../../../types/spec/json-api-raw.ts';
-import type { Graph } from '../graph.ts';
-type IdentifierCache = Store['identifierCache'];
+import type { Store } from "../../../index.js";
+import type { StableRecordIdentifier } 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).
+*/
 export default function updateRelationshipOperation(graph: Graph, op: UpdateRelationshipOperation | UpdateResourceRelationshipOperation): void;
 export declare function upgradeIdentifiers(arr: (ExistingResourceIdentifierObject | NewResourceIdentifierObject | StableRecordIdentifier)[], cache: IdentifierCache): StableRecordIdentifier[];
-export {};
-//# sourceMappingURL=update-relationship.d.ts.map

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

@@ -1,14 +1,13 @@
-import type { Store } from '../index.ts';
-import type { CacheCapabilitiesManager } from '../types.ts';
-import { Graph } from './-private/graph.ts';
-export { isBelongsTo } from './-private/-utils.ts';
-export type { CollectionEdge } from './-private/edges/collection.ts';
-export type { ResourceEdge } from './-private/edges/resource.ts';
-export type { ImplicitEdge } from './-private/edges/implicit.ts';
-export type { GraphEdge } from './-private/graph.ts';
-export type { UpgradedMeta } from './-private/-edge-definition.ts';
+import type { Store } from "../index.js";
+import type { CacheCapabilitiesManager } from "../types.js";
+import { Graph } from "./-private/graph.js";
+export { isBelongsTo } from "./-private/-utils.js";
+export type { CollectionEdge } from "./-private/edges/collection.js";
+export type { ResourceEdge } from "./-private/edges/resource.js";
+export type { ImplicitEdge } from "./-private/edges/implicit.js";
+export type { GraphEdge } from "./-private/graph.js";
+export type { UpgradedMeta } from "./-private/-edge-definition.js";
 export type { Graph };
 export declare function peekGraph(store: CacheCapabilitiesManager | Store): Graph | undefined;
 export type peekGraph = typeof peekGraph;
 export declare function graphFor(store: CacheCapabilitiesManager | Store): Graph;
-//# sourceMappingURL=-private.d.ts.map

package/declarations/index.d.ts

@@ -1,15 +1,14 @@
 /**
- * @module
- * @mergeModuleWith <project>
- */
-import type { ReactiveDocument } from './reactive/-private/document.ts';
-export { Fetch } from './request/-private/fetch.ts';
-export { RequestManager } from './request/-private/manager.ts';
-export { Store, type StoreRequestContext, CacheHandler, type CachePolicy, type StoreRequestInput, recordIdentifierFor, storeFor, } from './store/-private.ts';
+* @module
+* @mergeModuleWith <project>
+*/
+import type { ReactiveDocument } from "./reactive/-private/document.js";
+export { Fetch } from "./request/-private/fetch.js";
+export { RequestManager } from "./request/-private/manager.js";
+export { Store, type StoreRequestContext, CacheHandler, type CachePolicy, type StoreRequestInput, recordIdentifierFor, storeFor } from "./store/-private.js";
 /**
- * @deprecated use `ReactiveDocument` instead
- */
+* @deprecated use `ReactiveDocument` instead
+*/
 export type Document<T> = ReactiveDocument<T>;
-export type { DocumentCacheOperation, CacheOperation, NotificationType, } from './store/-private/managers/notification-manager.ts';
-export { setIdentifierGenerationMethod, setIdentifierUpdateMethod, setIdentifierForgetMethod, setIdentifierResetMethod, setKeyInfoForResource, } from './store/-private/caches/identifier-cache.ts';
-//# sourceMappingURL=index.d.ts.map
+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";