@warp-drive-mirror/core 5.10.0-alpha.2 → 5.10.0-alpha.21

package/dist/{internal-BrqYbG_y.d.ts → internal-D_WIXC4r.d.ts}

@@ -1,22 +1,21 @@
-import { c as RequestKey, l as ResourceKey, n as CacheKeyType, s as PersistedResourceKey } from "./identifier-DQnqOSJK.js";
-import { t as QueryParamsSerializationOptions } from "./params-DrEx3bf8.js";
-import { a as Type, n as RequestSignature } from "./symbols-DjRDCeX0.js";
-import { c as TypedRecordInstance, i as OpaqueRecordInstance$1, o as TypeFromInstance, s as TypeFromInstanceOrString } from "./record-D3QQcaIR.js";
-import { i as Value, n as ObjectValue } from "./raw-D5hnjiq7.js";
-import { d as Meta, g as ResourceIdentifierObject, i as ExistingResourceIdentifierObject, m as PaginationLinks, r as EmptyResourceDocument, s as JsonApiDocument, t as CollectionResourceDocument, u as Links, y as SingleResourceDocument } from "./json-api-raw-C5APJHHB.js";
-import { A as ResourceField, C as ObjectField, F as Trait, M as Schema, N as SchemaArrayField, O as PolarisResourceSchema, P as SchemaObjectField, T as ObjectSchema, a as DerivedField, b as LinksModeHasManyField, c as HashField, d as LegacyAttributeField, f as LegacyBelongsToField, g as LegacyRelationshipField, i as CollectionField, j as ResourceSchema, l as IdentityField, m as LegacyHasManyField, o as FieldSchema, r as CacheableFieldSchema, s as GenericField, t as ArrayField } from "./fields-FM7peCiM.js";
-import { n as HashFn, r as Transformation$1, t as Derivation } from "./concepts-DFldVwEM.js";
-import { n as WithPartial } from "./utils-BtURiy8l.js";
-import { t as ResourceBlob } from "./aliases-BWYW5EhX.js";
-import { t as Change } from "./change-C7kqv2kW.js";
-import { n as Mutation } from "./mutations-CqtoGB4t.js";
-import { r as ResourceRelationship, t as CollectionRelationship } from "./relationship-CmHzMPKf.js";
-import { i as MergeOperation, o as Operation$1 } from "./operations-D1qA6r0_.js";
-import { t as ApiError } from "./error-0uD6GkNX.js";
-import { o as SingleResourceDataDocument, r as ResourceDocument, t as CollectionResourceDataDocument } from "./document-Ca4ZZBd9.js";
-import { i as RemoteRelationshipOperation, n as LocalRelationshipOperation, t as DeleteRecordOperation } from "./graph-DLqYXP2z.js";
-import { i as SignalRef, t as ARRAY_SIGNAL } from "./configure-B_F639tN.js";
-//#region src/request/-private/manager.d.ts
+import { c as RequestKey, l as ResourceKey, n as CacheKeyType, s as PersistedResourceKey } from "./identifier-DmgDehQK.js";
+import { t as QueryParamsSerializationOptions } from "./params-CNLjCRyH.js";
+import { a as Type, n as RequestSignature } from "./symbols-DVa1PMFG.js";
+import { c as TypedRecordInstance, i as OpaqueRecordInstance$1, o as TypeFromInstance, s as TypeFromInstanceOrString } from "./record-f5-uOgHt.js";
+import { i as Value, n as ObjectValue } from "./raw-adYGuEGM.js";
+import { a as ExistingResourceObject, d as Meta, g as ResourceIdentifierObject, i as ExistingResourceIdentifierObject, m as PaginationLinks, r as EmptyResourceDocument, s as JsonApiDocument, t as CollectionResourceDocument, u as Links, y as SingleResourceDocument } from "./json-api-raw-juUdIITO.js";
+import { A as ResourceField, C as ObjectField, F as Trait, M as Schema, N as SchemaArrayField, O as PolarisResourceSchema, P as SchemaObjectField, T as ObjectSchema, a as DerivedField, b as LinksModeHasManyField, c as HashField, d as LegacyAttributeField, f as LegacyBelongsToField, g as LegacyRelationshipField, i as CollectionField, j as ResourceSchema, l as IdentityField, m as LegacyHasManyField, o as FieldSchema, r as CacheableFieldSchema, s as GenericField, t as ArrayField } from "./fields-r1rZJB9d.js";
+import { n as HashFn, r as Transformation$1, t as Derivation } from "./concepts-vh86nAcd.js";
+import { n as WithPartial } from "./utils-BVKvrO6e.js";
+import { t as ResourceBlob } from "./aliases-BG5TxALl.js";
+import { t as Change } from "./change-INHMiZ2a.js";
+import { n as Mutation } from "./mutations-CA39mior.js";
+import { r as ResourceRelationship, t as CollectionRelationship } from "./relationship-99pc4CaS.js";
+import { i as MergeOperation, o as Operation$1 } from "./operations-C1WAEKKq.js";
+import { t as ApiError } from "./error-j5n1yL9m.js";
+import { o as SingleResourceDataDocument, r as ResourceDocument, t as CollectionResourceDataDocument } from "./document-B8Fup751.js";
+import { i as RemoteRelationshipOperation, n as LocalRelationshipOperation, t as DeleteRecordOperation } from "./graph-BqxaFjEb.js";
+import { i as SignalRef, t as ARRAY_SIGNAL } from "./configure-BfXDuPUb.js";
 /**
  * ## Import
  *
@@ -24,7 +23,8 @@ import { i as SignalRef, t as ARRAY_SIGNAL } from "./configure-B_F639tN.js";
  * import { RequestManager } from '@warp-drive-mirror/core';
  * ```
  *
- * For complete usage guide see the [RequestManager Documentation](/guides/).
+ * For a complete usage guide see [Making Requests](/guides/the-manual/requests/), and
+ * [Handlers](/guides/the-manual/requests/handlers) for writing the handlers it runs.
  *
  * ## How It Works
  *
@@ -47,11 +47,28 @@ import { i as SignalRef, t as ARRAY_SIGNAL } from "./configure-B_F639tN.js";
  * ```ts [Setup.ts]
  * import { RequestManager, Fetch } from '@warp-drive-mirror/core';
  * import { AutoCompress } from '@warp-drive-mirror/utilities/handlers';
- * import Auth from 'ember-simple-auth/handler';
+ * import { AuthHandler } from './auth-handler';
  *
  * // ... create manager
  * const manager = new RequestManager()
- *    .use([Auth, new AutoCompress(), Fetch]); // [!code focus]
+ *    .use([AuthHandler, new AutoCompress(), Fetch]); // [!code focus]
+ * ```
+ *
+ * ```ts [auth-handler.ts]
+ * import type { Handler, NextFn } from '@warp-drive-mirror/core/request';
+ * import type { RequestContext } from '@warp-drive-mirror/core/types/request';
+ *
+ * const token = '<token>';
+ *
+ * // adds a bearer token to every request, then passes it along
+ * export const AuthHandler: Handler = {
+ *   request<T>(context: RequestContext, next: NextFn<T>) {
+ *     const headers = new Headers(context.request.headers);
+ *     headers.append('Authorization', `Bearer ${token}`);
+ *
+ *     return next(Object.assign({}, context.request, { headers }));
+ *   },
+ * };
  * ```
  *
  * ```ts [Usage.ts]
@@ -67,6 +84,20 @@ import { i as SignalRef, t as ARRAY_SIGNAL } from "./configure-B_F639tN.js";
  *
  * :::
  *
+ * ### RequestManager vs {@link Store.request}
+ *
+ * A bare `RequestManager` is the low-level primitive: it runs a request through the configured
+ * {@link Handler | handler chain} and settles with the raw {@link StructuredDocument}. It has no
+ * cache and does not hydrate {@link ReactiveDocument | ReactiveDocuments} unless you register a
+ * cache handler yourself via {@link RequestManager.useCache} and the request opts in.
+ *
+ * {@link Store.request} issues requests through this same `RequestManager`, but with the Store's
+ * cache handler and hydration already wired up — inserting the response into the Store's cache
+ * and resolving with a `ReactiveDocument` instead. Use `store.request` for anything the Store's
+ * cache should own, which is nearly all app code. Reach for `requestManager.request` directly
+ * only when there is no {@link Store} involved, or you specifically want the unprocessed
+ * `StructuredDocument`.
+ *
  * ### Futures
  *
  * The return value of `manager.request` is a `Future`, which allows
@@ -105,6 +136,7 @@ import { i as SignalRef, t as ARRAY_SIGNAL } from "./configure-B_F639tN.js";
  * type StructuredDocument<T> = StructuredDataDocument<T> | StructuredErrorDocument;
  * ```
  *
+ * @summary Runs each request through a chain of handlers that can fulfill, modify, or pass it along, and returns a `Future` for the response.
  * @public
  */
 declare class RequestManager {
@@ -134,7 +166,23 @@ declare class RequestManager {
   /**
    * Issue a Request.
    *
-   * Returns a Future that fulfills with a StructuredDocument
+   * Runs `request` through the configured {@link Handler | handler chain} and settles with the
+   * {@link StructuredDocument} the chain produces — a plain `{ request, response, content }`
+   * object, not a {@link ReactiveDocument}. Caching and hydration only happen if a cache handler
+   * has been registered via {@link RequestManager.useCache} and the request opts in; a
+   * `RequestManager` created on its own has neither.
+   *
+   * Most app code should use {@link Store.request} instead, which calls this same method with
+   * the Store's cache handler and hydration already configured. Reach for `requestManager.request`
+   * directly when there is no {@link Store} involved, or when you want the unprocessed
+   * `StructuredDocument`. The `<RT>` generic can be set explicitly or inferred from a request
+   * built with {@link withResponseType} or {@link withReactiveResponse} — see
+   * [Typing Requests](/guides/the-manual/requests/typing-requests.md).
+   *
+   * @example
+   * ```ts
+   * const { content } = await requestManager.request({ url: '/users' });
+   * ```
    *
    * @public
    */
@@ -171,8 +219,6 @@ interface PrivateRequestManager extends RequestManager {
     promise: Promise<unknown>;
   }>;
 }
-//#endregion
-//#region src/request/-private/types.d.ts
 interface GodContext {
   controller: AbortController;
   response: ResponseInfo | null;
@@ -187,6 +233,8 @@ interface GodContext {
  * allowing the promise to be created before the work that will settle it
  * has begun. See {@link createDeferred}.
  *
+ * @summary A promise bundled with the `resolve` and `reject` callbacks that settle it, as returned by
+ * `createDeferred`.
  * @public
  */
 type Deferred<T> = {
@@ -203,6 +251,8 @@ type Deferred<T> = {
  * background reload that other requests may dedupe against without
  * waiting on it.
  *
+ * @summary Marks whether a deduped managed request blocks its caller's promise or runs as a
+ * non-blocking background reload.
  * @public
  */
 type ManagedRequestPriority = {
@@ -221,6 +271,11 @@ type DeferredStream = {
  * while providing the ability to {@link Future.abort | abort} the underlying request, and
  * {@link Future.getStream | access the response stream} before the outer promise resolves;
  *
+ * The [Using The Response](/guides/the-manual/requests/using-the-response) guide shows
+ * how to work with one.
+ *
+ * @summary The promise returned for every request, resolving with the response document and able to
+ * abort the request or expose its response stream early.
  * @public
  */
 interface Future<T> extends Promise<StructuredDataDocument<T>> {
@@ -278,6 +333,10 @@ interface Future<T> extends Promise<StructuredDataDocument<T>> {
  * used to forward a request to the next handler in the chain. Resolves to a
  * {@link Future} carrying the downstream response.
  *
+ * The [Handlers](/guides/the-manual/requests/handlers) guide shows a handler calling it.
+ *
+ * @summary The function a request handler calls to pass a request to the next handler in the chain,
+ * returning a `Future` for its response.
  * @public
  */
 type NextFn<P = unknown> = (req: RequestInfo) => Future<P>;
@@ -286,6 +345,8 @@ type NextFn<P = unknown> = (req: RequestInfo) => Future<P>;
 as well as a `next` function with which to pass along a request to the next
 handler if it so chooses.
 
+The [Handlers](/guides/the-manual/requests/handlers) guide walks through writing one.
+
 A handler may be any object with a `request` method. This allows both stateful and non-stateful
 handlers to be utilized.
 
@@ -322,7 +383,7 @@ response content before passing along the chunk downstream.
 const FetchHandler = {
 async request(context) {
 const response = await fetch(context.request);
-context.setResponse(reponse);
+context.setResponse(response);
 context.setStream(response.clone().body);
 
 return response.json();
@@ -388,6 +449,8 @@ const manager = new RequestManager()
 
 Handlers will be invoked in the order they are registered ("fifo", first-in first-out), and may only be registered up until the first request is made. It is recommended but not required to register all handlers at one time in order to ensure explicitly visible handler ordering.
 
+@summary An object with a `request` method that a RequestManager calls to fulfill a request, either
+itself or by calling `next` to pass it along.
 @public
 */
 interface Handler {
@@ -408,6 +471,8 @@ interface Handler {
  * A RequestManager may only have one CacheHandler, registered via
  * `manager.useCache(CacheHandler)`.
  *
+ * @summary The single handler a RequestManager runs before all others via `useCache`, which may return
+ * a result synchronously.
  * @public
  */
 interface CacheHandler$1 {
@@ -421,8 +486,6 @@ interface CacheHandler$1 {
   request<T = unknown>(context: RequestContext, next: NextFn<T>): Promise<T | StructuredDataDocument<T>> | Future<T> | T;
 }
 type GenericCreateArgs = Record<string | symbol, unknown>;
-//#endregion
-//#region src/request/-private/context.d.ts
 declare class ContextOwner {
   hasSetStream: boolean;
   hasSetResponse: boolean;
@@ -452,6 +515,8 @@ declare class ContextOwner {
  * {@link StructuredDataDocument} that will ultimately be returned by the
  * {@link RequestManager}.
  *
+ * @summary The per-request object passed to each handler, exposing the immutable request plus methods to
+ * set the response, stream, and request key.
  * @public
  */
 declare class Context$1 {
@@ -504,8 +569,6 @@ declare class Context$1 {
   /** @private */
   _finalize(): void;
 }
-//#endregion
-//#region src/request/-private/utils.d.ts
 declare const IS_CACHE_HANDLER: "___(unique) Symbol(IS_CACHE_HANDLER)";
 /**
  * Additional properties exposed on errors thrown by the
@@ -517,6 +580,9 @@ declare const IS_CACHE_HANDLER: "___(unique) Symbol(IS_CACHE_HANDLER)";
  * Else it extends from {@link AggregateError} if the
  * response includes an array of errors, falling back
  * to {@link Error} as its base.
+ *
+ * @summary The shape of errors thrown by the Fetch handler for failed, aborted, or network-errored
+ * requests, carrying the HTTP `status` and `statusText`.
  */
 interface FetchError extends DOMException {
   /**
@@ -556,18 +622,22 @@ interface FetchError extends DOMException {
    */
   isRequestError: true;
 }
-//#endregion
-//#region src/types/request.d.ts
 /**
  * A {@link RequestInfo.cacheOptions | cacheOptions} flag which, when set,
  * signals that a request should never be handled by the cache-manager and
  * thus will never resolve from cache nor update the cache.
+ *
+ * @summary Symbol key for a request's `cacheOptions` that, when true, makes the request bypass the CacheHandler so it
+ * neither resolves from nor updates the cache.
  */
 declare const SkipCache: "___(unique) Symbol(SkipCache)";
 /**
  * A {@link RequestInfo} flag which, when set, signals to the store's
  * `instantiateRecord` hook that the resolved content should be hydrated
  * into reactive records rather than returned as raw data.
+ *
+ * @summary Symbol flag on a request that makes the CacheHandler return reactive records instead of raw cache
+ * documents; `store.request` sets it automatically.
  */
 declare const EnableHydration: "___(unique) Symbol(EnableHydration)";
 /**
@@ -580,12 +650,16 @@ declare const IS_FUTURE: "___(unique) Symbol(IS_FUTURE)";
 declare const STRUCTURED: "___(unique) Symbol(DOC)";
 /**
  * The HTTP methods WarpDrive's request layer supports.
+ *
+ * @summary Union of the HTTP method strings, including `QUERY`, that a WarpDrive request's `method` may be set to.
  */
 type HTTPMethod = "QUERY" | "GET" | "OPTIONS" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "CONNECT" | "TRACE";
 /**
  * Use these options to adjust {@link CacheHandler} behavior for a request
  * via {@link RequestInfo.cacheOptions}.
  *
+ * @summary Per-request settings on `cacheOptions` that control the cache key, forced or background reloads,
+ * invalidation by resource type, and cache bypass.
  */
 interface CacheOptions {
   /**
@@ -635,6 +709,9 @@ interface CacheOptions {
 /**
  * The request shape produced by the `findRecord` request builders, for
  * use with {@link Store.request}.
+ *
+ * @summary Shape of the `GET` request object that `findRecord` builders return for `store.request`, carrying the url,
+ * headers, and requested resource identifier.
  */
 type FindRecordRequestOptions<RT = unknown, T = unknown> = {
   /**
@@ -669,6 +746,9 @@ type FindRecordRequestOptions<RT = unknown, T = unknown> = {
 /**
  * The request shape produced by the `query` request builders, for
  * use with {@link Store.request}.
+ *
+ * @summary Shape of the `GET` request object that `query` builders return for `store.request`, carrying the url,
+ * headers, and cache options.
  */
 type QueryRequestOptions<RT = unknown> = {
   /**
@@ -699,6 +779,9 @@ type QueryRequestOptions<RT = unknown> = {
 /**
  * The request shape produced by the `postQuery` request builders, for
  * use with {@link Store.request}.
+ *
+ * @summary Shape of the `POST` or `QUERY` request object that `postQuery` builders return, with a body and a required
+ * cache key since the url cannot serve as one.
  */
 type PostQueryRequestOptions<RT = unknown> = {
   /**
@@ -739,6 +822,9 @@ type PostQueryRequestOptions<RT = unknown> = {
 /**
  * The request shape produced by the `deleteRecord` request builders, for
  * use with {@link Store.request}.
+ *
+ * @summary Shape of the `DELETE` request object that `deleteRecord` builders return for `store.request`, identifying
+ * the resource being deleted.
  */
 type DeleteRequestOptions<RT = unknown, T = unknown> = {
   /**
@@ -786,6 +872,9 @@ type ImmutableRequest<T> = Readonly<T> & {
 /**
  * The request shape produced by the `updateRecord` request builders, for
  * use with {@link Store.request}.
+ *
+ * @summary Shape of the `PATCH` or `PUT` request object that `updateRecord` builders return for `store.request`,
+ * identifying the resource being saved.
  */
 type UpdateRequestOptions<RT = unknown, T = unknown> = {
   /**
@@ -829,6 +918,9 @@ type UpdateRequestOptions<RT = unknown, T = unknown> = {
 /**
  * The request shape produced by the `createRecord` request builders, for
  * use with {@link Store.request}.
+ *
+ * @summary Shape of the `POST` request object that `createRecord` builders return for `store.request`, identifying the
+ * new resource being saved.
  */
 type CreateRequestOptions<RT = unknown, T = unknown> = {
   /**
@@ -871,19 +963,31 @@ type CreateRequestOptions<RT = unknown, T = unknown> = {
 };
 /**
  * The immutable, handler-facing form of {@link DeleteRequestOptions}.
+ *
+ * @summary Read-only view of a `deleteRecord` request as a handler receives it, with immutable headers and `records`
+ * as resource keys.
  */
 type ImmutableDeleteRequestOptions = ImmutableRequest<DeleteRequestOptions>;
 /**
  * The immutable, handler-facing form of {@link UpdateRequestOptions}.
+ *
+ * @summary Read-only view of an `updateRecord` request as a handler receives it, with immutable headers and `records`
+ * as resource keys.
  */
 type ImmutableUpdateRequestOptions = ImmutableRequest<UpdateRequestOptions>;
 /**
  * The immutable, handler-facing form of {@link CreateRequestOptions}.
+ *
+ * @summary Read-only view of a `createRecord` request as a handler receives it, with immutable headers and `records`
+ * as resource keys.
  */
 type ImmutableCreateRequestOptions = ImmutableRequest<CreateRequestOptions>;
 /**
  * A minimal reference to a resource sufficient to build a URL for it,
  * as accepted by the request builders.
+ *
+ * @summary A resource reference with a persisted `id` and `type` and an optional `lid`, which is enough for request
+ * builders to construct its url.
  */
 type RemotelyAccessibleIdentifier<T extends string = string> = {
   /**
@@ -902,6 +1006,9 @@ type RemotelyAccessibleIdentifier<T extends string = string> = {
 /**
  * Options accepted by the request builders for constraining how a
  * request's url is constructed and how the request interacts with the cache.
+ *
+ * @summary Options the request builders accept to set reload behavior and override the url's host, namespace, resource
+ * path, and query param serialization.
  */
 interface ConstrainedRequestOptions {
   /**
@@ -936,6 +1043,9 @@ interface ConstrainedRequestOptions {
 }
 /**
  * Options accepted by the `findRecord` request builders.
+ *
+ * @summary Options the `findRecord` request builders accept: the shared url and reload options plus the relationship
+ * paths to `include`.
  */
 interface FindRecordOptions$2 extends ConstrainedRequestOptions {
   /**
@@ -948,6 +1058,9 @@ interface FindRecordOptions$2 extends ConstrainedRequestOptions {
  * containing the original {@link RequestInfo | request},
  * the {@link Response | response} set by the handler chain (if any), and
  * the processed content.
+ *
+ * @summary The `{ request, response, content }` object that a request's `Future` resolves with when the request
+ * succeeds.
  */
 interface StructuredDataDocument<T> {
   /**
@@ -975,6 +1088,9 @@ interface StructuredDataDocument<T> {
  *
  * If using the error originates from the {@link Fetch | Fetch Handler}
  * the error will be a {@link FetchError}
+ *
+ * @summary The Error a request's `Future` rejects with when the request fails, carrying the `request`, `response`,
+ * `error`, and any `content` received.
  */
 interface StructuredErrorDocument<T = unknown> extends Error {
   /**
@@ -1002,11 +1118,16 @@ interface StructuredErrorDocument<T = unknown> extends Error {
  * A union of the resolve/reject data types for the {@link Future}
  * returned by {@link Store.request | request}
  *
+ * The [Using The Response](/guides/the-manual/requests/using-the-response) guide shows
+ * how to read one.
+ *
  * See also the docs for:
  *
  * - {@link Future}
  * - {@link StructuredDataDocument} (resolved/successful requests)
  * - {@link StructuredErrorDocument} (rejected/failed requests)
+ *
+ * @summary Union of the success and error documents that a request's `Future` resolves or rejects with.
  */
 type StructuredDocument<T> = StructuredDataDocument<T> | StructuredErrorDocument<T>;
 /**
@@ -1082,6 +1203,9 @@ interface NativeRequestInit {
 /**
  * A read-only {@link Headers} instance, as passed to {@link Handler | Handlers}
  * via {@link ImmutableRequestInfo.headers}.
+ *
+ * @summary Read-only `Headers` that handlers see on a request, adding `toJSON` to serialize them as `[key, value]`
+ * pairs and an optional mutable `clone`.
  */
 interface ImmutableHeaders extends Headers {
   /**
@@ -1100,6 +1224,11 @@ interface ImmutableHeaders extends Headers {
  * This interface is used to define the shape of a request that can be made via
  * either the {@link RequestManager.request} or {@link Store.request} methods.
  *
+ * The [Making Requests](/guides/the-manual/requests/#request-options) guide explains
+ * its options.
+ *
+ * @summary Describes a request for `store.request` or `RequestManager.request`: native fetch options plus cache
+ * options, operation name, records, data, and the store.
  * @privateRemarks
  * - [MDN Reference (fetch)](https://developer.mozilla.org/docs/Web/API/Window/fetch)
  * - [MDN Reference (RequestInit)](https://developer.mozilla.org/en-US/docs/Web/API/RequestInit)
@@ -1191,6 +1320,8 @@ interface RequestInfo<RT = unknown> extends NativeRequestInit {
 /**
  * Immutable version of {@link RequestInfo}. This is what is passed to handlers.
  *
+ * @summary Read-only form of a request as handlers receive it, with frozen headers, data, options, and cache options
+ * and no `controller`.
  */
 type ImmutableRequestInfo<RT = unknown> = Readonly<Omit<RequestInfo<RT>, "controller">> & {
   /**
@@ -1216,6 +1347,9 @@ type ImmutableRequestInfo<RT = unknown> = Readonly<Omit<RequestInfo<RT>, "contro
 /**
  * An immutable, JSON-serializable subset of the native {@link Response}
  * interface.
+ *
+ * @summary Immutable, JSON-serializable snapshot of a fetch `Response`'s headers, status, url, and type, usable in
+ * place of a `Response` in request results.
  */
 interface ResponseInfo {
   /**
@@ -1251,6 +1385,11 @@ interface ResponseInfo {
  * The object a {@link Handler} uses to fulfill a request: it provides a
  * readonly view of the {@link RequestContext.request | request} and methods
  * for supplying the {@link Future}'s stream and final response.
+ *
+ * The [Handlers](/guides/the-manual/requests/handlers) guide shows a handler using it.
+ *
+ * @summary Object passed to each request handler with the immutable request, a request id, and methods for setting the
+ * response stream and the response.
  */
 interface RequestContext {
   /**
@@ -1271,8 +1410,6 @@ interface RequestContext {
    */
   setResponse(response: Response | ResponseInfo | null): void;
 }
-//#endregion
-//#region src/store/-types/q/identifier.d.ts
 interface GenerationMethod {
   (data: ImmutableRequestInfo, bucket: "document"): string | null;
   (data: unknown | {
@@ -1294,498 +1431,281 @@ type KeyInfo = {
   type: string;
 };
 type KeyInfoMethod = (resource: unknown, known: ResourceKey | null) => KeyInfo;
-//#endregion
-//#region src/store/-private/managers/cache-key-manager.d.ts
-type TypeFromIdentifier<T> = T extends {
-  type: infer U;
-} ? U : string;
-type NarrowIdentifierIfPossible<T> = T extends ExistingResourceIdentifierObject ? PersistedResourceKey<TypeFromIdentifier<T>> : ResourceKey;
-/**
- * Type-guard that returns `true` if the given value is a stable {@link ResourceKey}
- * (as opposed to a {@link RequestKey} or arbitrary, not-yet-stabilized resource data).
- */
-declare function isResourceKey(identifier: unknown): identifier is ResourceKey;
-/**
- * Type-guard that returns `true` if the given value is a stable {@link RequestKey}
- * (as opposed to a {@link ResourceKey} or arbitrary, not-yet-stabilized data).
- */
-declare function isRequestKey(identifier: unknown): identifier is RequestKey;
-interface KeyOptions {
-  lid: IdentifierMap;
-  id: IdentifierMap;
+interface BaseFinderOptions$1 {
+  reload?: boolean;
+  backgroundReload?: boolean;
+  include?: string | string[];
+  adapterOptions?: Record<string, unknown>;
 }
-type TypeMap = {
-  [key: string]: KeyOptions;
-};
-type IdentifierMap = Map<string, ResourceKey>;
-type StableCache = {
-  resources: IdentifierMap;
-  documents: Map<string, RequestKey>;
-  resourcesByType: TypeMap;
-  polymorphicLidBackMap: Map<string, string[]>;
+interface FindRecordOptions$1 extends BaseFinderOptions$1 {
+  /**
+   * Data to preload into the store before the request is made.
+   * This feature is *highly* discouraged and has no corresponding
+   * feature when using builders and handlers.
+   *
+   * Excepting relationships: the data should be in the form of a
+   * JSON object where the keys are fields on the record and the value
+   * is the raw value to be added to the cache.
+   *
+   * Relationships can either be provided as string IDs from which
+   * an identifier will be built base upon the relationship's expected
+   * resource type, or be record instances from which the identifier
+   * will be extracted.
+   *
+   */
+  preload?: Record<string, Value>;
+}
+type QueryOptions$1 = { [K in string | "adapterOptions"]?: K extends "adapterOptions" ? Record<string, unknown> : unknown; };
+type FindAllOptions$1 = BaseFinderOptions$1;
+type LegacyResourceQuery$1 = {
+  include?: string | string[];
+  [key: string]: Value | undefined;
 };
-type MergeMethod = (targetIdentifier: ResourceKey, matchedIdentifier: ResourceKey, resourceData: unknown) => ResourceKey;
+type KeyOrString<T> = keyof T & string extends never ? string : keyof T & string;
 /**
-Configures how unique identifier lid strings are generated by @ember-data-mirror/store.
-
-This configuration MUST occur prior to the store instance being created.
-
-Takes a method which can expect to receive various data as its first argument
-and the name of a bucket as its second argument.
-
-Currently there are two buckets, 'record' and 'document'.
-
-### Resource (`Record`) Identity
-
-If the bucket is `record` the method must return a unique (to at-least
-the given bucket) string identifier for the given data as a string to be
-used as the `lid` of an `Identifier` token.
-
-This method will only be called by either `getOrCreateRecordIdentifier` or
-`createIdentifierForNewRecord` when an identifier for the supplied data
-is not already known via `lid` or `type + id` combo and one needs to be
-generated or retrieved from a proprietary cache.
-
-`data` will be the same data argument provided to `getOrCreateRecordIdentifier`
-and in the `createIdentifierForNewRecord` case will be an object with
-only `type` as a key.
-
-```ts
-import { setIdentifierGenerationMethod } from '@warp-drive-mirror/core';
-
-export function initialize(applicationInstance) {
-// note how `count` here is now scoped to the application instance
-// for our generation method by being inside the closure provided
-// by the initialize function
-let count = 0;
-
-setIdentifierGenerationMethod((resource, bucket) => {
-return resource.lid || `my-key-${count++}`;
-});
+ * Minimum subset of static schema methods and properties on the
+ * "model" class.
+ *
+ * Only used when using the legacy schema-service implementation
+ * for @warp-drive-mirror/legacy/model or when wrapping schema for legacy
+ * Adapters/Serializers.
+ *
+ * @summary Legacy shape of a Model class's static schema API (fields, attributes, relationships, iterators) used
+ * by the legacy schema service and Adapters/Serializers.
+ */
+interface ModelSchema<T = unknown> {
+  /**
+   * The resource type (model name) that this schema describes.
+   */
+  modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
+  /**
+   * A map of every field defined on this resource type to its kind
+   * (`'attribute'`, `'belongsTo'`, or `'hasMany'`).
+   */
+  fields: Map<KeyOrString<T>, "attribute" | "belongsTo" | "hasMany">;
+  /**
+   * A map of every attribute field defined on this resource type, keyed by
+   * attribute name.
+   */
+  attributes: Map<KeyOrString<T>, LegacyAttributeField>;
+  /**
+   * A map of every relationship (`belongsTo`/`hasMany`) field defined on this
+   * resource type, keyed by relationship name.
+   */
+  relationshipsByName: Map<KeyOrString<T>, LegacyRelationshipField>;
+  /**
+   * Invokes `callback` once for each attribute field defined on this resource
+   * type, passing the attribute's key and schema.
+   */
+  eachAttribute<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, attribute: LegacyAttributeField) => void, binding?: T): void;
+  /**
+   * Invokes `callback` once for each relationship field defined on this
+   * resource type, passing the relationship's key and schema.
+   */
+  eachRelationship<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, relationship: LegacyRelationshipField) => void, binding?: T): void;
+  /**
+   * Invokes `callback` once for each attribute field defined on this resource
+   * type that has a transform (a `type`), passing the attribute's key and the
+   * name of the transform to apply.
+   */
+  eachTransformedAttribute<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, type: string | null) => void, binding?: T): void;
 }
-
-export default {
-name: 'configure-ember-data-identifiers',
-initialize
-};
-```
-
-### Document Identity
-
-If the bucket is `document` the method will receive the associated
-immutable `request` passed to `store.request` as its first argument
-and should return a unique string for the given request if the document
-should be cached, and `null` if it should not be cached.
-
-Note, the request result will still be passed to the cache via `Cache.put`,
-but caches should take this as a signal that the document should not itself
-be cached, while its contents may still be used to update other cache state.
-
-The presence of `cacheOptions.key` on the request will take precedence
-for the document cache key, and this method will not be called if it is
-present.
-
-The default method implementation for this bucket is to return `null`
-for all requests whose method is not `GET`, and to return the `url` for
-those where it is.
-
-This means that queries via `POST` MUST provide `cacheOptions.key` or
-implement this hook.
-
-⚠️ Caution: Requests that do not have a `method` assigned are assumed to be `GET`
-
-@public
-*/
-declare function setIdentifierGenerationMethod(method: GenerationMethod | null): void;
 /**
-Configure a callback for when the identifier cache encounters new resource
-data for an existing resource.
-
-This configuration MUST occur prior to the store instance being created.
-
-```js
-import { setIdentifierUpdateMethod } from '@warp-drive-mirror/core';
-```
-
-Takes a method which can expect to receive an existing `Identifier` alongside
-some new data to consider as a second argument. This is an opportunity
-for secondary lookup tables and caches associated with the identifier
-to be amended.
-
-This method is called everytime `updateRecordIdentifier` is called and
-with the same arguments. It provides the opportunity to update secondary
-lookup tables for existing identifiers.
-
-It will always be called after an identifier created with `createIdentifierForNewRecord`
-has been committed, or after an update to the `record` a `RecordIdentifier`
-is assigned to has been committed. Committed here meaning that the server
-has acknowledged the update (for instance after a call to `.save()`)
-
-If `id` has not previously existed, it will be assigned to the `Identifier`
-prior to this `UpdateMethod` being called; however, calls to the parent method
-`updateRecordIdentifier` that attempt to change the `id` or calling update
-without providing an `id` when one is missing will throw an error.
+A `RecordReference` is a low-level API that allows users and
+addon authors to perform meta-operations on a record.
 
+@hideconstructor
 @public
 */
-declare function setIdentifierUpdateMethod(method: UpdateMethod | null): void;
-/**
-Configure a callback for when the identifier cache is going to release an identifier.
-
-This configuration MUST occur prior to the store instance being created.
-
-```js
-import { setIdentifierForgetMethod } from '@warp-drive-mirror/core';
-```
-
-Takes method which can expect to receive an existing `Identifier` that should be eliminated
-from any secondary lookup tables or caches that the user has populated for it.
-
-@public
-*/
-declare function setIdentifierForgetMethod(method: ForgetMethod | null): void;
-/**
-Configure a callback for when the identifier cache is being torn down.
-
-This configuration MUST occur prior to the store instance being created.
-
-```js
-import { setIdentifierResetMethod } from '@warp-drive-mirror/core';
-```
-
-Takes a method which can expect to be called when the parent application is destroyed.
-
-If you have properly used a WeakMap to encapsulate the state of your customization
-to the application instance, you may not need to implement the `resetMethod`.
-
-@public
-*/
-declare function setIdentifierResetMethod(method: ResetMethod | null): void;
-/**
-Configure a callback for when the identifier cache is generating a new
-ResourceKey for a resource.
-
-This method controls the `type` and `id` that will be assigned to the
-`ResourceKey` that is created.
-
-This configuration MUST occur prior to the store instance being created.
-
-```js
-import { setKeyInfoForResource } from '@warp-drive-mirror/core';
-```
-
-@public
-*/
-declare function setKeyInfoForResource(method: KeyInfoMethod | null): void;
-/**
- * Each instance of {@link Store} receives a unique instance of a CacheKeyManager.
- *
- * This cache is responsible for assigning or retrieving the unique identify
- * for arbitrary resource data encountered by the store. Data representing
- * a unique resource or record should always be represented by the same
- * identifier.
- *
- * It can be configured by consuming applications.
- *
- * @hideconstructor
- * @public
- */
-declare class CacheKeyManager {
-  constructor();
+declare class RecordReference {
+  constructor(store: Store$1, identifier: ResourceKey);
+  get type(): string;
   /**
-   * allows us to peek without generating when needed
-   * useful for the "create" case when we need to see if
-   * we are accidentally overwritting something
-   *
-   * @private
-   */
-  peekResourceKey(resource: ResourceIdentifierObject): ResourceKey | undefined;
+	The `id` of the record that this reference refers to.
+	
+	Together, the `type` and `id` properties form a composite key for
+	the identity map.
+	
+	Example
+	
+	```javascript
+	let userRef = store.getReference('user', 1);
+	
+	userRef.id(); // '1'
+	```
+	
+	@public
+	@return The id of the record.
+	*/
+  id(): string | null;
   /**
-   * Peeks the {@link RequestKey} for the given {@link RequestInfo}, but will not
-   * create one if none has been previously generated.
-   *
-   * @public
-   */
-  peekRequestKey(request: RequestInfo): RequestKey | null;
+	The `identifier` of the record that this reference refers to.
+	
+	Together, the `type` and `id` properties form a composite key for
+	the identity map.
+	
+	Example
+	
+	```javascript
+	let userRef = store.getReference('user', 1);
+	
+	userRef.identifier(); // '1'
+	```
+	
+	@public
+	@return The identifier of the record.
+	*/
+  identifier(): ResourceKey;
   /**
-   * Returns the {@link RequestKey} for the given {@link RequestInfo} if the request is
-   * considered cacheable. For cacheable requests, this method will create
-   * a RequestKey if none is found.
-   *
-   * A `null` response indicates the request cannot/will not be cached,
-   * generally this means either
-   *
-   * - {@link RequestInfo.cacheOptions.key} is not present on the `RequestInfo`
-   * - the request's method is `GET` but it has no `url`
-   *
-   * Generally you should not seek to cache requests that are not idempotent
-   * or have side effects, such as mutations that create, update or delete
-   * a resource.
-   *
-   * @public
-   */
-  getOrCreateDocumentIdentifier(request: RequestInfo): RequestKey | null;
+	How the reference will be looked up when it is loaded. Currently
+	this always returns `identity` to signify that a record will be
+	loaded by its `type` and `id`.
+	
+	Example
+	
+	```javascript
+	const userRef = store.getReference('user', 1);
+	
+	userRef.remoteType(); // 'identity'
+	```
+	
+	@public
+	*/
+  remoteType(): "identity";
   /**
-	Returns the {@link ResourceKey} for the given Resource, creates one if it does not yet exist.
+	This API allows you to provide a reference with new data. The
+	simplest usage of this API is similar to `store.push`: you provide a
+	normalized hash of data and the object represented by the reference
+	will update.
 	
-	Specifically this means that we:
+	If you pass a promise to `push`, WarpDrive will not ask the adapter
+	for the data if another attempt to fetch it is made in the
+	interim. When the promise resolves, the underlying object is updated
+	with the new data, and the promise returned by *this function* is resolved
+	with that object.
 	
-	- validate the `id` `type` and `lid` combo against known identifiers
-	- return an object with an `lid` that is stable (repeated calls with the same
-	`id` + `type` or `lid` will return the same `lid` value)
-	- this referential stability of the object itself is guaranteed
+	For example, `recordReference.push(promise)` will be resolved with a
+	record.
+	
+	Example
+	
+	```javascript
+	let userRef = store.getReference('user', 1);
+	
+	// provide data for reference
+	userRef.push({
+	data: {
+	id: "1",
+	type: "user",
+	attributes: {
+	username: "@user"
+	}
+	}
+	}).then(function(user) {
+	userRef.value() === user;
+	});
+	```
 	
 	@public
+	@param objectOrPromise a JSON:API ResourceDocument or a promise resolving to one
+	@return a promise for the value (record or relationship)
 	*/
-  getOrCreateRecordIdentifier<T>(resource: T): NarrowIdentifierIfPossible<T>;
+  push(objectOrPromise: SingleResourceDocument | Promise<SingleResourceDocument>): Promise<OpaqueRecordInstance$1>;
   /**
-	Returns a new Identifier for the supplied data. Call this method to generate
-	an identifier when a new resource is being created local to the client and
-	potentially does not have an `id`.
+	If the entity referred to by the reference is already loaded, it is
+	present as `reference.value`. Otherwise the value returned by this function
+	is `null`.
 	
-	Delegates generation to the user supplied `GenerateMethod` if one has been provided
-	with the signature `generateMethod({ type }, 'record')`.
+	Example
+	
+	```javascript
+	let userRef = store.getReference('user', 1);
+	
+	userRef.value(); // user
+	```
 	
 	@public
+	@return the record for this RecordReference
 	*/
-  createIdentifierForNewRecord(data: {
-    type: string;
-    id?: string | null;
-    lid?: string;
-  }): ResourceKey;
+  value(): OpaqueRecordInstance$1 | null;
   /**
-	Provides the opportunity to update secondary lookup tables for existing identifiers
-	Called after an identifier created with `createIdentifierForNewRecord` has been
-	committed.
+	Triggers a fetch for the backing entity based on its `remoteType`
+	(see `remoteType` definitions per reference type).
 	
-	Assigned `id` to an `Identifier` if `id` has not previously existed; however,
-	attempting to change the `id` or calling update without providing an `id` when
-	one is missing will throw an error.
+	Example
 	
-	- sets `id` (if `id` was previously `null`)
-	- `lid` and `type` MUST NOT be altered post creation
+	```javascript
+	let userRef = store.getReference('user', 1);
 	
-	If a merge occurs, it is possible the returned identifier does not match the originally
-	provided identifier. In this case the abandoned identifier will go through the usual
-	`forgetRecordIdentifier` codepaths.
+	// load user (via store.find)
+	userRef.load().then(...)
+	```
 	
 	@public
+	@return the record for this RecordReference
 	*/
-  updateRecordIdentifier(identifierObject: ResourceKey, data: unknown): ResourceKey;
+  load(): Promise<unknown>;
   /**
-	Provides the opportunity to eliminate an identifier from secondary lookup tables
-	as well as eliminates it from ember-data's own lookup tables and book keeping.
+	Reloads the record if it is already loaded. If the record is not
+	loaded it will load the record via `store.findRecord`
 	
-	Useful when a record has been deleted and the deletion has been persisted and
-	we do not care about the record anymore. Especially useful when an `id` of a
-	deleted record might be reused later for a new record.
+	Example
+	
+	```javascript
+	let userRef = store.getReference('user', 1);
+	
+	// or trigger a reload
+	userRef.reload().then(...)
+	```
 	
 	@public
+	@return the record for this RecordReference
 	*/
-  forgetRecordIdentifier(identifierObject: ResourceKey): void;
+  reload(): Promise<unknown>;
 }
 /**
- * This type exists for internal use only for
- * where intimate contracts still exist either for
- * the Test Suite or for Legacy code.
+ * Options shared by {@link FindRecordOptions} and {@link FindAllOptions}
+ * for controlling reload behavior and adapter/serializer specific
+ * configuration when using the legacy Adapter/Serializer network layer.
  *
- * @private
+ * @summary Legacy reload, background-reload, include, and adapterOptions settings shared by `store.findRecord` and
+ * `store.findAll`.
  */
-interface PrivateCacheKeyManager extends CacheKeyManager {
-  _cache: StableCache;
+interface BaseFinderOptions {
   /**
-   * Internal hook to allow management of merge conflicts with identifiers.
-   *
-   * we allow late binding of this private internal merge so that
-   * the cache can insert itself here to handle elimination of duplicates
-   */
-  __configureMerge(method: MergeMethod | null): void;
-  _mergeRecordIdentifiers(keyInfo: KeyInfo, identifier: ResourceKey, existingIdentifier: ResourceKey, data: unknown): ResourceKey;
-  destroy(): void;
-}
-//#endregion
-//#region src/store/-private/managers/notification-manager.d.ts
-type UnsubscribeToken$1 = object;
-/**
- * The kinds of change notifications the {@link NotificationManager} can emit for a resource.
- */
-type CacheOperation$1 = "added" | "removed" | "updated" | "state";
-/**
- * The kinds of change notifications the {@link NotificationManager} can emit for a request document.
- */
-type DocumentCacheOperation$1 = "invalidated" | "added" | "removed" | "updated" | "state";
-/**
- * The full set of notification kinds the {@link NotificationManager} can emit for a resource,
- * including both {@link CacheOperation}s and finer-grained field-level change notifications.
- */
-type NotificationType = "attributes" | "relationships" | "identity" | "errors" | "meta" | CacheOperation$1;
-/**
- * The shape accepted by {@link NotificationManager.notify} and
- * {@link CacheCapabilitiesManager.notifyChange} for delivering many keys for
- * the `'attributes'` or `'relationships'` namespaces in a single call
- * instead of once per key.
- *
- * @since 5.9.0
- * @public
- */
-type NotifyKeys = Set<string>;
-/**
- * A change to a resource's `attributes` or `relationships` can be relevant to
- * a "local" view of the resource (its mutable/editable state), a "remote" view
- * (its last-known-persisted state), or both.
- *
- * Each view subscribes to its own channel and, when notified, re-pulls its own
- * projection of the data: a remote-only reader (e.g. PolarisMode's default
- * immutable record) subscribes `'remote'` and re-reads remote state; an
- * editable/reconciled reader (a legacy record, or an editable checkout)
- * subscribes `'local'` (the same as omitting the channel) and re-reads local
- * state. A notifier that knows which projection changed tags the notification
- * with that channel; each tag is delivered only to that channel's subscribers.
- * A change affecting both projections is either notified unscoped or once per
- * channel. An unscoped notify cannot guarantee which view changed, so it
- * reaches every subscriber -- this keeps every pre-channel `notify` callsite
- * (and any custom cache that doesn't know about channels) fully compatible.
- *
- * The full delivery matrix:
- *
- * | notify ↓ subscribe → | `'local'` | `'remote'` | omitted (= `'local'`) |
- * | -------------------- | --------- | ---------- | --------------------- |
- * | `'local'`            | ✅        | ❌         | ✅                    |
- * | `'remote'`           | ❌        | ✅         | ❌                    |
- * | omitted              | ✅        | ✅         | ✅                    |
- *
- * Channel only applies to the `'attributes'` and `'relationships'`
- * notification types. All other types (`'errors'`,
- * `'identity'`, `'state'`, and the various `CacheOperation`/
- * `DocumentCacheOperation` values) are never filtered by channel since they
- * have no local/remote duality.
- *
- * @public
- */
-type NotificationChannel = "local" | "remote";
-interface NotificationCallback$1 {
-  (cacheKey: ResourceKey, notificationType: "attributes" | "relationships", key?: string): void;
-  (cacheKey: ResourceKey, notificationType: "errors" | "meta" | "identity" | "state"): void;
-  (cacheKey: ResourceKey, notificationType: CacheOperation$1): void;
-}
-interface ResourceOperationCallback$1 {
-  (cacheKey: ResourceKey, notificationType: CacheOperation$1): void;
-}
-interface DocumentOperationCallback$1 {
-  (cacheKey: RequestKey, notificationType: DocumentCacheOperation$1): void;
-}
-/**
- * The NotificationManager provides the ability to subscribe to
- * changes to Cache state.
- *
- * This Feature is what allows WarpDrive to create subscriptions that
- * work with any framework or change-notification system.
- *
- * @hideconstructor
- * @public
- */
-declare class NotificationManager$1 {
-  constructor(store: Store$1);
+   * If `true`, forces the request to go to the adapter even if a cached
+   * copy of the requested resource(s) already exists in the store. If
+   * omitted, the adapter's `shouldReloadRecord`/`shouldReloadAll` hook
+   * decides whether to reload.
+   */
+  reload?: boolean;
   /**
-   * Subscribe to changes for a given ResourceKey, RequestKey, or addition/removal of any resource
-   * or document.
-   *
-   * ```ts
-   * export type CacheOperation = 'added' | 'removed' | 'updated' | 'state';
-   *
-   * export interface NotificationCallback {
-   *   (cacheKey: ResourceKey, notificationType: 'attributes' | 'relationships', key?: string): void;
-   *   (cacheKey: ResourceKey, notificationType: 'errors' | 'meta' | 'identity' | 'state'): void;
-   *   (cacheKey: ResourceKey, notificationType: NotificationType, key?: string): void;
-   * }
-   * export interface ResourceOperationCallback {
-   *   // resource updates
-   *   (cacheKey: ResourceKey, notificationType: CacheOperation): void;
-   * }
-   * export interface DocumentOperationCallback {
-   *   // document updates
-   *   (cacheKey: RequestKey, notificationType: CacheOperation): void;
-   * }
-   * ```
-   *
-   * A `channel` may be provided when subscribing to a `ResourceKey`. Its
-   * effect is that the subscription skips `'attributes'`/`'relationships'`
-   * notifications explicitly tagged with the *other* channel; unscoped
-   * notifications, and notifications for all other notification types, always
-   * reach the subscriber. Subscribing `'local'` and omitting the channel are
-   * the same thing. See {@link NotificationChannel}.
-   *
-   * | notify ↓ subscribe → | `'local'` | `'remote'` | omitted (= `'local'`) |
-   * | -------------------- | --------- | ---------- | --------------------- |
-   * | `'local'`            | ✅        | ❌         | ✅                    |
-   * | `'remote'`           | ❌        | ✅         | ❌                    |
-   * | omitted              | ✅        | ✅         | ✅                    |
-   *
-   * @public
-   * @return an opaque token to be used with unsubscribe
+   * If `true` or `false`, forces or prevents a background reload of the
+   * cached resource(s) after resolving with the cached data. If omitted,
+   * the adapter's `shouldBackgroundReloadRecord`/`shouldBackgroundReloadAll`
+   * hook decides whether to reload in the background.
    */
-  subscribe(cacheKey: ResourceKey, callback: NotificationCallback$1, channel?: NotificationChannel): UnsubscribeToken$1;
-  subscribe(cacheKey: "resource", callback: ResourceOperationCallback$1): UnsubscribeToken$1;
-  subscribe(cacheKey: "document" | RequestKey, callback: DocumentOperationCallback$1): UnsubscribeToken$1;
+  backgroundReload?: boolean;
   /**
-   * remove a previous subscription
-   *
-   * @public
+   * The names of relationships to load along with this request, used to
+   * build the `include` query parameter for adapters (such as the
+   * JSON:API adapter) that support it.
    */
-  unsubscribe(token: UnsubscribeToken$1): void;
+  include?: string | string[];
   /**
-   * Custom Caches and Application Code should not call this method directly.
-   *
-   * When notifying `'attributes'` or `'relationships'` for many keys on the
-   * same `cacheKey` at once (for instance, when a bulk update to a single
-   * record touches many fields) `key` may be supplied as a `Set<string>`
-   * instead of being called once per key. The `Set` is iterated as-is (it is
-   * never converted to or from an array internally). This delivers the
-   * exact same sequence of individual notifications to subscribers (each
-   * subscriber callback is still invoked once per key, in order) while
-   * paying the per-call overhead (validity checks, subscriber lookups,
-   * buffer/flush scheduling) only once for the whole batch instead of once
-   * per key.
-   *
-   * A `channel` may be supplied for the `'attributes'`/`'relationships'`
-   * namespaces. Tagging a notification `'local'` declares "only the local
-   * (reconciled/editable) view changed"; tagging it `'remote'` declares "only
-   * the remote view changed". Each tag is delivered only to that channel's
-   * subscribers. Omitting the channel reaches every subscriber regardless of
-   * its channel. See {@link NotificationChannel}.
-   *
-   * | notify ↓ subscribe → | `'local'` | `'remote'` | omitted (= `'local'`) |
-   * | -------------------- | --------- | ---------- | --------------------- |
-   * | `'local'`            | ✅        | ❌         | ✅                    |
-   * | `'remote'`           | ❌        | ✅         | ❌                    |
-   * | omitted              | ✅        | ✅         | ✅                    |
-   *
-   * @private
+   * Arbitrary options made available to the adapter via the request's
+   * snapshot (`snapshot.adapterOptions`). The store does not interpret
+   * this value itself.
    */
-  notify(cacheKey: ResourceKey, value: "attributes" | "relationships", key?: string | NotifyKeys | null, channel?: NotificationChannel): boolean;
-  notify(cacheKey: ResourceKey, value: "errors" | "meta" | "identity" | "state", key?: null): boolean;
-  notify(cacheKey: ResourceKey, value: CacheOperation$1, key?: null): boolean;
-  notify(cacheKey: RequestKey, value: DocumentCacheOperation$1, key?: null): boolean;
+  adapterOptions?: Record<string, unknown>;
 }
 /**
- * This type exists for internal use only for
- * where intimate contracts still exist either for
- * the Test Suite or for Legacy code.
+ * Options for `store.findRecord()`.
  *
- * @private
+ * @summary Legacy options for `store.findRecord`, adding a discouraged `preload` of field values to the shared
+ * reload and adapter settings.
  */
-interface PrivateNotificationManager extends NotificationManager$1 {
-  _flush(): void;
-}
-//#endregion
-//#region src/store/deprecated/-private.d.ts
-interface BaseFinderOptions$1 {
-  reload?: boolean;
-  backgroundReload?: boolean;
-  include?: string | string[];
-  adapterOptions?: Record<string, unknown>;
-}
-interface FindRecordOptions$1 extends BaseFinderOptions$1 {
+interface FindRecordOptions extends BaseFinderOptions {
   /**
    * Data to preload into the store before the request is made.
    * This feature is *highly* discouraged and has no corresponding
@@ -1803,315 +1723,62 @@ interface FindRecordOptions$1 extends BaseFinderOptions$1 {
    */
   preload?: Record<string, Value>;
 }
-type QueryOptions$1 = { [K in string | "adapterOptions"]?: K extends "adapterOptions" ? Record<string, unknown> : unknown; };
-type FindAllOptions$1 = BaseFinderOptions$1;
-type LegacyResourceQuery$1 = {
+/**
+ * Options for `store.query()` and `store.queryRecord()`. Unlike
+ * {@link LegacyResourceQuery}, these options are not sent to the server;
+ * only `adapterOptions` is recognized by the store, and it is passed
+ * through to `adapter.query`/`adapter.queryRecord` via the request snapshot.
+ *
+ * @summary Legacy options for `store.query` and `store.queryRecord`, of which only `adapterOptions` is used, passed
+ * to the adapter rather than the server.
+ */
+type QueryOptions = { [K in string | "adapterOptions"]?: K extends "adapterOptions" ? Record<string, unknown> : unknown; };
+/**
+ * Options for `store.findAll()`.
+ *
+ * @summary Legacy reload, background-reload, include, and adapterOptions settings for `store.findAll`.
+ */
+type FindAllOptions = BaseFinderOptions;
+/**
+ * An opaque query object for `store.query()` and `store.queryRecord()`
+ * that is passed as-is to the adapter, which is responsible for turning
+ * it into request query parameters.
+ *
+ * @summary Legacy query object for `store.query` and `store.queryRecord` that the adapter turns into request query
+ * params, with an optional `include`.
+ */
+type LegacyResourceQuery = {
+  /**
+   * The names of relationships to load along with this query, used to
+   * build the `include` query parameter for adapters (such as the
+   * JSON:API adapter) that support it.
+   */
   include?: string | string[];
   [key: string]: Value | undefined;
 };
-type KeyOrString<T> = keyof T & string extends never ? string : keyof T & string;
 /**
- * Minimum subset of static schema methods and properties on the
- * "model" class.
+ * Extensions allow providing non-schema driven behaviors to
+ * ReactiveResources, ReactiveArrays, and ReactiveObjects.
  *
- * Only used when using the legacy schema-service implementation
- * for @warp-drive-mirror/legacy/model or when wrapping schema for legacy
- * Adapters/Serializers.
+ * This should only be used for temporary migration purposes
+ * to the new schema system when migrating from either Model
+ * or ModelFragments.
  *
+ * @summary Registers named methods, getters, and values to add to ReactiveResources, ReactiveObjects,
+ * or ReactiveArrays; meant only as a temporary aid when migrating from Model or ModelFragments.
  */
-interface ModelSchema<T = unknown> {
-  /**
-   * The resource type (model name) that this schema describes.
-   */
-  modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
-  /**
-   * A map of every field defined on this resource type to its kind
-   * (`'attribute'`, `'belongsTo'`, or `'hasMany'`).
-   */
-  fields: Map<KeyOrString<T>, "attribute" | "belongsTo" | "hasMany">;
+interface CAUTION_MEGA_DANGER_ZONE_Extension {
   /**
-   * A map of every attribute field defined on this resource type, keyed by
-   * attribute name.
+   * Whether this extension extends the behaviors of objects
+   * (both ReactiveObjects and ReactiveResources) or of arrays.
    */
-  attributes: Map<KeyOrString<T>, LegacyAttributeField>;
+  kind: "object" | "array";
   /**
-   * A map of every relationship (`belongsTo`/`hasMany`) field defined on this
-   * resource type, keyed by relationship name.
+   * The name of the extension, to be used when specifying
+   * either `objectExtensions` or `arrayExtensions` on the
+   * field, ResourceSchema or ObjectSchema
    */
-  relationshipsByName: Map<KeyOrString<T>, LegacyRelationshipField>;
-  /**
-   * Invokes `callback` once for each attribute field defined on this resource
-   * type, passing the attribute's key and schema.
-   */
-  eachAttribute<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, attribute: LegacyAttributeField) => void, binding?: T): void;
-  /**
-   * Invokes `callback` once for each relationship field defined on this
-   * resource type, passing the relationship's key and schema.
-   */
-  eachRelationship<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, relationship: LegacyRelationshipField) => void, binding?: T): void;
-  /**
-   * Invokes `callback` once for each attribute field defined on this resource
-   * type that has a transform (a `type`), passing the attribute's key and the
-   * name of the transform to apply.
-   */
-  eachTransformedAttribute<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, type: string | null) => void, binding?: T): void;
-}
-/**
-A `RecordReference` is a low-level API that allows users and
-addon authors to perform meta-operations on a record.
-
-@hideconstructor
-@public
-*/
-declare class RecordReference {
-  constructor(store: Store$1, identifier: ResourceKey);
-  get type(): string;
-  /**
-	The `id` of the record that this reference refers to.
-	
-	Together, the `type` and `id` properties form a composite key for
-	the identity map.
-	
-	Example
-	
-	```javascript
-	let userRef = store.getReference('user', 1);
-	
-	userRef.id(); // '1'
-	```
-	
-	@public
-	@return The id of the record.
-	*/
-  id(): string | null;
-  /**
-	The `identifier` of the record that this reference refers to.
-	
-	Together, the `type` and `id` properties form a composite key for
-	the identity map.
-	
-	Example
-	
-	```javascript
-	let userRef = store.getReference('user', 1);
-	
-	userRef.identifier(); // '1'
-	```
-	
-	@public
-	@return The identifier of the record.
-	*/
-  identifier(): ResourceKey;
-  /**
-	How the reference will be looked up when it is loaded. Currently
-	this always returns `identity` to signify that a record will be
-	loaded by its `type` and `id`.
-	
-	Example
-	
-	```javascript
-	const userRef = store.getReference('user', 1);
-	
-	userRef.remoteType(); // 'identity'
-	```
-	
-	@public
-	*/
-  remoteType(): "identity";
-  /**
-	This API allows you to provide a reference with new data. The
-	simplest usage of this API is similar to `store.push`: you provide a
-	normalized hash of data and the object represented by the reference
-	will update.
-	
-	If you pass a promise to `push`, WarpDrive will not ask the adapter
-	for the data if another attempt to fetch it is made in the
-	interim. When the promise resolves, the underlying object is updated
-	with the new data, and the promise returned by *this function* is resolved
-	with that object.
-	
-	For example, `recordReference.push(promise)` will be resolved with a
-	record.
-	
-	Example
-	
-	```javascript
-	let userRef = store.getReference('user', 1);
-	
-	// provide data for reference
-	userRef.push({
-	data: {
-	id: "1",
-	type: "user",
-	attributes: {
-	username: "@user"
-	}
-	}
-	}).then(function(user) {
-	userRef.value() === user;
-	});
-	```
-	
-	@public
-	@param objectOrPromise a JSON:API ResourceDocument or a promise resolving to one
-	@return a promise for the value (record or relationship)
-	*/
-  push(objectOrPromise: SingleResourceDocument | Promise<SingleResourceDocument>): Promise<OpaqueRecordInstance$1>;
-  /**
-	If the entity referred to by the reference is already loaded, it is
-	present as `reference.value`. Otherwise the value returned by this function
-	is `null`.
-	
-	Example
-	
-	```javascript
-	let userRef = store.getReference('user', 1);
-	
-	userRef.value(); // user
-	```
-	
-	@public
-	@return the record for this RecordReference
-	*/
-  value(): OpaqueRecordInstance$1 | null;
-  /**
-	Triggers a fetch for the backing entity based on its `remoteType`
-	(see `remoteType` definitions per reference type).
-	
-	Example
-	
-	```javascript
-	let userRef = store.getReference('user', 1);
-	
-	// load user (via store.find)
-	userRef.load().then(...)
-	```
-	
-	@public
-	@return the record for this RecordReference
-	*/
-  load(): Promise<unknown>;
-  /**
-	Reloads the record if it is already loaded. If the record is not
-	loaded it will load the record via `store.findRecord`
-	
-	Example
-	
-	```javascript
-	let userRef = store.getReference('user', 1);
-	
-	// or trigger a reload
-	userRef.reload().then(...)
-	```
-	
-	@public
-	@return the record for this RecordReference
-	*/
-  reload(): Promise<unknown>;
-}
-//#endregion
-//#region src/store/-types/q/store.d.ts
-/**
- * Options shared by {@link FindRecordOptions} and {@link FindAllOptions}
- * for controlling reload behavior and adapter/serializer specific
- * configuration when using the legacy Adapter/Serializer network layer.
- */
-interface BaseFinderOptions {
-  /**
-   * If `true`, forces the request to go to the adapter even if a cached
-   * copy of the requested resource(s) already exists in the store. If
-   * omitted, the adapter's `shouldReloadRecord`/`shouldReloadAll` hook
-   * decides whether to reload.
-   */
-  reload?: boolean;
-  /**
-   * If `true` or `false`, forces or prevents a background reload of the
-   * cached resource(s) after resolving with the cached data. If omitted,
-   * the adapter's `shouldBackgroundReloadRecord`/`shouldBackgroundReloadAll`
-   * hook decides whether to reload in the background.
-   */
-  backgroundReload?: boolean;
-  /**
-   * The names of relationships to load along with this request, used to
-   * build the `include` query parameter for adapters (such as the
-   * JSON:API adapter) that support it.
-   */
-  include?: string | string[];
-  /**
-   * Arbitrary options made available to the adapter via the request's
-   * snapshot (`snapshot.adapterOptions`). The store does not interpret
-   * this value itself.
-   */
-  adapterOptions?: Record<string, unknown>;
-}
-/**
- * Options for `store.findRecord()`.
- */
-interface FindRecordOptions extends BaseFinderOptions {
-  /**
-   * Data to preload into the store before the request is made.
-   * This feature is *highly* discouraged and has no corresponding
-   * feature when using builders and handlers.
-   *
-   * Excepting relationships: the data should be in the form of a
-   * JSON object where the keys are fields on the record and the value
-   * is the raw value to be added to the cache.
-   *
-   * Relationships can either be provided as string IDs from which
-   * an identifier will be built base upon the relationship's expected
-   * resource type, or be record instances from which the identifier
-   * will be extracted.
-   *
-   */
-  preload?: Record<string, Value>;
-}
-/**
- * Options for `store.query()` and `store.queryRecord()`. Unlike
- * {@link LegacyResourceQuery}, these options are not sent to the server;
- * only `adapterOptions` is recognized by the store, and it is passed
- * through to `adapter.query`/`adapter.queryRecord` via the request snapshot.
- */
-type QueryOptions = { [K in string | "adapterOptions"]?: K extends "adapterOptions" ? Record<string, unknown> : unknown; };
-/**
- * Options for `store.findAll()`.
- */
-type FindAllOptions = BaseFinderOptions;
-/**
- * An opaque query object for `store.query()` and `store.queryRecord()`
- * that is passed as-is to the adapter, which is responsible for turning
- * it into request query parameters.
- */
-type LegacyResourceQuery = {
-  /**
-   * The names of relationships to load along with this query, used to
-   * build the `include` query parameter for adapters (such as the
-   * JSON:API adapter) that support it.
-   */
-  include?: string | string[];
-  [key: string]: Value | undefined;
-};
-//#endregion
-//#region src/reactive/-private/schema.d.ts
-/**
- * Extensions allow providing non-schema driven behaviors to
- * ReactiveResources, ReactiveArrays, and ReactiveObjects.
- *
- * This should only be used for temporary migration purposes
- * to the new schema system when migrating from either Model
- * or ModelFragments.
- */
-interface CAUTION_MEGA_DANGER_ZONE_Extension {
-  /**
-   * Whether this extension extends the behaviors of objects
-   * (both ReactiveObjects and ReactiveResources) or of arrays.
-   */
-  kind: "object" | "array";
-  /**
-   * The name of the extension, to be used when specifying
-   * either `objectExtensions` or `arrayExtensions` on the
-   * field, ResourceSchema or ObjectSchema
-   */
-  name: string;
+  name: string;
   /**
    * An object with iterable keys whose values are the getters
    * or methods to expose on the object or array.
@@ -2195,6 +1862,9 @@ interface CAUTION_MEGA_DANGER_ZONE_Extension {
  * Describes one feature added to a resource by a schema extension, as
  * classified by {@link processExtension} from the property descriptor it
  * was declared with (a method, a plain value, or a getter/setter pair).
+ *
+ * @summary One normalized feature of a schema extension, tagged by kind as a method, a readonly or
+ * mutable value, or a getter/setter accessor.
  */
 type ExtensionDef = {
   /** A callable feature, installed as a method. */
@@ -2233,6 +1903,9 @@ type ExtensionDef = {
  * The result of {@link processExtension} normalizing a
  * {@link CAUTION_MEGA_DANGER_ZONE_Extension} into a lookup of its features
  * by name.
+ *
+ * @summary A registered schema extension normalized into its kind, name, and a map of its features
+ * keyed by property name.
  */
 interface ProcessedExtension {
   /** Whether this extension applies to objects/resources or to arrays. */
@@ -2262,14 +1935,19 @@ interface ExtensibleField {
  * Utility for constructing a ResourceSchema with the recommended
  * fields for the PolarisMode experience.
  *
+ * The [ResourceSchemas](/guides/the-manual/schemas/resources/) guide shows how to
+ * create a schema with it.
+ *
  * Using this requires registering the PolarisMode derivations
  *
  * ```ts
- * import { registerDerivations } from '@warp-drive-mirror/schema-record';
+ * import { registerDerivations } from '@warp-drive-mirror/core/reactive';
  *
  * registerDerivations(schema);
  * ```
  *
+ * @summary Adds the default `id` identity plus `$key`, `$type`, and `constructor` derived fields to a
+ * PolarisMode resource schema.
  * @public
  * @param schema
  * @return {PolarisResourceSchema}
@@ -2312,6 +1990,8 @@ interface FromIdentityDerivation {
  *
  * `^` returns the entire identifier object.
  *
+ * @summary The `@identity` derivation, which reads a record's `id`, `lid`, `type`, or whole resource key
+ * for use in derived fields.
  * @public
  */
 declare const fromIdentity: FromIdentityDerivation;
@@ -2320,9 +2000,14 @@ declare const fromIdentity: FromIdentityDerivation;
  * to use the PolarisMode defaults provided by
  *
  * ```ts
- * import { withDefaults } from '@warp-drive-mirror/schema-record';
+ * import { withDefaults } from '@warp-drive-mirror/core/reactive';
  * ```
  *
+ * The [Derivations](/guides/the-manual/schemas/derivations#about-built-in-derivations)
+ * guide explains when you need to call it.
+ *
+ * @summary Registers the `@identity` and `@constructor` derivations that schemas built with
+ * `withDefaults` depend on.
  * @public
  */
 declare function registerDerivations(schema: SchemaService): void;
@@ -2339,6 +2024,9 @@ interface InternalSchema {
  * Defines how to convert a `GenericField`, `ObjectField`, or `ArrayField`
  * between the raw value `T` stored in the cache and the presentation value
  * `PT` exposed on the record.
+ *
+ * @summary A registered converter between a field's raw cache value and the value exposed on the
+ * record, with optional default.
  */
 type Transformation<T extends Value = Value, PT = unknown> = {
   /** Converts the presentation value into the raw value to store in the cache. */
@@ -2362,6 +2050,12 @@ interface SchemaService$1 {
 /**
  * A SchemaService designed to work with dynamically registered schemas.
  *
+ * The [Schemas](/guides/the-manual/schemas/) guide shows how to register schemas
+ * with it, and [Advanced Store Configuration](/guides/configuration/advanced#add-a-source-for-schema-for-your-data)
+ * shows how to give a store one.
+ *
+ * @summary The default schema service, which stores resource and object schemas, traits, derivations,
+ * transformations, hash functions and extensions registered at runtime.
  * @public
  */
 declare class SchemaService$1 implements SchemaService {
@@ -2443,13 +2137,13 @@ declare class SchemaService$1 implements SchemaService {
     type: string;
   }): boolean;
 }
-//#endregion
-//#region src/types/schema/schema-service.d.ts
 /**
  * A dictionary of {@link LegacyAttributeField} definitions keyed by
  * attribute name, as returned by the deprecated
  * {@link SchemaService.attributesDefinitionFor | attributesDefinitionFor} hook.
  *
+ * @summary Legacy attribute field definitions keyed by attribute name, returned by the deprecated
+ * `attributesDefinitionFor` schema hook.
  * @public
  */
 type AttributesSchema = Record<string, LegacyAttributeField>;
@@ -2458,6 +2152,8 @@ type AttributesSchema = Record<string, LegacyAttributeField>;
  * relationship name, as returned by the deprecated
  * {@link SchemaService.relationshipsDefinitionFor | relationshipsDefinitionFor} hook.
  *
+ * @summary Legacy relationship field definitions keyed by relationship name, returned by the deprecated
+ * `relationshipsDefinitionFor` schema hook.
  * @public
  */
 type RelationshipsSchema = Record<string, LegacyRelationshipField>;
@@ -2468,6 +2164,10 @@ interface ObjectWithStringTypeProperty {
  * The SchemaService provides the ability to query for information about the structure
  * of any resource type.
  *
+ * The [Schemas](/guides/the-manual/schemas/) guide shows how to register schemas
+ * with it, and [Advanced Store Configuration](/guides/configuration/advanced#add-a-source-for-schema-for-your-data)
+ * shows how to give a store one.
+ *
  * Applications can provide any implementation of the SchemaService they please so long
  * as it conforms to this interface.
  *
@@ -2512,6 +2212,8 @@ interface ObjectWithStringTypeProperty {
  * }
  * ```
  *
+ * @summary The contract a store's schema service implements to answer which resource types, traits, fields,
+ * transformations, and derivations exist.
  * @public
  */
 interface SchemaService {
@@ -2535,301 +2237,828 @@ interface SchemaService {
    *
    * @public
    */
-  hasTrait(type: string): boolean;
+  hasTrait(type: string): boolean;
+  /**
+   * Queries whether the given resource has the given trait
+   *
+   * @public
+   */
+  resourceHasTrait(resource: ObjectWithStringTypeProperty | ResourceKey, trait: string): boolean;
+  /**
+   * Queries for the fields of a given resource type or resource identity.
+   *
+   * Should error if the resource type is not recognized.
+   *
+   * @public
+   */
+  fields(resource: ObjectWithStringTypeProperty | ResourceKey): Map<string, FieldSchema>;
+  /**
+   * Queries for the fields of a given resource type or resource identity.
+   *
+   * Should error if the resource type is not recognized.
+   *
+   * @public
+   */
+  cacheFields?(resource: ObjectWithStringTypeProperty | ResourceKey): Map<string, Exclude<CacheableFieldSchema, IdentityField>>;
+  /**
+   * Returns the transformation registered with the name provided
+   * by `field.type`. Validates that the field is a valid transformable.
+   *
+   * @public
+   */
+  transformation(field: GenericField | ObjectField | ArrayField | ObjectWithStringTypeProperty): Transformation$1;
+  /**
+   * Returns the hash function registered with the name provided
+   * by `field.type`. Validates that the field is a valid HashField.
+   *
+   * @public
+   */
+  hashFn(field: HashField | ObjectWithStringTypeProperty): HashFn;
+  /**
+   * Returns the derivation registered with the name provided
+   * by `field.type`. Validates that the field is a valid DerivedField.
+   *
+   * @public
+   */
+  derivation(field: DerivedField | ObjectWithStringTypeProperty): Derivation;
+  /**
+   * Returns the schema for the provided resource type.
+   *
+   * @public
+   */
+  resource(resource: ObjectWithStringTypeProperty | ResourceKey): Schema;
+  /**
+   * Enables registration of multiple Schemas at once.
+   *
+   * This can be useful for either pre-loading schema information
+   * or for registering schema information delivered by API calls
+   * or other sources just-in-time.
+   *
+   * @public
+   */
+  registerResources(schemas: Schema[]): void;
+  /**
+   * Enables registration of a single Schema representing either
+   * a resource in PolarisMode or LegacyMode or an ObjectSchema
+   * representing an embedded structure in other schemas.
+   *
+   * This can be useful for either pre-loading schema information
+   * or for registering schema information delivered by API calls
+   * or other sources just-in-time.
+   *
+   * @public
+   */
+  registerResource(schema: Schema): void;
+  /**
+   * Enables registration of a transformation.
+   *
+   * The transformation can later be retrieved by the name
+   * attached to it's `[Type]` property.
+   *
+   * @public
+   */
+  registerTransformation(transform: Transformation$1): void;
+  /**
+   * Enables registration of a derivation.
+   *
+   * The derivation can later be retrieved by the name
+   * attached to it's `[Type]` property.
+   *
+   * @public
+   */
+  registerDerivation<R, T, FM extends ObjectValue | null>(derivation: Derivation<R, T, FM>): void;
+  /**
+   * Enables registration of a hashing function
+   *
+   * The hashing function can later be retrieved by the name
+   * attached to it's `[Type]` property.
+   *
+   * @public
+   */
+  registerHashFn(hashFn: HashFn): void;
+  /**
+   * Registers a {@link Trait} for use by resource schemas.
+   *
+   * Traits are re-usable collections of fields that can be composed to
+   * build up a resource schema. Often they represent polymorphic behaviors
+   * a resource should exhibit.
+   *
+   * When we finalize a resource, we walk its traits and apply their fields
+   * to the resource's fields. All specified traits must be registered by
+   * this time or an error will be thrown.
+   *
+   * Traits are applied left-to-right, with traits of traits being applied in the same
+   * way. Thus for the most part, application of traits is a post-order graph traversal
+   * problem.
+   *
+   * A trait is only ever processed once. If multiple traits (A, B, C) have the same
+   * trait (D) as a dependency, D will be included only once when first encountered by
+   * A.
+   *
+   * If a cycle exists such that trait A has trait B which has Trait A, trait A will
+   * be applied *after* trait B in production. In development a cycle error will be thrown.
+   *
+   * Fields are finalized on a "last wins principle". Thus traits appearing higher in
+   * the tree and further to the right of a traits array take precedence, with the
+   * resource's fields always being applied last and winning out.
+   *
+   * @public
+   */
+  registerTrait?(trait: Trait): void;
+  /**
+   * DEPRECATED - use `fields` instead
+   *
+   * Returns definitions for all properties of the specified resource
+   * that are considered "attributes". Generally these are properties
+   * that are not related to book-keeping state on the client and do
+   * not represent a linkage to another resource.
+   *
+   * The return value should be a dictionary of key:value pairs
+   * where the `key` is the attribute or property's name and `value`
+   * is an object with at least the property `name` which should also
+   * match `key`.
+   *
+   * Optionally, this object may also specify `type`, which should
+   * be a string reference to a `transform`, and `options` which
+   * should be dictionary in which any key:value pairs are permissable.
+   *
+   * For instance, when using `@warp-drive-mirror/legacy/model`, the following attribute
+   * definition:
+   *
+   * ```ts
+   * class extends Model {
+   *   @attr('string', { defaultValue: 'hello' }) greeting;
+   *   @attr('date') birthday;
+   *   @attr firstName;
+   * }
+   * ```
+   *
+   * Would be returned as:
+   *
+   * ```js
+   * {
+   *   greeting: { name: 'greeting', type: 'string', options: { defaultValue: 'hello' } },
+   *   birthday: { name: 'birthday', type: 'date' },
+   *   firstName: { name: 'firstName' }
+   * }
+   * ```
+   *
+   * @public
+   * @deprecated - use {@link SchemaService.fields | fields}
+   */
+  attributesDefinitionFor?(key: ResourceKey | ObjectWithStringTypeProperty): AttributesSchema;
+  /**
+   * DEPRECATED - use `fields` instead
+   *
+   * Returns definitions for all properties of the specified resource
+   * that are considered "relationships". Generally these are properties
+   * that represent a linkage to another resource.
+   *
+   * The return value should be a dictionary of key:value pairs
+   * where the `key` is the relationship or property's name and `value`
+   * is an object with at least the following properties:
+   *
+   * - `name` which should also match the `key` used in the dictionary.
+   * - `kind` which should be either `belongsTo` or `hasMany`
+   * - `type` which should be the related resource's string "type"
+   * - `options` which should be a dictionary allowing any key but with
+   *    at least the below keys present.
+   *
+   * - `options.async` a boolean representing whether data for this relationship is
+   *      typically loaded on-demand.
+   * - `options.inverse` a string or null representing the field name / key of the
+   *       corresponding relationship on the inverse resource.
+   *
+   * Additionally the following options properties are optional. See [Polymorphic Relationships](https://rfcs.emberjs.com/id/0793-polymporphic-relations-without-inheritance)
+   *
+   * - `options.polymorphic` a boolean representing whether multiple resource types
+   *    can be used to satisfy this relationship.
+   * - `options.as` a string representing the abstract type that the concrete side of
+   *    a relationship must specify when fulfilling a polymorphic inverse.
+   *
+   * For example, the following Model using @warp-drive-mirror/legacy/model would generate this relationships
+   * definition by default:
+   *
+   * ```js
+   * class User extends Model {
+   *   @belongsTo('user', { async: false, inverse: null }) bestFriend;
+   *   @hasMany('user', { async: true, inverse: 'friends' }) friends;
+   *   @hasMany('pet', { async: false, polymorphic: true, inverse: 'owner' }) pets;
+   * }
+   * ```
+   *
+   * Which would be returned as
+   *
+   * ```js
+   * {
+   *   bestFriend: {
+   *     name: 'bestFriend',
+   *     kind: 'belongsTo',
+   *     type: 'user',
+   *     options: {
+   *       async: false,
+   *       inverse: null
+   *     }
+   *   },
+   *   friends: {
+   *     name: 'friends',
+   *     kind: 'hasMany',
+   *     type: 'user',
+   *     options: {
+   *       async: true,
+   *       inverse: 'friends'
+   *     }
+   *   },
+   *   pets: {
+   *     name: 'pets',
+   *     kind: 'hasMany',
+   *     type: 'pet',
+   *     options: {
+   *       async: false,
+   *       polymorphic: true,
+   *       inverse: 'owner'
+   *     }
+   *   },
+   * }
+   * ```
+   *
+   * @public
+   * @deprecated - use {@link SchemaService.fields | fields}
+   */
+  relationshipsDefinitionFor?(key: ResourceKey | ObjectWithStringTypeProperty): RelationshipsSchema;
   /**
-   * Queries whether the given resource has the given trait
+   * Returns all known resource types
    *
    * @public
    */
-  resourceHasTrait(resource: ObjectWithStringTypeProperty | ResourceKey, trait: string): boolean;
+  resourceTypes(): Readonly<string[]>;
   /**
-   * Queries for the fields of a given resource type or resource identity.
+   * Register an extension for either objects or arrays
    *
-   * Should error if the resource type is not recognized.
+   * See also {@link CAUTION_MEGA_DANGER_ZONE_Extension}
    *
    * @public
    */
-  fields(resource: ObjectWithStringTypeProperty | ResourceKey): Map<string, FieldSchema>;
+  CAUTION_MEGA_DANGER_ZONE_registerExtension?(extension: CAUTION_MEGA_DANGER_ZONE_Extension): void;
   /**
-   * Queries for the fields of a given resource type or resource identity.
-   *
-   * Should error if the resource type is not recognized.
+   * Retrieve the extension map for a resource
    *
    * @public
    */
-  cacheFields?(resource: ObjectWithStringTypeProperty | ResourceKey): Map<string, Exclude<CacheableFieldSchema, IdentityField>>;
+  CAUTION_MEGA_DANGER_ZONE_resourceExtensions?(resource: ResourceKey | {
+    type: string;
+  }): null | ProcessedExtension["features"];
   /**
-   * Returns the transformation registered with the name provided
-   * by `field.type`. Validates that the field is a valid transformable.
+   * Retrieve the extension map for an object field
    *
    * @public
    */
-  transformation(field: GenericField | ObjectField | ArrayField | ObjectWithStringTypeProperty): Transformation$1;
+  CAUTION_MEGA_DANGER_ZONE_objectExtensions?(field: ExtensibleField, resolvedType: string | null): null | ProcessedExtension["features"];
   /**
-   * Returns the hash function registered with the name provided
-   * by `field.type`. Validates that the field is a valid HashField.
+   * Retrieve the extension map for an array field
    *
    * @public
    */
-  hashFn(field: HashField | ObjectWithStringTypeProperty): HashFn;
+  CAUTION_MEGA_DANGER_ZONE_arrayExtensions?(field: ExtensibleField): null | ProcessedExtension["features"];
   /**
-   * Returns the derivation registered with the name provided
-   * by `field.type`. Validates that the field is a valid DerivedField.
+   * Check if a specific extension has been registered previously
    *
    * @public
    */
-  derivation(field: DerivedField | ObjectWithStringTypeProperty): Derivation;
+  CAUTION_MEGA_DANGER_ZONE_hasExtension?(ext: {
+    kind: "object" | "array";
+    name: string;
+  }): boolean;
+}
+type TypeFromIdentifier<T> = T extends {
+  type: infer U;
+} ? U : string;
+type NarrowIdentifierIfPossible<T> = T extends ExistingResourceIdentifierObject ? PersistedResourceKey<TypeFromIdentifier<T>> : ResourceKey;
+/**
+ * Type-guard that returns `true` if the given value is a stable {@link ResourceKey}
+ * (as opposed to a {@link RequestKey} or arbitrary, not-yet-stabilized resource data).
+ */
+declare function isResourceKey(identifier: unknown): identifier is ResourceKey;
+/**
+ * Type-guard that returns `true` if the given value is a stable {@link RequestKey}
+ * (as opposed to a {@link ResourceKey} or arbitrary, not-yet-stabilized data).
+ */
+declare function isRequestKey(identifier: unknown): identifier is RequestKey;
+/**
+ * The identity of a field's value, as returned by {@link fieldValueIdentity}.
+ * Today only schema-object values (a `schema-object` field, or one element of
+ * a `schema-array`) have one: the concrete schema-object type the value
+ * resolves to, and the identity hash that type's `ObjectSchema` declares for
+ * it, or `null` when the schema declares `identity: null`.
+ */
+interface FieldValueIdentity {
+  type: string;
+  hash: string | null;
+}
+/**
+ * The identity of `value` as a value of `field`, when the field kind has one.
+ *
+ * A `schema-object` value, or one element of a `schema-array`, resolves to its
+ * concrete schema-object type and the identity hash that type's `ObjectSchema`
+ * declares (`null` when the schema declares `identity: null`). A
+ * non-polymorphic field names the type directly; a polymorphic field reads it
+ * off the value at `options.type` (default `'type'`), or computes it with the
+ * hash function named by `field.type` when `options.type` is `'@hash'`.
+ *
+ * Every other field kind, and any non-object value, has no identity and
+ * returns `null`.
+ */
+declare function fieldValueIdentity(schema: SchemaService, field: FieldSchema, value: unknown): FieldValueIdentity | null;
+interface KeyOptions {
+  lid: IdentifierMap;
+  id: IdentifierMap;
+}
+type TypeMap = {
+  [key: string]: KeyOptions;
+};
+type IdentifierMap = Map<string, ResourceKey>;
+type StableCache = {
+  resources: IdentifierMap;
+  documents: Map<string, RequestKey>;
+  resourcesByType: TypeMap;
+  polymorphicLidBackMap: Map<string, string[]>;
+};
+type MergeMethod = (targetIdentifier: ResourceKey, matchedIdentifier: ResourceKey, resourceData: unknown) => ResourceKey;
+/**
+Configures how unique identifier lid strings are generated by @ember-data-mirror/store.
+
+This configuration MUST occur prior to the store instance being created.
+
+Takes a method which can expect to receive various data as its first argument
+and the name of a bucket as its second argument.
+
+Currently there are two buckets, 'record' and 'document'.
+
+### Resource (`Record`) Identity
+
+If the bucket is `record` the method must return a unique (to at-least
+the given bucket) string identifier for the given data as a string to be
+used as the `lid` of an `Identifier` token.
+
+This method will only be called by either `getOrCreateRecordIdentifier` or
+`createIdentifierForNewRecord` when an identifier for the supplied data
+is not already known via `lid` or `type + id` combo and one needs to be
+generated or retrieved from a proprietary cache.
+
+`data` will be the same data argument provided to `getOrCreateRecordIdentifier`
+and in the `createIdentifierForNewRecord` case will be an object with
+only `type` as a key.
+
+```ts
+import { setIdentifierGenerationMethod } from '@warp-drive-mirror/core';
+
+export function initialize(applicationInstance) {
+// note how `count` here is now scoped to the application instance
+// for our generation method by being inside the closure provided
+// by the initialize function
+let count = 0;
+
+setIdentifierGenerationMethod((resource, bucket) => {
+return resource.lid || `my-key-${count++}`;
+});
+}
+
+export default {
+name: 'configure-ember-data-identifiers',
+initialize
+};
+```
+
+### Document Identity
+
+If the bucket is `document` the method will receive the associated
+immutable `request` passed to `store.request` as its first argument
+and should return a unique string for the given request if the document
+should be cached, and `null` if it should not be cached.
+
+Note, the request result will still be passed to the cache via `Cache.put`,
+but caches should take this as a signal that the document should not itself
+be cached, while its contents may still be used to update other cache state.
+
+The presence of `cacheOptions.key` on the request will take precedence
+for the document cache key, and this method will not be called if it is
+present.
+
+The default method implementation for this bucket is to return `null`
+for all requests whose method is not `GET`, and to return the `url` for
+those where it is.
+
+This means that queries via `POST` MUST provide `cacheOptions.key` or
+implement this hook.
+
+⚠️ Caution: Requests that do not have a `method` assigned are assumed to be `GET`
+
+@summary Overrides how the store generates `lid` cache keys for resources and documents; must be set
+before the store is created.
+@public
+*/
+declare function setIdentifierGenerationMethod(method: GenerationMethod | null): void;
+/**
+Configure a callback for when the identifier cache encounters new resource
+data for an existing resource.
+
+This configuration MUST occur prior to the store instance being created.
+
+```js
+import { setIdentifierUpdateMethod } from '@warp-drive-mirror/core';
+```
+
+Takes a method which can expect to receive an existing `Identifier` alongside
+some new data to consider as a second argument. This is an opportunity
+for secondary lookup tables and caches associated with the identifier
+to be amended.
+
+This method is called everytime `updateRecordIdentifier` is called and
+with the same arguments. It provides the opportunity to update secondary
+lookup tables for existing identifiers.
+
+It will always be called after an identifier created with `createIdentifierForNewRecord`
+has been committed, or after an update to the `record` a `RecordIdentifier`
+is assigned to has been committed. Committed here meaning that the server
+has acknowledged the update (for instance after a call to `.save()`)
+
+If `id` has not previously existed, it will be assigned to the `Identifier`
+prior to this `UpdateMethod` being called; however, calls to the parent method
+`updateRecordIdentifier` that attempt to change the `id` or calling update
+without providing an `id` when one is missing will throw an error.
+
+@summary Registers a callback run when an existing resource key receives new data, for updating your
+own secondary lookup tables.
+@public
+*/
+declare function setIdentifierUpdateMethod(method: UpdateMethod | null): void;
+/**
+Configure a callback for when the identifier cache is going to release an identifier.
+
+This configuration MUST occur prior to the store instance being created.
+
+```js
+import { setIdentifierForgetMethod } from '@warp-drive-mirror/core';
+```
+
+Takes method which can expect to receive an existing `Identifier` that should be eliminated
+from any secondary lookup tables or caches that the user has populated for it.
+
+@summary Registers a callback run when the store releases a resource key, for cleaning up your own
+lookup tables.
+@public
+*/
+declare function setIdentifierForgetMethod(method: ForgetMethod | null): void;
+/**
+Configure a callback for when the identifier cache is being torn down.
+
+This configuration MUST occur prior to the store instance being created.
+
+```js
+import { setIdentifierResetMethod } from '@warp-drive-mirror/core';
+```
+
+Takes a method which can expect to be called when the parent application is destroyed.
+
+If you have properly used a WeakMap to encapsulate the state of your customization
+to the application instance, you may not need to implement the `resetMethod`.
+
+@summary Registers a callback run when the store's key cache is torn down, for resetting any custom
+key-generation state.
+@public
+*/
+declare function setIdentifierResetMethod(method: ResetMethod | null): void;
+/**
+Configure a callback for when the identifier cache is generating a new
+ResourceKey for a resource.
+
+This method controls the `type` and `id` that will be assigned to the
+`ResourceKey` that is created.
+
+This configuration MUST occur prior to the store instance being created.
+
+```js
+import { setKeyInfoForResource } from '@warp-drive-mirror/core';
+```
+
+@summary Overrides how the store derives the `type` and `id` of a new `ResourceKey` from resource data;
+must be set before the store is created.
+@public
+*/
+declare function setKeyInfoForResource(method: KeyInfoMethod | null): void;
+/**
+ * Each instance of {@link Store} receives a unique instance of a CacheKeyManager.
+ *
+ * This cache is responsible for assigning or retrieving the unique identify
+ * for arbitrary resource data encountered by the store. Data representing
+ * a unique resource or record should always be represented by the same
+ * identifier.
+ *
+ * It can be configured by consuming applications.
+ *
+ * @hideconstructor
+ * @public
+ */
+declare class CacheKeyManager {
+  constructor();
   /**
-   * Returns the schema for the provided resource type.
+   * allows us to peek without generating when needed
+   * useful for the "create" case when we need to see if
+   * we are accidentally overwritting something
    *
-   * @public
+   * @private
    */
-  resource(resource: ObjectWithStringTypeProperty | ResourceKey): Schema;
+  peekResourceKey(resource: ResourceIdentifierObject): ResourceKey | undefined;
   /**
-   * Enables registration of multiple Schemas at once.
-   *
-   * This can be useful for either pre-loading schema information
-   * or for registering schema information delivered by API calls
-   * or other sources just-in-time.
+   * Peeks the {@link RequestKey} for the given {@link RequestInfo}, but will not
+   * create one if none has been previously generated.
    *
    * @public
    */
-  registerResources(schemas: Schema[]): void;
+  peekRequestKey(request: RequestInfo): RequestKey | null;
   /**
-   * Enables registration of a single Schema representing either
-   * a resource in PolarisMode or LegacyMode or an ObjectSchema
-   * representing an embedded structure in other schemas.
+   * Returns the {@link RequestKey} for the given {@link RequestInfo} if the request is
+   * considered cacheable. For cacheable requests, this method will create
+   * a RequestKey if none is found.
    *
-   * This can be useful for either pre-loading schema information
-   * or for registering schema information delivered by API calls
-   * or other sources just-in-time.
+   * A `null` response indicates the request cannot/will not be cached,
+   * generally this means either
    *
-   * @public
-   */
-  registerResource(schema: Schema): void;
-  /**
-   * Enables registration of a transformation.
+   * - {@link RequestInfo.cacheOptions.key} is not present on the `RequestInfo`
+   * - the request's method is `GET` but it has no `url`
    *
-   * The transformation can later be retrieved by the name
-   * attached to it's `[Type]` property.
+   * Generally you should not seek to cache requests that are not idempotent
+   * or have side effects, such as mutations that create, update or delete
+   * a resource.
    *
    * @public
    */
-  registerTransformation(transform: Transformation$1): void;
+  getOrCreateDocumentIdentifier(request: RequestInfo): RequestKey | null;
   /**
-   * Enables registration of a derivation.
-   *
-   * The derivation can later be retrieved by the name
-   * attached to it's `[Type]` property.
-   *
-   * @public
-   */
-  registerDerivation<R, T, FM extends ObjectValue | null>(derivation: Derivation<R, T, FM>): void;
+	Returns the {@link ResourceKey} for the given Resource, creates one if it does not yet exist.
+	
+	Specifically this means that we:
+	
+	- validate the `id` `type` and `lid` combo against known identifiers
+	- return an object with an `lid` that is stable (repeated calls with the same
+	`id` + `type` or `lid` will return the same `lid` value)
+	- this referential stability of the object itself is guaranteed
+	
+	@public
+	*/
+  getOrCreateRecordIdentifier<T>(resource: T): NarrowIdentifierIfPossible<T>;
   /**
-   * Enables registration of a hashing function
-   *
-   * The hashing function can later be retrieved by the name
-   * attached to it's `[Type]` property.
-   *
-   * @public
-   */
-  registerHashFn(hashFn: HashFn): void;
+	Returns a new Identifier for the supplied data. Call this method to generate
+	an identifier when a new resource is being created local to the client and
+	potentially does not have an `id`.
+	
+	Delegates generation to the user supplied `GenerateMethod` if one has been provided
+	with the signature `generateMethod({ type }, 'record')`.
+	
+	@public
+	*/
+  createIdentifierForNewRecord(data: {
+    type: string;
+    id?: string | null;
+    lid?: string;
+  }): ResourceKey;
   /**
-   * Registers a {@link Trait} for use by resource schemas.
-   *
-   * Traits are re-usable collections of fields that can be composed to
-   * build up a resource schema. Often they represent polymorphic behaviors
-   * a resource should exhibit.
-   *
-   * When we finalize a resource, we walk its traits and apply their fields
-   * to the resource's fields. All specified traits must be registered by
-   * this time or an error will be thrown.
-   *
-   * Traits are applied left-to-right, with traits of traits being applied in the same
-   * way. Thus for the most part, application of traits is a post-order graph traversal
-   * problem.
-   *
-   * A trait is only ever processed once. If multiple traits (A, B, C) have the same
-   * trait (D) as a dependency, D will be included only once when first encountered by
-   * A.
-   *
-   * If a cycle exists such that trait A has trait B which has Trait A, trait A will
-   * be applied *after* trait B in production. In development a cycle error will be thrown.
-   *
-   * Fields are finalized on a "last wins principle". Thus traits appearing higher in
-   * the tree and further to the right of a traits array take precedence, with the
-   * resource's fields always being applied last and winning out.
-   *
-   * @public
-   */
-  registerTrait?(trait: Trait): void;
+	Provides the opportunity to update secondary lookup tables for existing identifiers
+	Called after an identifier created with `createIdentifierForNewRecord` has been
+	committed.
+	
+	Assigned `id` to an `Identifier` if `id` has not previously existed; however,
+	attempting to change the `id` or calling update without providing an `id` when
+	one is missing will throw an error.
+	
+	- sets `id` (if `id` was previously `null`)
+	- `lid` and `type` MUST NOT be altered post creation
+	
+	If a merge occurs, it is possible the returned identifier does not match the originally
+	provided identifier. In this case the abandoned identifier will go through the usual
+	`forgetRecordIdentifier` codepaths.
+	
+	@public
+	*/
+  updateRecordIdentifier(identifierObject: ResourceKey, data: unknown): ResourceKey;
   /**
-   * DEPRECATED - use `fields` instead
-   *
-   * Returns definitions for all properties of the specified resource
-   * that are considered "attributes". Generally these are properties
-   * that are not related to book-keeping state on the client and do
-   * not represent a linkage to another resource.
-   *
-   * The return value should be a dictionary of key:value pairs
-   * where the `key` is the attribute or property's name and `value`
-   * is an object with at least the property `name` which should also
-   * match `key`.
-   *
-   * Optionally, this object may also specify `type`, which should
-   * be a string reference to a `transform`, and `options` which
-   * should be dictionary in which any key:value pairs are permissable.
+	Provides the opportunity to eliminate an identifier from secondary lookup tables
+	as well as eliminates it from ember-data's own lookup tables and book keeping.
+	
+	Useful when a record has been deleted and the deletion has been persisted and
+	we do not care about the record anymore. Especially useful when an `id` of a
+	deleted record might be reused later for a new record.
+	
+	@public
+	*/
+  forgetRecordIdentifier(identifierObject: ResourceKey): void;
+}
+/**
+ * This type exists for internal use only for
+ * where intimate contracts still exist either for
+ * the Test Suite or for Legacy code.
+ *
+ * @private
+ */
+interface PrivateCacheKeyManager extends CacheKeyManager {
+  _cache: StableCache;
+  /**
+   * Internal hook to allow management of merge conflicts with identifiers.
    *
-   * For instance, when using `@warp-drive-mirror/legacy/model`, the following attribute
-   * definition:
+   * we allow late binding of this private internal merge so that
+   * the cache can insert itself here to handle elimination of duplicates
+   */
+  __configureMerge(method: MergeMethod | null): void;
+  _mergeRecordIdentifiers(keyInfo: KeyInfo, identifier: ResourceKey, existingIdentifier: ResourceKey, data: unknown): ResourceKey;
+  destroy(): void;
+}
+type UnsubscribeToken$1 = object;
+/**
+ * The kinds of change notifications the {@link NotificationManager} can emit for a resource.
+ *
+ * @summary The lifecycle notification kinds sent to resource subscribers: `added`, `removed`, `updated`,
+ * or `state`.
+ */
+type CacheOperation$1 = "added" | "removed" | "updated" | "state";
+/**
+ * The kinds of change notifications the {@link NotificationManager} can emit for a request document.
+ *
+ * @summary The notification kinds sent to request document subscribers, such as `updated` or
+ * `invalidated`.
+ */
+type DocumentCacheOperation$1 = "invalidated" | "added" | "removed" | "updated" | "state";
+/**
+ * The full set of notification kinds the {@link NotificationManager} can emit for a resource,
+ * including both {@link CacheOperation}s and finer-grained field-level change notifications.
+ *
+ * @summary Every notification kind a resource subscriber can receive, from lifecycle operations to
+ * `attributes`, `relationships`, `errors`, `meta`, and `identity` changes.
+ */
+type NotificationType = "attributes" | "relationships" | "identity" | "errors" | "meta" | CacheOperation$1;
+/**
+ * The shape accepted by {@link NotificationManager.notify} and
+ * {@link CacheCapabilitiesManager.notifyChange} for delivering many keys for
+ * the `'attributes'` or `'relationships'` namespaces in a single call
+ * instead of once per key.
+ *
+ * @summary A set of field names passed to `notify` or `notifyChange` to report many `attributes` or
+ * `relationships` changes in one call.
+ * @since 5.9.0
+ * @public
+ */
+type NotifyKeys = Set<string>;
+/**
+ * A change to a resource's `attributes` or `relationships` can be relevant to
+ * a "local" view of the resource (its mutable/editable state), a "remote" view
+ * (its last-known-persisted state), or both.
+ *
+ * Each view subscribes to its own channel and, when notified, re-pulls its own
+ * projection of the data: a remote-only reader (e.g. PolarisMode's default
+ * immutable record) subscribes `'remote'` and re-reads remote state; an
+ * editable/reconciled reader (a legacy record, or an editable checkout)
+ * subscribes `'local'` (the same as omitting the channel) and re-reads local
+ * state. A notifier that knows which projection changed tags the notification
+ * with that channel; each tag is delivered only to that channel's subscribers.
+ * A change affecting both projections is either notified unscoped or once per
+ * channel. An unscoped notify cannot guarantee which view changed, so it
+ * reaches every subscriber -- this keeps every pre-channel `notify` callsite
+ * (and any custom cache that doesn't know about channels) fully compatible.
+ *
+ * The full delivery matrix:
+ *
+ * | notify ↓ subscribe → | `'local'` | `'remote'` | omitted (= `'local'`) |
+ * | -------------------- | --------- | ---------- | --------------------- |
+ * | `'local'`            | ✅        | ❌         | ✅                    |
+ * | `'remote'`           | ❌        | ✅         | ❌                    |
+ * | omitted              | ✅        | ✅         | ✅                    |
+ *
+ * Channel only applies to the `'attributes'` and `'relationships'`
+ * notification types. All other types (`'errors'`,
+ * `'identity'`, `'state'`, and the various `CacheOperation`/
+ * `DocumentCacheOperation` values) are never filtered by channel since they
+ * have no local/remote duality.
+ *
+ * @summary Scopes an `attributes` or `relationships` notification to a resource's local (editable) or
+ * remote (persisted) view so only matching subscribers hear it.
+ * @public
+ */
+type NotificationChannel = "local" | "remote";
+interface NotificationCallback$1 {
+  (cacheKey: ResourceKey, notificationType: "attributes" | "relationships", key?: string): void;
+  (cacheKey: ResourceKey, notificationType: "errors" | "meta" | "identity" | "state"): void;
+  (cacheKey: ResourceKey, notificationType: CacheOperation$1): void;
+}
+interface ResourceOperationCallback$1 {
+  (cacheKey: ResourceKey, notificationType: CacheOperation$1): void;
+}
+interface DocumentOperationCallback$1 {
+  (cacheKey: RequestKey, notificationType: DocumentCacheOperation$1): void;
+}
+/**
+ * The NotificationManager provides the ability to subscribe to
+ * changes to Cache state.
+ *
+ * This Feature is what allows WarpDrive to create subscriptions that
+ * work with any framework or change-notification system.
+ *
+ * @summary The store service that lets code subscribe to and batch-deliver change notifications for
+ * cached resources and request documents.
+ * @hideconstructor
+ * @public
+ */
+declare class NotificationManager$1 {
+  constructor(store: Store$1);
+  /**
+   * Subscribe to changes for a given ResourceKey, RequestKey, or addition/removal of any resource
+   * or document.
    *
    * ```ts
-   * class extends Model {
-   *   @attr('string', { defaultValue: 'hello' }) greeting;
-   *   @attr('date') birthday;
-   *   @attr firstName;
-   * }
-   * ```
-   *
-   * Would be returned as:
+   * export type CacheOperation = 'added' | 'removed' | 'updated' | 'state';
    *
-   * ```js
-   * {
-   *   greeting: { name: 'greeting', type: 'string', options: { defaultValue: 'hello' } },
-   *   birthday: { name: 'birthday', type: 'date' },
-   *   firstName: { name: 'firstName' }
+   * export interface NotificationCallback {
+   *   (cacheKey: ResourceKey, notificationType: 'attributes' | 'relationships', key?: string): void;
+   *   (cacheKey: ResourceKey, notificationType: 'errors' | 'meta' | 'identity' | 'state'): void;
+   *   (cacheKey: ResourceKey, notificationType: NotificationType, key?: string): void;
    * }
-   * ```
-   *
-   * @public
-   * @deprecated - use {@link SchemaService.fields | fields}
-   */
-  attributesDefinitionFor?(key: ResourceKey | ObjectWithStringTypeProperty): AttributesSchema;
-  /**
-   * DEPRECATED - use `fields` instead
-   *
-   * Returns definitions for all properties of the specified resource
-   * that are considered "relationships". Generally these are properties
-   * that represent a linkage to another resource.
-   *
-   * The return value should be a dictionary of key:value pairs
-   * where the `key` is the relationship or property's name and `value`
-   * is an object with at least the following properties:
-   *
-   * - `name` which should also match the `key` used in the dictionary.
-   * - `kind` which should be either `belongsTo` or `hasMany`
-   * - `type` which should be the related resource's string "type"
-   * - `options` which should be a dictionary allowing any key but with
-   *    at least the below keys present.
-   *
-   * - `options.async` a boolean representing whether data for this relationship is
-   *      typically loaded on-demand.
-   * - `options.inverse` a string or null representing the field name / key of the
-   *       corresponding relationship on the inverse resource.
-   *
-   * Additionally the following options properties are optional. See [Polymorphic Relationships](https://rfcs.emberjs.com/id/0793-polymporphic-relations-without-inheritance)
-   *
-   * - `options.polymorphic` a boolean representing whether multiple resource types
-   *    can be used to satisfy this relationship.
-   * - `options.as` a string representing the abstract type that the concrete side of
-   *    a relationship must specify when fulfilling a polymorphic inverse.
-   *
-   * For example, the following Model using @warp-drive-mirror/legacy/model would generate this relationships
-   * definition by default:
-   *
-   * ```js
-   * class User extends Model {
-   *   @belongsTo('user', { async: false, inverse: null }) bestFriend;
-   *   @hasMany('user', { async: true, inverse: 'friends' }) friends;
-   *   @hasMany('pet', { async: false, polymorphic: true, inverse: 'owner' }) pets;
+   * export interface ResourceOperationCallback {
+   *   // resource updates
+   *   (cacheKey: ResourceKey, notificationType: CacheOperation): void;
    * }
-   * ```
-   *
-   * Which would be returned as
-   *
-   * ```js
-   * {
-   *   bestFriend: {
-   *     name: 'bestFriend',
-   *     kind: 'belongsTo',
-   *     type: 'user',
-   *     options: {
-   *       async: false,
-   *       inverse: null
-   *     }
-   *   },
-   *   friends: {
-   *     name: 'friends',
-   *     kind: 'hasMany',
-   *     type: 'user',
-   *     options: {
-   *       async: true,
-   *       inverse: 'friends'
-   *     }
-   *   },
-   *   pets: {
-   *     name: 'pets',
-   *     kind: 'hasMany',
-   *     type: 'pet',
-   *     options: {
-   *       async: false,
-   *       polymorphic: true,
-   *       inverse: 'owner'
-   *     }
-   *   },
+   * export interface DocumentOperationCallback {
+   *   // document updates
+   *   (cacheKey: RequestKey, notificationType: CacheOperation): void;
    * }
    * ```
    *
-   * @public
-   * @deprecated - use {@link SchemaService.fields | fields}
-   */
-  relationshipsDefinitionFor?(key: ResourceKey | ObjectWithStringTypeProperty): RelationshipsSchema;
-  /**
-   * Returns all known resource types
-   *
-   * @public
-   */
-  resourceTypes(): Readonly<string[]>;
-  /**
-   * Register an extension for either objects or arrays
+   * A `channel` may be provided when subscribing to a `ResourceKey`. Its
+   * effect is that the subscription skips `'attributes'`/`'relationships'`
+   * notifications explicitly tagged with the *other* channel; unscoped
+   * notifications, and notifications for all other notification types, always
+   * reach the subscriber. Subscribing `'local'` and omitting the channel are
+   * the same thing. See {@link NotificationChannel}.
    *
-   * See also {@link CAUTION_MEGA_DANGER_ZONE_Extension}
+   * | notify ↓ subscribe → | `'local'` | `'remote'` | omitted (= `'local'`) |
+   * | -------------------- | --------- | ---------- | --------------------- |
+   * | `'local'`            | ✅        | ❌         | ✅                    |
+   * | `'remote'`           | ❌        | ✅         | ❌                    |
+   * | omitted              | ✅        | ✅         | ✅                    |
    *
    * @public
+   * @return an opaque token to be used with unsubscribe
    */
-  CAUTION_MEGA_DANGER_ZONE_registerExtension?(extension: CAUTION_MEGA_DANGER_ZONE_Extension): void;
+  subscribe(cacheKey: ResourceKey, callback: NotificationCallback$1, channel?: NotificationChannel): UnsubscribeToken$1;
+  subscribe(cacheKey: "resource", callback: ResourceOperationCallback$1): UnsubscribeToken$1;
+  subscribe(cacheKey: "document" | RequestKey, callback: DocumentOperationCallback$1): UnsubscribeToken$1;
   /**
-   * Retrieve the extension map for a resource
+   * remove a previous subscription
    *
    * @public
    */
-  CAUTION_MEGA_DANGER_ZONE_resourceExtensions?(resource: ResourceKey | {
-    type: string;
-  }): null | ProcessedExtension["features"];
+  unsubscribe(token: UnsubscribeToken$1): void;
   /**
-   * Retrieve the extension map for an object field
+   * Custom Caches and Application Code should not call this method directly.
    *
-   * @public
-   */
-  CAUTION_MEGA_DANGER_ZONE_objectExtensions?(field: ExtensibleField, resolvedType: string | null): null | ProcessedExtension["features"];
-  /**
-   * Retrieve the extension map for an array field
+   * When notifying `'attributes'` or `'relationships'` for many keys on the
+   * same `cacheKey` at once (for instance, when a bulk update to a single
+   * record touches many fields) `key` may be supplied as a `Set<string>`
+   * instead of being called once per key. The `Set` is iterated as-is (it is
+   * never converted to or from an array internally). This delivers the
+   * exact same sequence of individual notifications to subscribers (each
+   * subscriber callback is still invoked once per key, in order) while
+   * paying the per-call overhead (validity checks, subscriber lookups,
+   * buffer/flush scheduling) only once for the whole batch instead of once
+   * per key.
    *
-   * @public
-   */
-  CAUTION_MEGA_DANGER_ZONE_arrayExtensions?(field: ExtensibleField): null | ProcessedExtension["features"];
-  /**
-   * Check if a specific extension has been registered previously
+   * A `channel` may be supplied for the `'attributes'`/`'relationships'`
+   * namespaces. Tagging a notification `'local'` declares "only the local
+   * (reconciled/editable) view changed"; tagging it `'remote'` declares "only
+   * the remote view changed". Each tag is delivered only to that channel's
+   * subscribers. Omitting the channel reaches every subscriber regardless of
+   * its channel. See {@link NotificationChannel}.
    *
-   * @public
+   * | notify ↓ subscribe → | `'local'` | `'remote'` | omitted (= `'local'`) |
+   * | -------------------- | --------- | ---------- | --------------------- |
+   * | `'local'`            | ✅        | ❌         | ✅                    |
+   * | `'remote'`           | ❌        | ✅         | ❌                    |
+   * | omitted              | ✅        | ✅         | ✅                    |
+   *
+   * @private
    */
-  CAUTION_MEGA_DANGER_ZONE_hasExtension?(ext: {
-    kind: "object" | "array";
-    name: string;
-  }): boolean;
+  notify(cacheKey: ResourceKey, value: "attributes" | "relationships", key?: string | NotifyKeys | null, channel?: NotificationChannel): boolean;
+  notify(cacheKey: ResourceKey, value: "errors" | "meta" | "identity" | "state", key?: null): boolean;
+  notify(cacheKey: ResourceKey, value: CacheOperation$1, key?: null): boolean;
+  notify(cacheKey: RequestKey, value: DocumentCacheOperation$1, key?: null): boolean;
+}
+/**
+ * This type exists for internal use only for
+ * where intimate contracts still exist either for
+ * the Test Suite or for Legacy code.
+ *
+ * @private
+ */
+interface PrivateNotificationManager extends NotificationManager$1 {
+  _flush(): void;
 }
-//#endregion
-//#region src/store/-types/q/cache-capabilities-manager.d.ts
 /**
  * CacheCapabilitiesManager provides encapsulated API access to the minimal
  * subset of the Store's functionality that Cache implementations
@@ -2839,6 +3068,8 @@ interface SchemaService {
  *
  * This class cannot be directly instantiated.
  *
+ * @summary The narrow slice of Store API handed to a Cache via `createCache`, for key lookup, schema access, record
+ * id updates, and change notifications.
  * @public
  */
 type CacheCapabilitiesManager$1 = {
@@ -2970,8 +3201,6 @@ type CacheCapabilitiesManager$1 = {
    */
   notifyChange(identifier: ResourceKey | RequestKey, namespace: NotificationType | "added" | "removed" | "updated", key: string | NotifyKeys | null, channel?: NotificationChannel): void;
 };
-//#endregion
-//#region src/store/-types/q/record-instance.d.ts
 /**
 In WarpDrive, a "record instance" is a class instance used to present the data
 for a single resource, transforming the resource's cached raw data into a form
@@ -2994,18 +3223,20 @@ based on a special symbol prsent on record instances that implement the
 
 */
 type OpaqueRecordInstance = unknown;
-//#endregion
-//#region src/types/cache.d.ts
 /**
  * A hash of changed attributes with the key being the attribute name and the value being an
  * array of `[oldValue, newValue]`.
  *
+ * @summary Map of attribute name to `[oldValue, newValue]` for a resource's uncommitted attribute changes, as
+ * returned by `cache.changedAttrs`.
  */
 type ChangedAttributesHash = Record<string, [Value | undefined, Value]>;
 /**
  * Describes the local (uncommitted) changes to a single relationship,
  * as returned by {@link Cache.changedRelationships}.
  *
+ * @summary Remote versus local state of one relationship, with additions, removals, and reordering for to-many,
+ * as returned by `cache.changedRelationships`.
  * @example
  * ```ts
  * const diff: RelationshipDiff = {
@@ -3063,6 +3294,11 @@ type RelationshipDiff = {
  * A Cache handles in-memory storage of Document and Resource
  * data.
  *
+ * The [Caching](/guides/the-manual/caching/#how-the-cache-works) guide explains how
+ * the cache stores that data.
+ *
+ * @summary Contract a Cache implementation fulfills to store, patch, mutate, and read document and resource data
+ * for the Store, including local changes, errors, and SSR hydration.
  * @public
  */
 interface Cache {
@@ -3203,7 +3439,11 @@ interface Cache {
    * Push resource data from a remote source into the cache for this ResourceKey
    *
    * @public
-   * @return if `hasRecord` is true then calculated key changes should be returned
+   * @return when `hasRecord` is true, the names of the attributes whose persisted value
+   *   this push changed, or `undefined` when none did. A key counts as changed when the
+   *   value the cache holds for it moved, whether or not a local edit already held the new
+   *   value; a value the schema considers equal (for instance, a schema-object with a
+   *   matching identity hash) does not count. Otherwise `void`.
    */
   upsert(cacheKey: ResourceKey, data: ResourceBlob, hasRecord: boolean): void | string[];
   /**
@@ -3284,7 +3524,7 @@ interface Cache {
    * @param cacheKey - the primary ResourceKey that was operated on
    * @param result - a document in the cache format containing any updated data
    */
-  didCommit(cacheKey: ResourceKey, result: StructuredDataDocument<SingleResourceDataDocument> | null): SingleResourceDataDocument;
+  didCommit(cacheKey: ResourceKey, result: StructuredDataDocument<SingleResourceDataDocument<ExistingResourceObject, ExistingResourceObject>> | null): SingleResourceDataDocument;
   /**
    * [LIFECYCLE] Signals to the cache that a set of resources
    * was successfully updated as part of a save transaction that
@@ -3294,7 +3534,7 @@ interface Cache {
    * @param cacheKey - the primary ResourceKeys that were operated on
    * @param result - a document in the cache format containing any updated data
    */
-  didCommit(cacheKey: ResourceKey[], result: StructuredDataDocument<SingleResourceDataDocument> | null): SingleResourceDataDocument;
+  didCommit(cacheKey: ResourceKey[], result: StructuredDataDocument<SingleResourceDataDocument<ExistingResourceObject, ExistingResourceObject>> | null): SingleResourceDataDocument;
   /**
    * [LIFECYCLE] Signals to the cache that a set of resources
    * was successfully updated as part of a save transaction that
@@ -3304,7 +3544,7 @@ interface Cache {
    * @param cacheKey - the primary ResourceKeys that were operated on
    * @param result - a document in the cache format containing any updated data
    */
-  didCommit(cacheKey: ResourceKey[], result: StructuredDataDocument<CollectionResourceDataDocument> | null): CollectionResourceDataDocument;
+  didCommit(cacheKey: ResourceKey[], result: StructuredDataDocument<CollectionResourceDataDocument<ExistingResourceObject>> | null): CollectionResourceDataDocument;
   /**
    * [LIFECYCLE] Signals to the cache that a resource
    * was update via a save transaction failed.
@@ -3450,8 +3690,6 @@ interface Cache {
    */
   isDeletionCommitted(cacheKey: ResourceKey): boolean;
 }
-//#endregion
-//#region src/graph/-private/-edge-definition.d.ts
 type EdgeCache = Record<string, Record<string, EdgeDefinition | null>>;
 type RelationshipField = LegacyBelongsToField | LegacyHasManyField | ResourceField | CollectionField;
 type RelationshipFieldKind = RelationshipField["kind"];
@@ -3589,8 +3827,6 @@ interface EdgeDefinition {
    */
   isReflexive: boolean;
 }
-//#endregion
-//#region src/graph/-private/-state.d.ts
 interface RelationshipState {
   hasReceivedData: boolean;
   hasReceivedRemoteData: boolean;
@@ -3600,8 +3836,6 @@ interface RelationshipState {
   shouldForceReload: boolean;
   hasDematerializedInverse: boolean;
 }
-//#endregion
-//#region src/graph/-private/edges/collection.d.ts
 /**
  * Stores the graph's internal state for one side of a collection (`hasMany`) relationship.
  */
@@ -3655,8 +3889,6 @@ interface CollectionEdge {
     del: Set<ResourceKey>;
   };
 }
-//#endregion
-//#region src/graph/-private/edges/implicit.d.ts
 /**
  * The relationship definition (schema metadata) backing an {@link ImplicitEdge}, tagging
  * the {@link UpgradedMeta} as belonging to an implicit inverse relationship.
@@ -3707,8 +3939,6 @@ interface ImplicitEdge {
   /** Members known to be part of the relationship from remote (server-provided) state. */
   remoteMembers: Set<ResourceKey>;
 }
-//#endregion
-//#region src/graph/-private/edges/resource.d.ts
 /**
  * Stores the data for one side of a "single" resource relationship.
  *
@@ -3725,8 +3955,6 @@ interface ResourceEdge {
   transactionRef: number;
   accessed: boolean;
 }
-//#endregion
-//#region src/graph/-private/graph.d.ts
 /**
  * A single edge (relationship field) tracked by the {@link Graph} for a resource. Which kind of edge
  * a field is depends on its relationship definition:
@@ -3968,30 +4196,24 @@ declare class Graph {
    */
   destroy(): void;
 }
-//#endregion
-//#region src/graph/-private/-utils.d.ts
 /** A type-guard returning whether the given edge is a `belongsTo` {@link ResourceEdge}. */
 declare function isBelongsTo(relationship: GraphEdge): relationship is ResourceEdge;
-//#endregion
-//#region src/graph/-private.d.ts
 /** Returns the {@link Graph} associated with the given store or capabilities manager, if one has been created. */
 declare function peekGraph(store: CacheCapabilitiesManager$1 | Store$1): Graph | undefined;
 /** The type of the {@link peekGraph} function. */
 type peekGraph = typeof peekGraph;
 /** Returns the {@link Graph} for the given store, creating (and caching) one first if it does not yet exist. */
 declare function graphFor(store: CacheCapabilitiesManager$1 | Store$1): Graph;
-//#endregion
-//#region src/request/-private/future.d.ts
 /**
  * Create a {@link Deferred}: a promise along with the `resolve`/`reject`
  * callbacks that settle it, so the promise can be handed out before the
  * work that will settle it has started.
  *
+ * @summary Creates a promise together with its `resolve` and `reject` callbacks so it can be handed out
+ * before it is settled.
  * @public
  */
 declare function createDeferred<T>(): Deferred<T>;
-//#endregion
-//#region src/request/-private/promise-cache.d.ts
 type CacheResult<T = unknown, E = unknown> = {
   isError: true;
   result: E;
@@ -4005,6 +4227,8 @@ type CacheResult<T = unknown, E = unknown> = {
  * (and by `getPromiseState`). Anything that is at least `then`/`catch`/`finally`
  * "shaped" (including a real `Promise` or {@link Future}) satisfies this.
  *
+ * @summary Any promise-like value with `then`, `catch`, and `finally`, as accepted by the promise-result
+ * cache and `getPromiseState`.
  * @public
  */
 type Awaitable<T = unknown, E = unknown> = {
@@ -4032,6 +4256,8 @@ type Awaitable<T = unknown, E = unknown> = {
  * outcome can be synchronously read later via {@link getPromiseResult},
  * without needing to await it again.
  *
+ * @summary Records a promise's settled value or error so it can later be read synchronously with
+ * `getPromiseResult`.
  * @public
  */
 declare function setPromiseResult(promise: Promise<unknown> | Awaitable, result: CacheResult): void;
@@ -4039,26 +4265,35 @@ declare function setPromiseResult(promise: Promise<unknown> | Awaitable, result:
  * Synchronously read the settled result (or error) previously recorded for
  * a promise-like value via {@link setPromiseResult}, if any.
  *
+ * @summary Synchronously returns the settled value or error previously recorded for a promise, or
+ * `undefined` if none was recorded.
  * @public
  */
 declare function getPromiseResult<T, E>(promise: Promise<T> | Awaitable<T, E>): CacheResult<T, E> | undefined;
-//#endregion
-//#region src/request.d.ts
 /**
  * Brands the supplied object with the supplied response type.
  *
+ * Call it inside a [builder](/guides/the-manual/requests/builders), so the type is part of
+ * the builder's contract and every caller gets it through inference. Calling it inline
+ * where the request is made is a cast. The [Typing Requests](/guides/the-manual/requests/typing-requests)
+ * guide shows how to use it.
+ *
  * ```ts
  * import type { ReactiveDataDocument } from '@warp-drive-mirror/core/reactive';
  * import { withResponseType } from '@warp-drive-mirror/core/request';
  * import type { User } from '#/data/user.ts'
  *
- * const result = await store.request(
- *  withResponseType<ReactiveDataDocument<User>>({ url: '/users/1' })
- * );
+ * export function getUser(id: string) {
+ *   return withResponseType<ReactiveDataDocument<User>>({ url: `/users/${id}` });
+ * }
+ *
+ * const result = await store.request(getUser('1'));
  *
  * result.content.data; // will have type User
  * ```
  *
+ * @summary Types a request object with the response type that `store.request` or `RequestManager.request`
+ * should resolve with; no runtime effect.
  */
 declare function withResponseType<T>(obj: RequestInfo): RequestInfo<T> & {
   /** The branded response type. Present only at the type level; carries no runtime value. */
@@ -4069,13 +4304,20 @@ declare function withResponseType<T>(obj: RequestInfo): RequestInfo<T> & {
  * wrapped in {@link ReactiveDataDocument}. This is a convenience for
  * the common case of using {@link withResponseType} with `ReactiveDataDocument`.
  *
+ * Like `withResponseType`, call it inside a [builder](/guides/the-manual/requests/builders)
+ * rather than where the request is made. The
+ * [Typing Requests](/guides/the-manual/requests/typing-requests#typing-reactive-responses)
+ * guide shows how to use it.
+ *
  * ```ts
  * import { withReactiveResponse } from '@warp-drive-mirror/core/request';
  * import type { User } from '#/data/user.ts'
  *
- * const result = await store.request(
- *   withReactiveResponse<User>({ url: '/users/1' })
- * );
+ * export function getUser(id: string) {
+ *   return withReactiveResponse<User>({ url: `/users/${id}` });
+ * }
+ *
+ * const result = await store.request(getUser('1'));
  *
  * result.content.data; // will have type User
  * ```
@@ -4085,13 +4327,17 @@ declare function withResponseType<T>(obj: RequestInfo): RequestInfo<T> & {
  * ```ts
  * type PageMeta = { page: { limit: number; offset: number }; total?: number };
  *
- * const result = await store.request(
- *   withReactiveResponse<User[], PageMeta>({ url: '/users' })
- * );
+ * export function getUsers() {
+ *   return withReactiveResponse<User[], PageMeta>({ url: '/users' });
+ * }
+ *
+ * const result = await store.request(getUsers());
  *
  * result.content.meta?.total; // number | undefined
  * ```
  *
+ * @summary Types a request object so its response resolves as a `ReactiveDataDocument` of the given
+ * data and meta types; no runtime effect.
  * @public
  */
 declare function withReactiveResponse<T, M extends Meta | undefined = Meta | undefined, E extends object = object, EM extends Meta | undefined = M>(obj: RequestInfo): RequestInfo<ReactiveDataDocument<T, M, E, EM>> & {
@@ -4099,18 +4345,31 @@ declare function withReactiveResponse<T, M extends Meta | undefined = Meta | und
   [RequestSignature]: ReactiveDataDocument<T, M, E, EM>;
 };
 /**
+ * @summary Deprecated alias for `withResponseType`, which types a request object with its expected
+ * response type.
  * @deprecated use {@link withResponseType} instead
  */
 declare const withBrand: typeof withResponseType;
-//#endregion
-//#region src/store/-private/cache-handler/handler.d.ts
 type LooseStoreRequestInfo<RT = unknown> = Omit<ImmutableRequestInfo<RT>, "records" | "headers" | typeof RequestSignature> & {
   records?: ResourceIdentifierObject[];
   headers?: Headers;
+  /**
+   * If provided, used instead of the AbortController auto-configured for each request by the RequestManager.
+   *
+   * Handlers never receive this: the RequestManager removes it before the first handler runs and
+   * exposes its signal as `request.signal` instead, which is why {@link ImmutableRequestInfo} omits it.
+   */
+  controller?: AbortController;
 };
 /**
  * The request shape accepted by {@link Store.request}, either a fully-formed
  * {@link ImmutableRequestInfo} or the looser {@link LooseStoreRequestInfo}.
+ *
+ * Only the looser form accepts `controller`, so a request carrying one, including a builder's
+ * output spread together with a `controller`, resolves to {@link LooseStoreRequestInfo}.
+ *
+ * @summary The request object `store.request` accepts, either a full immutable request info or a looser
+ * form with plain `records` and `headers`.
  */
 type StoreRequestInput<RT = unknown> = ImmutableRequestInfo<RT> | LooseStoreRequestInfo<RT>;
 interface StoreRequestContext extends RequestContext {
@@ -4122,6 +4381,9 @@ interface StoreRequestContext extends RequestContext {
 /**
  * A CacheHandler that adds support for using an WarpDrive Cache with a RequestManager.
  *
+ * The [Caching](/guides/the-manual/caching/) guide explains how it decides whether a
+ * request can use the cache.
+ *
  * This handler will only run when a request has supplied a `store` instance. Requests
  * issued by the store via `store.request()` will automatically have the `store` instance
  * attached to the request.
@@ -4157,22 +4419,29 @@ interface StoreRequestContext extends RequestContext {
  *   method: 'GET',
  *   [EnableHydration]: true
  * });
+ * ```
  *
+ * @summary The RequestManager cache handler that serves, dedupes, and caches store requests and returns
+ * reactive documents when hydration is enabled.
  */
 declare const CacheHandler: CacheHandler$1;
-//#endregion
-//#region src/store/-private/cache-handler/types.d.ts
 /**
  * A service which an application may provide to the store via
  * the store's `lifetimes` property to configure the behavior
  * of the CacheHandler.
  *
+ * The [Advanced Store Configuration](/guides/configuration/advanced#decide-how-long-requests-are-valid-for-with-a-cachepolicy)
+ * guide shows how to configure one, and [Caching](/guides/the-manual/caching/) explains
+ * where the CacheHandler consults it.
+ *
  * The default behavior for request lifetimes is to never expire
  * unless manually refreshed via `cacheOptions.reload` or `cacheOptions.backgroundReload`.
  *
  * Implementing this service allows you to programatically define
  * when a request should be considered expired.
  *
+ * @summary The interface a store's `lifetimes` service implements to decide when cached requests are
+ * hard or soft expired and should be refetched.
  * @public
  */
 interface CachePolicy {
@@ -4243,8 +4512,6 @@ interface CachePolicy {
    */
   didRequest?(request: ImmutableRequestInfo, response: Response | ResponseInfo | null, identifier: RequestKey | null, store: Store$1): void;
 }
-//#endregion
-//#region src/reactive/-private/document.d.ts
 interface ReactiveDocumentBase<T, M extends Meta | undefined = Meta | undefined, E extends object = object, EM extends Meta | undefined = M> {
   /**
    * The links object for this document, if any
@@ -4366,6 +4633,8 @@ type DocumentMeta<M extends Meta | undefined> = undefined extends M ? {
  * The variant of {@link ReactiveDocument} returned for a request whose
  * response contained no primary data, e.g. an error response.
  *
+ * @summary The shape of a reactive response document that carries `errors` and no primary `data`,
+ * such as the result of a failed request.
  * @public
  */
 type ReactiveErrorDocument<T, EM extends Meta | undefined = Meta | undefined, E extends object = object, M extends Meta | undefined = EM> = ReactiveDocumentBase<T, M, E, EM> & DocumentMeta<EM> & {
@@ -4396,6 +4665,8 @@ type ReactiveErrorDocument<T, EM extends Meta | undefined = Meta | undefined, E
  * The variant of {@link ReactiveDocument} returned for a request whose
  * response contained primary data.
  *
+ * @summary The shape of a reactive response document whose `data` holds the request's primary
+ * records, with no `errors`.
  * @public
  */
 type ReactiveDataDocument<T, M extends Meta | undefined = Meta | undefined, E extends object = object, EM extends Meta | undefined = M> = ReactiveDocumentBase<T, M, E, EM> & DocumentMeta<M> & {
@@ -4423,15 +4694,18 @@ type ReactiveDataDocument<T, M extends Meta | undefined = Meta | undefined, E ex
  * returned by `Cache.put` or `Cache.peek`, converting ResourceKeys into
  * ReactiveResource instances.
  *
+ * The [Using The Response](/guides/the-manual/requests/using-the-response) guide
+ * shows when a request's content is a ReactiveDocument.
+ *
  * It is not directly instantiated by the user, and its properties should not
  * be directly modified. Whether individual properties are mutable or not is
  * determined by the record instance itself.
  *
+ * @summary The reactive wrapper around a request's response document that exposes its data or errors
+ * as live records, plus meta, links, and pagination helpers.
  * @public
  */
 type ReactiveDocument<T, M extends Meta | undefined = Meta | undefined, E extends object = object, EM extends Meta | undefined = M> = ReactiveDataDocument<T, M, E, EM> | ReactiveErrorDocument<T, EM, E, M>;
-//#endregion
-//#region src/store/-private/managers/cache-capabilities-manager.d.ts
 interface CacheCapabilitiesManager {
   /** @deprecated - use {@link CacheCapabilitiesManager.schema} */
   getSchemaDefinitionService(): SchemaService;
@@ -4466,8 +4740,6 @@ interface PrivateCacheCapabilitiesManager extends CacheCapabilitiesManager {
  * @private
  */
 declare function assertPrivateCapabilities(manager: unknown): asserts manager is PrivateCacheCapabilitiesManager;
-//#endregion
-//#region src/store/-private/managers/cache-manager.d.ts
 /**
  * The CacheManager wraps a Cache enforcing that only
  * the public API surface area is exposed.
@@ -4571,7 +4843,8 @@ declare class CacheManager implements Cache {
    * Push resource data from a remote source into the cache for this ResourceKey
    *
    * @public
-   * @return if `hasRecord` is true then calculated key changes should be returned
+   * @return when `hasRecord` is true, the names of the attributes whose persisted value
+   *   this push changed, or `undefined` when none did. Otherwise `void`.
    */
   upsert(key: ResourceKey, data: unknown, hasRecord: boolean): void | string[];
   /**
@@ -4673,9 +4946,9 @@ declare class CacheManager implements Cache {
    *
    * @public
    */
-  didCommit(key: ResourceKey, result: StructuredDataDocument<SingleResourceDataDocument> | null): SingleResourceDataDocument;
-  didCommit(key: ResourceKey[], result: StructuredDataDocument<SingleResourceDataDocument> | null): SingleResourceDataDocument;
-  didCommit(key: ResourceKey[], result: StructuredDataDocument<CollectionResourceDataDocument> | null): CollectionResourceDataDocument;
+  didCommit(key: ResourceKey, result: StructuredDataDocument<SingleResourceDataDocument<ExistingResourceObject, ExistingResourceObject>> | null): SingleResourceDataDocument;
+  didCommit(key: ResourceKey[], result: StructuredDataDocument<SingleResourceDataDocument<ExistingResourceObject, ExistingResourceObject>> | null): SingleResourceDataDocument;
+  didCommit(key: ResourceKey[], result: StructuredDataDocument<CollectionResourceDataDocument<ExistingResourceObject>> | null): CollectionResourceDataDocument;
   /**
    * [LIFECYCLE] Signals to the cache that a resource
    * was update via a save transaction failed.
@@ -4824,8 +5097,6 @@ declare class CacheManager implements Cache {
    */
   isDeletionCommitted(key: ResourceKey): boolean;
 }
-//#endregion
-//#region src/store/-private/caches/instance-cache.d.ts
 /**
 Retrieves the unique referentially-stable {@link ResourceKey}
 assigned to the given record instance.
@@ -4840,6 +5111,7 @@ const identifier = recordIdentifierFor(record);
 const { id, type, lid } = identifier;
 ```
 
+@summary Returns the stable `ResourceKey` (type, id, and lid) the store assigned to a record instance.
 @public
 @param record a record instance previously obstained from the store.
 */
@@ -4939,8 +5211,6 @@ declare class InstanceCache {
  * @private
  */
 declare function _clearCaches(): void;
-//#endregion
-//#region src/store/-private/record-arrays/native-proxy-type-fix.d.ts
 interface ProxyConstructor {}
 /**
  * The global `Proxy` constructor, retyped with the corrected
@@ -4950,13 +5220,13 @@ interface ProxyConstructor {}
  * @private
  */
 declare const NativeProxy: ProxyConstructor;
-//#endregion
-//#region src/reactive/-private/symbols.d.ts
 declare const SOURCE: "___(unique) Symbol(SOURCE)";
 /**
  * Symbol for the method used to request a mutable copy of an otherwise
  * immutable {@link ReactiveResource}.
  *
+ * @summary Deprecated symbol-keyed method on a ReactiveResource that resolves with an editable copy;
+ * use `checkout` instead.
  * @deprecated use the {@link checkout} utility function instead.
  */
 declare const Checkout: "___(unique) Symbol(Checkout)";
@@ -4965,8 +5235,6 @@ declare const Checkout: "___(unique) Symbol(Checkout)";
  * mutability, etc.) on a {@link ReactiveResource} or reactive field instance.
  */
 declare const Context: "___(unique) Symbol(Context)";
-//#endregion
-//#region src/reactive/-private/fields/managed-array.d.ts
 interface ManagedArray extends Omit<Array<unknown>, "[]"> {
   [SOURCE]: unknown[];
   identifier: ResourceKey;
@@ -4978,8 +5246,6 @@ interface ManagedArray extends Omit<Array<unknown>, "[]"> {
 declare class ManagedArray {
   constructor(context: KindContext<SchemaArrayField | ArrayField>, owner: ReactiveResource, data: unknown[]);
 }
-//#endregion
-//#region src/store/-private/record-arrays/resource-array.d.ts
 declare const IS_COLLECTION: "___(unique) Symbol(IS_COLLECTION)";
 type ProxiedMethod = (...args: unknown[]) => unknown;
 interface ReactiveResourceArrayCreateOptions {
@@ -5010,10 +5276,15 @@ interface ReactiveResourceArrayContext extends ReactiveResourceArrayCreateOption
  * as the base for relationship and legacy record-array types such as
  * {@link LegacyLiveArray}, {@link LegacyQueryArray} and {@link LegacyManyArray}.
  *
+ * The [Key Terminology](/guides/the-manual/caching/key-terms#resources) guide explains
+ * how it relates to resources.
+ *
  * Behaves like a native Array: `Array.isArray(arr)` and `arr instanceof Array`
  * both report `true`. The array stays in sync with the cache, updating
  * reactively as the underlying {@link ResourceKey}s change.
  *
+ * @summary Native-Array-compatible reactive list of records backed by cache keys, returned for collection responses
+ * and underlying relationship and legacy record arrays.
  * @public
  */
 interface ReactiveResourceArray<T = unknown> extends Omit<Array<T>, "[]"> {}
@@ -5037,8 +5308,6 @@ interface PrivateReactiveResourceArray<T = unknown> extends Omit<Array<T>, "[]">
   /** @private */
   [Context]: ReactiveResourceArrayContext;
 }
-//#endregion
-//#region src/store/-private/record-arrays/-utils.d.ts
 /**
  * LegacyArrays have the capability of updating via `array.update()`
  * and saving each contained record individually via `array.save()`
@@ -5104,8 +5373,6 @@ interface MinimumManager {
   mutate?(mutation: LocalRelationshipOperation): void;
   reloadHasMany?<T>(key: string, options?: BaseFinderOptions): Promise<ReactiveResourceArray> | PromiseManyArray<T>;
 }
-//#endregion
-//#region src/store/-private/record-arrays/legacy-live-array.d.ts
 /**
  * LiveArrays contain all the known records for a given `ResourceType`.
  *
@@ -5166,6 +5433,8 @@ interface MinimumManager {
  * and "bmw" will have populated LiveArrays, but the LiveArray for "car"
  * would be empty.
  *
+ * @summary Legacy reactive array of every record of one type in the store, returned by `store.peekAll` and
+ * `store.findAll`.
  * @legacy we recommend againt using LiveArrays. Use {@link Store.request} instead
  */
 interface LegacyLiveArray<T = unknown> extends LegacyArray<T> {
@@ -5190,8 +5459,6 @@ interface LegacyLiveArrayCreateOptions {
   source: ResourceKey[];
   type: string;
 }
-//#endregion
-//#region src/store/-private/record-arrays/legacy-query.d.ts
 /**
  * QueryArrays contain the primary records returned when querying
  * for records by `ResourceType`.
@@ -5262,6 +5529,8 @@ interface LegacyLiveArrayCreateOptions {
  * from the cache, but it does remove the array as well as the overhead it requires
  * from the store for book-keeping.
  *
+ * @summary Legacy immutable reactive array of the primary records returned by `store.query`, refreshable with
+ * `update()` and released with `destroy()`.
  * @legacy we recommend againt using QueryArrays. Use {@link Store.request} instead
  */
 interface LegacyQueryArray<T = unknown> extends LegacyLiveArray<T> {
@@ -5282,8 +5551,6 @@ interface LegacyQueryArray<T = unknown> extends LegacyLiveArray<T> {
    */
   meta: Meta | null;
 }
-//#endregion
-//#region src/store/-private/managers/record-array-manager.d.ts
 /**
  * This is a clever optimization.
  *
@@ -5374,8 +5641,6 @@ interface PrivateRecordArrayManager extends RecordArrayManager {
   _managed: Set<ReactiveResourceArray>;
   clear(isClear?: boolean): void;
 }
-//#endregion
-//#region src/store/-private/network/request-cache.d.ts
 declare const Touching: "___(unique) Symbol(Touching)";
 declare const RequestPromise: "___(unique) Symbol(RequestPromise)";
 /**
@@ -5507,8 +5772,6 @@ interface PrivateRequestStateService extends RequestStateService {
   _clearEntries(identifier: ResourceKey): void;
   _enqueue<T>(promise: Promise<T>, queryRequest: Request$1): Promise<T>;
 }
-//#endregion
-//#region src/store/-private/store-service.d.ts
 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;
@@ -5560,6 +5823,26 @@ interface Store$1 {
    * mechanism of presenting cache data to the ui for access
    * mutation, and interaction.
    *
+   * The Store treats whatever this hook returns as opaque, so a record can be
+   * anything from a fairly simple object to a robust proxy that links together
+   * associated records through relationships.
+   *
+   * That also lets a record implementation separate edit flows from create flows
+   * entirely. A [ReactiveResource](/api/@warp-drive-mirror/core/reactive/types/ReactiveResource)
+   * is not editable by default; calling
+   * [checkout](/api/@warp-drive-mirror/core/reactive/functions/checkout) on it gives access to
+   * an editable copy while the original stays read-only.
+   *
+   * Because records are created here and read their data from the {@link Store.cache | cache},
+   * record implementations should be able to interoperate both with each other and with
+   * any Cache. An app can therefore use more than one record implementation, either to give
+   * only some resource types enhanced features or to migrate from one implementation to
+   * another incrementally. The Store that
+   * [useLegacyStore](/api/@warp-drive-mirror/legacy/functions/useLegacyStore) produces does this:
+   * its hook creates a legacy `Model` for each resource type that only has a Model schema,
+   * and a ReactiveResource for every other type. Each Store creates one Cache, so an
+   * app that needs more than one Cache implementation uses more than one Store.
+   *
    * @param identifier - The Resource CacheKey
    * @param createRecordArgs - An object containing any properties passed to `store.createRecord`
    * @return A record instance
@@ -6539,6 +6822,10 @@ interface Store$1 {
  * The `Store` is the central piece of the ***Warp*Drive** experience. It connects
  * requests for data with schemas, caching and reactivity.
  *
+ * The [Setup](/guides/configuration/#configure-the-store) guide shows how to configure
+ * one, and [Making Requests](/guides/the-manual/requests/) shows how to request data
+ * through it.
+ *
  * While it's easy to use ***just*** ***Warp*Drive**'s request management, most projects will find they
  * require far more than basic fetch management. For this reason it's often best to start with a `Store`
  * even when you aren't sure yet.
@@ -6546,6 +6833,7 @@ interface Store$1 {
  * Most projects will only have a single `Store`, though using multiple distinct stores
  * is possible.
  *
+ * @summary Central coordinator that connects requests for data with schemas, the cache and reactivity.
  * @public
  * @hideconstructor
  */
@@ -6654,12 +6942,25 @@ declare class Store$1 extends BaseClass {
    */
   getRequestStateService(): RequestStateService;
   /**
-   * ::: tip 💡 For a more complete overview see the [Request Guide](/guides/2-requests/1-overview)
+   * ::: tip 💡 For a more complete overview see the [Request Guide](/guides/the-manual/requests/)
    * :::
    *
    * Issue a request via the configured {@link RequestManager},
    * inserting the response into the {@link Store.cache | cache} and handing
-   * back a {@link Future} which resolves to a {@link ReactiveDocument | ReactiveDocument}
+   * back a {@link Future} which resolves to a {@link ReactiveDocument | ReactiveDocument}.
+   * Use `store.request` for anything the Store's cache should own, which is nearly all app
+   * code; reach for {@link RequestManager.request | requestManager.request} directly only when
+   * there is no `Store` involved, or you specifically want the unprocessed
+   * {@link StructuredDocument}.
+   *
+   * #### Building Requests
+   *
+   * `requestConfig` can be written by hand, but for anything reused more than once prefer a
+   * request builder — a plain function that returns the right shape for `store.request`. This
+   * repo ships builders for common operations (`findRecord`, `query`, `createRecord`, and more)
+   * for {json:api}, REST, and ActiveRecord-style APIs in `@warp-drive-mirror/utilities`; each builder's
+   * return value also carries its own response type, so `RT` below is inferred automatically
+   * instead of being written by hand. See [Builders](/guides/the-manual/requests/builders.md).
    *
    * #### Request Cache Keys
    *
@@ -6704,6 +7005,29 @@ declare class Store$1 extends BaseClass {
    * is that `store.request` will convert the response into a {@link ReactiveDocument}
    * containing {@link Store.instantiateRecord | ReactiveResources}.
    *
+   * A {@link ReactiveDocument} is either a {@link ReactiveDataDocument} (`content.data` holds
+   * the resource(s)) or a {@link ReactiveErrorDocument} (`content.errors` holds the API's error
+   * objects), depending on whether the `Future` resolves or rejects; both carry the response's
+   * `content.meta`. Read either state reactively with {@link getRequestState} or the
+   * `<Request />` component instead of always `await`-ing the `Future` directly — see
+   * [Using the Response](/guides/the-manual/requests/using-the-response.md).
+   *
+   * #### Typing The Response
+   *
+   * `request<RT>` accepts an explicit type argument, but the more common path is to let it be
+   * inferred: build the request with {@link withResponseType} (or {@link withReactiveResponse}
+   * for the common reactive-document case), or with a builder from `@warp-drive-mirror/utilities` as
+   * described above, and `RT` is inferred from the request object itself. See
+   * [Typing Requests](/guides/the-manual/requests/typing-requests.md) for the full mechanism.
+   *
+   * @example
+   * ```ts
+   * import { findRecord } from '@warp-drive-mirror/utilities/json-api';
+   *
+   * const { content } = await store.request(findRecord('user', '1'));
+   * content.data; // ReactiveResource, typed from the builder's response type
+   * ```
+   *
    * @public
    */
   request<RT>(requestConfig: StoreRequestInput<RT>): Future<RT>;
@@ -7134,8 +7458,6 @@ declare function assertPrivateStore(store: unknown): asserts store is PrivateSto
  * @private
  */
 declare function isPrivateStore(store: unknown): PrivateStore;
-//#endregion
-//#region src/store/-private/utils/construct-resource.d.ts
 /**
  * Given an existing resource identifier object (or a {@link ResourceKey}),
  * returns it unchanged aside from coercing its `id`, if present, to a string.
@@ -7171,8 +7493,6 @@ declare function constructResource(type: string, id: string, lid?: string | null
  * @private
  */
 declare function constructResource(type: string, id?: string | number | null, lid?: string | null): ResourceIdentifierObject;
-//#endregion
-//#region src/store/-private/utils/coerce-id.d.ts
 type Coercable = string | number | boolean | null | undefined | symbol;
 /**
  * Normalizes a resource `id` entering the store to a string (or `null`).
@@ -7195,8 +7515,6 @@ declare function coerceId(id: unknown): string | null;
  * @private
  */
 declare function ensureStringId(id: Coercable): string;
-//#endregion
-//#region src/store/-private/utils/normalize-model-name.d.ts
 /**
  * Normalizes a resource `type` to its dasherized form, e.g. `myClass` to
  * `my-class`. Re-exported elsewhere as `_deprecatingNormalize`.
@@ -7208,8 +7526,6 @@ declare function ensureStringId(id: Coercable): string;
  * @private
  */
 declare function normalizeModelName(type: string): string;
-//#endregion
-//#region src/store/-private/record-arrays/legacy-many-array.d.ts
 /**
 A `ManyArray` is a `MutableArray` that represents the contents of a has-many
 relationship.
@@ -7250,6 +7566,7 @@ the has-many.
 We call the record to which a relationship belongs-to the
 relationship's _owner_.
 
+@summary Legacy mutable reactive array holding the related records of a legacy or linksMode has-many relationship.
 @public
 */
 interface LegacyManyArray<T = unknown> extends ReactiveResourceArray<T> {
@@ -7349,8 +7666,6 @@ interface LegacyManyArrayCreateOptions extends LegacyLiveArrayCreateOptions {
  * @private
  */
 declare function createLegacyManyArray<T>(options: LegacyManyArrayCreateOptions): LegacyManyArray<T>;
-//#endregion
-//#region src/store/-private/debug/utils.d.ts
 /**
  * Opens a collapsed console group for a `cache` scoped debug message, using
  * `type`/`lid`/`bucket`/`key` to build the colorized group label.
@@ -7400,8 +7715,6 @@ declare function log(scope: "reactive-ui", prefix: string, type: string, lid: st
  * @private
  */
 declare function log(scope: "notify", prefix: string, type: string, lid: string, bucket: string, key: string): void;
-//#endregion
-//#region src/reactive/-private/default-mode.d.ts
 type ModeName = "polaris" | "legacy";
 interface BaseContext {
   /**
@@ -7480,8 +7793,6 @@ interface KindContext<T extends FieldSchema | IdentityField | HashField> extends
    */
   signals: SignalStore;
 }
-//#endregion
-//#region src/reactive/-private/record.d.ts
 interface ReactiveResource {
   /**
    * Create an editable copy of the record
@@ -7516,10 +7827,14 @@ interface PrivateReactiveResource extends ReactiveResource {
  * and a ResourceKey to transform data from the cache into a rich, reactive
  * object.
  *
+ * The [ResourceSchemas](/guides/the-manual/schemas/resources/) guide shows how to
+ * define the schema it reads.
+ *
  * This class is not directly instantiable. To use it, you should
  * configure the store's `instantiateRecord` and `teardownRecord` hooks
  * with the matching hooks provided by this package.
  *
+ * @summary The rich, reactive record object that presents a resource's cached data through its `ResourceSchema`.
  * @hideconstructor
  * @public
  */
@@ -7545,6 +7860,8 @@ declare class ReactiveResource {
  * Edits to editable resources will be automatically committed if a new
  * payload from the cache matches their existing value.
  *
+ * @summary Resolves with an editable copy of an immutable `ReactiveResource` so its fields can be
+ * changed locally.
  * @public
  *
  * @returns a promise that resolves to the editable resource
@@ -7559,11 +7876,11 @@ declare function checkout<T>(resource: unknown): Promise<T & ReactiveResource>;
  * approach is for either the API or a Handler to reflect saved
  * changes back to update the cache.
  *
+ * @summary Forcibly makes an editable resource's local changes its new remote (immutable) state,
+ * bypassing a save round-trip.
  * @public
  */
 declare function commit(record: ReactiveResource): Promise<void>;
-//#endregion
-//#region src/reactive/-private/hooks.d.ts
 /**
  * The store's default `instantiateRecord` hook implementation, which
  * produces a {@link ReactiveResource} for `identifier` using the resource
@@ -7573,6 +7890,8 @@ declare function commit(record: ReactiveResource): Promise<void>;
  * schema is `legacy`, matching the historical behavior of assigning initial
  * properties when creating a new legacy record.
  *
+ * @summary Default store `instantiateRecord` hook that creates a `ReactiveResource` for a resource key
+ * from its registered schema.
  * @public
  */
 declare function instantiateRecord(store: Store$1, identifier: ResourceKey, createArgs?: Record<string, unknown>): ReactiveResource;
@@ -7581,11 +7900,11 @@ declare function instantiateRecord(store: Store$1, identifier: ResourceKey, crea
  * that `record` is a {@link ReactiveResource} and invokes its `Destroy`
  * behavior.
  *
+ * @summary Default store `teardownRecord` hook that destroys a `ReactiveResource` when the store
+ * releases it.
  * @public
  */
 declare function teardownRecord(record: unknown): void;
-//#endregion
-//#region src/request/-private/fetch.d.ts
 /**
  * ```ts
  * import { Fetch } from '@warp-drive-mirror/core';
@@ -7594,6 +7913,9 @@ declare function teardownRecord(record: unknown): void;
  * A basic Fetch Handler which converts a request into a
  * `fetch` call presuming the response to be `json`.
  *
+ * The [Making Requests](/guides/the-manual/requests/#requests-do-not-need-to-use-fetch)
+ * guide shows where it sits in the handler chain.
+ *
  * ```ts
  * import { RequestManager, Fetch } from '@warp-drive-mirror/core';
  *
@@ -7601,6 +7923,8 @@ declare function teardownRecord(record: unknown): void;
  *   .use([Fetch]);
  * ```
  *
+ * @summary Terminal request handler that sends the request with native `fetch` and resolves with the
+ * parsed JSON body, turning HTTP failures into errors.
  * @public
  * @badge Handler
  */
@@ -7614,8 +7938,6 @@ declare const Fetch: {
    */
   request<T>(context: Context$1): Promise<T>;
 };
-//#endregion
-//#region src/store/-private/default-cache-policy.d.ts
 type UnsubscribeToken = object;
 type CacheOperation = "added" | "removed" | "updated" | "state";
 type DocumentCacheOperation = "invalidated" | "added" | "removed" | "updated" | "state";
@@ -7646,6 +7968,9 @@ type Store = {
  * Interface of a parsed Cache-Control header value.
  *
  * - [MDN Cache-Control Reference](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Cache-Control)
+ *
+ * @summary The directives of a `Cache-Control` header as an object of flags and second counts, as
+ * returned by `parseCacheControl`.
  */
 interface CacheControlValue {
   /** Indicates the response will never change; parsed but not currently used by this cache policy's expiration logic. */
@@ -7701,6 +8026,8 @@ interface CacheControlValue {
  *
  * See also {@link CacheControlValue} and [Response Directives](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Cache-Control#response_directives)
  *
+ * @summary Parses a `Cache-Control` header string into a `CacheControlValue` object, caching results
+ * per header string.
  * @public
  */
 declare function parseCacheControl(header: string): CacheControlValue;
@@ -7763,6 +8090,9 @@ interface PolicyConfigConstraints {
 /**
  * The configuration options for the {@link DefaultCachePolicy}
  *
+ * The [Advanced Store Configuration](/guides/configuration/advanced#decide-how-long-requests-are-valid-for-with-a-cachepolicy)
+ * guide shows a policy configured with them.
+ *
  * ```ts [app/services/store.ts]
  * import { Store } from '@warp-drive-mirror/core';
  * import { DefaultCachePolicy } from '@warp-drive-mirror/core/store'; // [!code focus]
@@ -7774,6 +8104,8 @@ interface PolicyConfigConstraints {
  * }
  * ```
  *
+ * @summary Options for `DefaultCachePolicy`: soft and hard expiration times, header-based expiration
+ * constraints, and test-mode behavior.
  */
 interface PolicyConfig {
   /**
@@ -7854,6 +8186,9 @@ interface PolicyConfig {
 /**
  * A basic {@link CachePolicy} that can be added to the Store service.
  *
+ * The [Advanced Store Configuration](/guides/configuration/advanced#decide-how-long-requests-are-valid-for-with-a-cachepolicy)
+ * guide shows how to configure it.
+ *
  * ```ts [app/services/store.ts]
  * import { Store } from '@warp-drive-mirror/core';
  * import { DefaultCachePolicy } from '@warp-drive-mirror/core/store'; // [!code focus]
@@ -7912,6 +8247,7 @@ interface PolicyConfig {
  * for which {@link CacheOptions.types | cacheOptions.types} was provided
  * when a request with an `OpCode` of `"createRecord"` is successful and also includes
  * a matching type in its own `cacheOptions.types` array.
+
  * :::tip 💡 TIP
  * Abstracting this behavior via builders is recommended to ensure consistency.
  * :::
@@ -7931,6 +8267,8 @@ interface PolicyConfig {
  * This behavior can be opted out of by setting `disableTestOptimization = true`
  * in the policy config.
  *
+ * @summary The built-in cache policy, which expires cached requests using expiration headers or time
+ * since the response `date`, and invalidates queries after matching creates.
  * @public
  */
 declare class DefaultCachePolicy implements CachePolicy {
@@ -8010,14 +8348,16 @@ declare class DefaultCachePolicy implements CachePolicy {
    */
   isSoftExpired(cacheKey: RequestKey, store: Store): boolean;
 }
-//#endregion
-//#region src/index.d.ts
 /**
+ * @summary Deprecated alias for `ReactiveDocument`, the reactive wrapper around a request's response document.
  * @deprecated use {@link ReactiveDocument} instead
  */
 type Document<T, M extends Meta | undefined = Meta | undefined, E extends object = object, EM extends Meta | undefined = M> = ReactiveDocument<T, M, E, EM>;
 /**
  * Options for setting up a Store instance with `useRecommendedStore`.
+ *
+ * @summary Configures the cache, cache policy, request handlers, schemas, and schema extensions that
+ * `useRecommendedStore` wires into a Store class.
  */
 interface StoreSetupOptions<T extends Cache = Cache> {
   /**
@@ -8102,6 +8442,9 @@ declare class ConfiguredStore<T extends {
  * Creates a configured Store class with recommended defaults
  * for schema handling, reactivity, caching, and request management.
  *
+ * The [Setup](/guides/configuration/#configure-the-store) guide walks through
+ * configuring the store with it.
+ *
  * ```ts
  * import { useRecommendedStore } from '@warp-drive-mirror/core';
  * import { JSONAPICache } from '@warp-drive-mirror/json-api';
@@ -8204,6 +8547,9 @@ declare class ConfiguredStore<T extends {
  * {@link RequestManager} won't have it set unless the caller supplies it
  * explicitly, so a handler relying on it should treat it as optional (as
  * `LoggingHandler` does above).
+ *
+ * @summary Builds a Store subclass preconfigured with the given cache, schemas, and handlers, plus
+ * `Fetch`, `CacheHandler`, and a default cache policy.
  */
 declare function useRecommendedStore<T extends Cache, Policy extends CachePolicy>(options: StoreSetupOptions<T> & {
   policy: Policy;
@@ -8218,12 +8564,12 @@ declare function useRecommendedStore<T extends Cache>(options: StoreSetupOptions
 declare function useRecommendedStore<T extends Cache>(options: StoreSetupOptions<T>, StoreKlass?: typeof Store$1): typeof ConfiguredStore<{
   cache: T;
 }>;
-//#endregion
-//#region src/signals/promise-state.d.ts
 /**
  * The state of a promise in the "pending"
  * state. This is the default initial state.
  *
+ * @summary The `getPromiseState` state for a promise that has not yet settled, with `isPending` true and
+ * no value or reason.
  */
 interface PendingPromise {
   /**
@@ -8287,6 +8633,8 @@ interface PendingPromise {
  * This is the state of a promise that has resolved
  * successfully.
  *
+ * @summary The `getPromiseState` state for a promise that resolved, with `isSuccess` true and the
+ * resolved `value`.
  */
 interface ResolvedPromise<T> {
   /**
@@ -8350,6 +8698,8 @@ interface ResolvedPromise<T> {
  * This is the state of a promise that has rejected
  * with an error.
  *
+ * @summary The `getPromiseState` state for a promise that rejected, with `isError` true and the
+ * rejection `reason`.
  */
 interface RejectedPromise<E> {
   /**
@@ -8417,11 +8767,16 @@ interface RejectedPromise<E> {
  * - {@link ResolvedPromise}
  * - {@link RejectedPromise}
  *
+ * @summary The reactive pending, fulfilled, or rejected state of a promise, as returned by
+ * `getPromiseState`.
  */
 type PromiseState<T = unknown, E = unknown> = PendingPromise | ResolvedPromise<T> | RejectedPromise<E>;
 /**
  * Returns a reactive state-machine for the provided promise or awaitable.
  *
+ * The [Async as Reactive State](/guides/the-manual/reactivity/derivation) guide shows
+ * how to use it in place of tracked loading and error state.
+ *
  * Repeat calls to `getPromiseState` with the same promise will return the same state object
  * making is safe and easy to use in templates and JavaScript code to produce reactive
  * behaviors around promises.
@@ -8471,15 +8826,18 @@ type PromiseState<T = unknown, E = unknown> = PendingPromise | ResolvedPromise<T
  * If looking to use in a template, consider also the `<Await />` component.
  *
  * See also {@link PromiseState}
+ *
+ * @summary Returns a cached, reactive state object tracking whether a promise is pending, fulfilled, or
+ * rejected, for use in JS or templates.
  */
 declare function getPromiseState<T = unknown, E = unknown>(promise: Promise<T> | Awaitable<T, E>): Readonly<PromiseState<T, E>>;
-//#endregion
-//#region src/signals/request-state.d.ts
 /**
  * Lazily consumes the stream of a request, providing a number of
  * reactive properties that can be used to build UIs that respond
  * to the progress of a request.
  *
+ * @summary Reactive download progress for a request, such as bytes loaded and timing, built by lazily
+ * reading its response stream.
  * @hideconstructor
  */
 declare class RequestLoadingState {
@@ -8699,9 +9057,11 @@ interface RejectedRequest<RT, E extends StructuredErrorDocument = StructuredErro
   response: Response | ResponseInfo | null;
 }
 /**
- * The state of a request in the "cancelled" state.
- * This is the state of a promise that has been
- * cancelled.
+ * The state of a request that was aborted before it settled.
+ *
+ * A cancelled request has `status: 'cancelled'` and its `reason` is an
+ * `AbortError`. `isError` is also `true`, as for a {@link RejectedRequest},
+ * so check `status` or `isCancelled` to tell the two apart.
  *
  */
 interface CancelledRequest<RT, E extends StructuredErrorDocument = StructuredErrorDocument> {
@@ -8835,11 +9195,33 @@ interface CancelledRequest<RT, E extends StructuredErrorDocument = StructuredErr
  * - {@link RejectedRequest}
  * - {@link CancelledRequest}
  *
+ * @summary The reactive pending, fulfilled, rejected, or cancelled state of a request `Future`, as
+ * returned by `getRequestState`.
  */
 type RequestState<RT = unknown, E extends StructuredErrorDocument = StructuredErrorDocument> = PendingRequest | ResolvedRequest<RT> | RejectedRequest<RT, E> | CancelledRequest<RT, E>;
 /**
  * `getRequestState` can be used in both JavaScript and Template contexts.
  *
+ * It returns a {@link RequestState}: a reactive object that updates as the
+ * request advances. Calling it again with the same {@link Future} returns the
+ * same object. Check `status` to narrow it to one of four states:
+ *
+ * - {@link PendingRequest} (`'pending'`) is the initial state, before the
+ *   request settles.
+ * - {@link ResolvedRequest} (`'fulfilled'`) holds the response content on `value`.
+ * - {@link RejectedRequest} (`'rejected'`) holds the error on `reason`.
+ * - {@link CancelledRequest} (`'cancelled'`) is a request that was aborted.
+ *   `isError` is also `true` for a cancelled request, so check `status` or
+ *   `isCancelled` rather than `isError` if you handle it differently.
+ *
+ * Every state also exposes a {@link RequestLoadingState} on `loadingState`
+ * for tracking the progress of the response stream.
+ *
+ * The [Reactive Control Flow](/guides/the-manual/reactivity/control-flow) guide shows
+ * how to render request states with it, and
+ * [Using The Response](/guides/the-manual/requests/using-the-response) covers the
+ * `Future` it reads.
+ *
  * ```ts
  * import { getRequestState } from '@warp-drive-mirror/ember';
  *
@@ -8886,10 +9268,12 @@ type RequestState<RT = unknown, E extends StructuredErrorDocument = StructuredEr
  * which offers a number of additional capabilities for requests *beyond* what
  * `RequestState` provides.
  *
+ * @param future - the request {@link Future} to track, as returned by `store.request` or `requestManager.request`
+ * @return the cached {@link RequestState} for `future`
+ * @summary Returns a cached, reactive state object tracking a request `Future` through pending, success,
+ * error, and cancellation.
  */
 declare function getRequestState<RT, E>(future: Future<RT>): Readonly<RequestState<RT, StructuredErrorDocument<E>>>;
-//#endregion
-//#region src/signals/request-subscription.d.ts
 /**
  * A symbol used to dispose of a {@link RequestSubscription} when the
  * component or context using it is torn down.
@@ -8898,16 +9282,25 @@ declare const DISPOSE: "(symbol) dispose";
 /**
  * The individual autorefresh strategies a {@link RequestSubscription}
  * may combine, see {@link AutorefreshBehaviorCombos}.
+ *
+ * @summary One autorefresh trigger for a request subscription: on reconnecting (`online`), on a timer
+ * (`interval`), or on store invalidation (`invalid`).
  */
 type AutorefreshBehaviorType = "online" | "interval" | "invalid";
 /**
  * The value accepted by {@link SubscriptionArgs.autorefresh}: either a
  * boolean, a single {@link AutorefreshBehaviorType}, or a comma-separated
  * combination of up to three of them.
+ *
+ * @summary The accepted values for a request subscription's `autorefresh` option: a boolean or a
+ * comma-separated mix of `online`, `interval`, and `invalid`.
  */
 type AutorefreshBehaviorCombos = boolean | AutorefreshBehaviorType | `${AutorefreshBehaviorType},${AutorefreshBehaviorType}` | `${AutorefreshBehaviorType},${AutorefreshBehaviorType},${AutorefreshBehaviorType}`;
 /**
  * Utilities to assist in recovering from the error.
+ *
+ * @summary The online and visibility state plus a `retry` function that a request subscription exposes
+ * for recovering from a failed request.
  */
 interface RecoveryFeatures {
   /**
@@ -8925,6 +9318,9 @@ interface RecoveryFeatures {
 }
 /**
  * Utilities for keeping the request fresh
+ *
+ * @summary The online, visibility, and refreshing state plus `refresh`, `reload`, and `abort` functions a
+ * request subscription exposes alongside successful content.
  */
 interface ContentFeatures<RT> {
   /**
@@ -8958,6 +9354,9 @@ interface ContentFeatures<RT> {
 }
 /**
  * The args accepted by the `<Request />` component.
+ *
+ * @summary The arguments of the `<Request />` component: the request or query to run, autorefresh
+ * options, and an optional store or subscription.
  */
 interface RequestArgs<RT, E> extends SubscriptionArgs<RT, E> {
   /**
@@ -8976,6 +9375,8 @@ interface RequestArgs<RT, E> extends SubscriptionArgs<RT, E> {
 }
 /**
  * The args accepted by a {@link RequestSubscription}.
+ *
+ * @summary Options for a request subscription: the request or query to monitor and its autorefresh settings.
  */
 interface SubscriptionArgs<RT, E> {
   /**
@@ -9040,6 +9441,8 @@ interface RequestSubscription<RT, E> {
 /**
  * A reactive class
  *
+ * @summary Reactive subscription that monitors a request or query, tracking online, visibility and refresh state and
+ * handling autorefresh, reload and retry.
  * @hideconstructor
  */
 declare class RequestSubscription<RT, E> {
@@ -9104,10 +9507,11 @@ declare class RequestSubscription<RT, E> {
 /**
  * Creates a {@link RequestSubscription}, the reactive class powering the
  * `<Request />` component's autorefresh, retry, and refresh behaviors.
+ *
+ * @summary Creates a reactive subscription to a request or query that tracks its state and handles
+ * autorefresh, retry, and refresh.
  */
 declare function createRequestSubscription<RT, E>(store: Store$1 | RequestManager, args: SubscriptionArgs<RT, E>): RequestSubscription<RT, E>;
-//#endregion
-//#region src/signals/reactivity/internal.d.ts
 interface Initializer {
   value: () => unknown;
 }
@@ -9229,6 +9633,5 @@ declare function peekInternalSignal(signals: SignalStore | undefined, key: strin
  * signal, scheduling any of its consumers for re-render/re-computation.
  */
 declare function notifyInternalSignal(signal: WarpDriveSignal | undefined): void;
-//#endregion
-export { PrivateRequestStateService as $, Context$1 as $n, ExtensibleField as $t, PolicyConfig as A, EnableHydration as An, withReactiveResponse as At, logGroup as B, PostQueryRequestOptions as Bn, GraphEdge as Bt, getPromiseState as C, setIdentifierResetMethod as Cn, ReactiveDocument as Ct, useRecommendedStore as D, ConstrainedRequestOptions as Dn, StoreRequestContext as Dt, StoreSetupOptions as E, CacheOptions as En, CacheHandler as Et, PrivateReactiveResource as F, ImmutableCreateRequestOptions as Fn, createDeferred as Ft, ensureStringId as G, ResponseInfo as Gn, Cache as Gt, createLegacyManyArray as H, RemotelyAccessibleIdentifier as Hn, ImplicitEdge as Ht, ReactiveResource as I, ImmutableDeleteRequestOptions as In, graphFor as It, PrivateStore as J, StructuredDataDocument as Jn, CacheCapabilitiesManager$1 as Jt, constructResource as K, STRUCTURED as Kn, ChangedAttributesHash as Kt, checkout as L, ImmutableHeaders as Ln, peekGraph as Lt, Fetch as M, FindRecordRequestOptions as Mn, Awaitable as Mt, instantiateRecord as N, HTTPMethod as Nn, getPromiseResult as Nt, CacheControlValue as O, CreateRequestOptions as On, StoreRequestInput as Ot, teardownRecord as P, IS_FUTURE as Pn, setPromiseResult as Pt, FindRecordQuery as Q, FetchError as Qn, CAUTION_MEGA_DANGER_ZONE_Extension as Qt, commit as R, ImmutableRequestInfo as Rn, isBelongsTo as Rt, ResolvedPromise as S, setIdentifierGenerationMethod as Sn, ReactiveDataDocument as St, Document as T, setKeyInfoForResource as Tn, CachePolicy as Tt, normalizeModelName as U, RequestContext as Un, CollectionEdge as Ut, LegacyManyArray as V, QueryRequestOptions as Vn, ResourceEdge as Vt, coerceId as W, RequestInfo as Wn, UpgradedMeta as Wt, assertPrivateStore as X, StructuredErrorDocument as Xn, RelationshipsSchema as Xt, Store$1 as Y, StructuredDocument as Yn, AttributesSchema as Yt, isPrivateStore as Z, UpdateRequestOptions as Zn, SchemaService as Zt, RequestState as _, NotificationType as _n, recordIdentifierFor as _t, notifyInternalSignal as a, registerDerivations as an, NextFn as ar, fastPush as at, PromiseState as b, isResourceKey as bn, PrivateCacheCapabilitiesManager as bt, AutorefreshBehaviorCombos as c, FindAllOptions as cn, PrivateReactiveResourceArray as ct, RecoveryFeatures as d, QueryOptions as dn, Checkout as dt, ExtensionDef as en, CacheHandler$1 as er, Request$1 as et, RequestArgs as f, ModelSchema as fn, Context as ft, RequestLoadingState as g, NotificationManager$1 as gn, _clearCaches as gt, createRequestSubscription as h, NotificationChannel as hn, StoreMap as ht, makeInitializer as i, fromIdentity as in, ManagedRequestPriority as ir, RecordArrayManager as it, parseCacheControl as j, FindRecordOptions$2 as jn, withResponseType as jt, DefaultCachePolicy as k, DeleteRequestOptions as kn, withBrand as kt, ContentFeatures as l, FindRecordOptions as ln, ReactiveResourceArray as lt, SubscriptionArgs as m, DocumentCacheOperation$1 as mn, InstanceCache as mt, WarpDriveSignal as n, SchemaService$1 as nn, Future as nr, RequestStateService as nt, peekInternalSignal as o, withDefaults as on, RequestManager as or, LegacyQueryArray as ot, RequestSubscription as p, CacheOperation$1 as pn, NativeProxy as pt, CreateRecordProperties as q, SkipCache as qn, RelationshipDiff as qt, getOrCreateInternalSignal as r, Transformation as rn, Handler as rr, SaveRecordMutation as rt, withSignalStore as s, BaseFinderOptions as sn, LegacyLiveArray as st, SignalStore as t, ProcessedExtension as tn, Deferred as tr, RequestCacheRequestState as tt, DISPOSE as u, LegacyResourceQuery as un, ManagedArray as ut, getRequestState as v, NotifyKeys as vn, setRecordIdentifier as vt, ConfiguredStore as w, setIdentifierUpdateMethod as wn, ReactiveErrorDocument as wt, RejectedPromise as x, setIdentifierForgetMethod as xn, assertPrivateCapabilities as xt, PendingPromise as y, isRequestKey as yn, storeFor as yt, log as z, ImmutableUpdateRequestOptions as zn, Graph as zt };
-//# sourceMappingURL=internal-BrqYbG_y.d.ts.map
+export { PrivateStore as $, STRUCTURED as $n, CacheCapabilitiesManager$1 as $t, Document as A, LegacyResourceQuery as An, CachePolicy as At, PrivateReactiveResource as B, HTTPMethod as Bn, createDeferred as Bt, getRequestState as C, Transformation as Cn, setRecordIdentifier as Ct, ResolvedPromise as D, BaseFinderOptions as Dn, ReactiveDataDocument as Dt, RejectedPromise as E, withDefaults as En, assertPrivateCapabilities as Et, PolicyConfig as F, CreateRequestOptions as Fn, withReactiveResponse as Ft, logGroup as G, ImmutableRequestInfo as Gn, GraphEdge as Gt, checkout as H, ImmutableCreateRequestOptions as Hn, peekGraph as Ht, parseCacheControl as I, DeleteRequestOptions as In, withResponseType as It, normalizeModelName as J, QueryRequestOptions as Jn, CollectionEdge as Jt, LegacyManyArray as K, ImmutableUpdateRequestOptions as Kn, ResourceEdge as Kt, Fetch as L, EnableHydration as Ln, Awaitable as Lt, useRecommendedStore as M, ModelSchema as Mn, StoreRequestContext as Mt, CacheControlValue as N, CacheOptions as Nn, StoreRequestInput as Nt, getPromiseState as O, FindAllOptions as On, ReactiveDocument as Ot, DefaultCachePolicy as P, ConstrainedRequestOptions as Pn, withBrand as Pt, CreateRecordProperties as Q, ResponseInfo as Qn, RelationshipDiff as Qt, instantiateRecord as R, FindRecordOptions$2 as Rn, getPromiseResult as Rt, ResolvedRequest as S, SchemaService$1 as Sn, recordIdentifierFor as St, PromiseState as T, registerDerivations as Tn, PrivateCacheCapabilitiesManager as Tt, commit as U, ImmutableDeleteRequestOptions as Un, isBelongsTo as Ut, ReactiveResource as V, IS_FUTURE as Vn, graphFor as Vt, log as W, ImmutableHeaders as Wn, Graph as Wt, ensureStringId as X, RequestContext as Xn, Cache as Xt, coerceId as Y, RemotelyAccessibleIdentifier as Yn, UpgradedMeta as Yt, constructResource as Z, RequestInfo as Zn, ChangedAttributesHash as Zt, CancelledRequest as _, SchemaService as _n, Context as _t, notifyInternalSignal as a, NotifyKeys as an, FetchError as ar, Request$1 as at, RequestLoadingState as b, ExtensionDef as bn, StoreMap as bt, AutorefreshBehaviorCombos as c, isRequestKey as cn, Deferred as cr, SaveRecordMutation as ct, DISPOSE as d, setIdentifierGenerationMethod as dn, ManagedRequestPriority as dr, LegacyQueryArray as dt, CacheOperation$1 as en, SkipCache as er, Store$1 as et, RecoveryFeatures as f, setIdentifierResetMethod as fn, NextFn as fr, LegacyLiveArray as ft, createRequestSubscription as g, RelationshipsSchema as gn, Checkout as gt, SubscriptionArgs as h, AttributesSchema as hn, ManagedArray as ht, makeInitializer as i, NotificationType as in, UpdateRequestOptions as ir, PrivateRequestStateService as it, StoreSetupOptions as j, QueryOptions as jn, CacheHandler as jt, ConfiguredStore as k, FindRecordOptions as kn, ReactiveErrorDocument as kt, AutorefreshBehaviorType as l, isResourceKey as ln, Future as lr, RecordArrayManager as lt, RequestSubscription as m, setKeyInfoForResource as mn, ReactiveResourceArray as mt, WarpDriveSignal as n, NotificationChannel as nn, StructuredDocument as nr, isPrivateStore as nt, peekInternalSignal as o, FieldValueIdentity as on, Context$1 as or, RequestCacheRequestState as ot, RequestArgs as p, setIdentifierUpdateMethod as pn, RequestManager as pr, PrivateReactiveResourceArray as pt, createLegacyManyArray as q, PostQueryRequestOptions as qn, ImplicitEdge as qt, getOrCreateInternalSignal as r, NotificationManager$1 as rn, StructuredErrorDocument as rr, FindRecordQuery as rt, withSignalStore as s, fieldValueIdentity as sn, CacheHandler$1 as sr, RequestStateService as st, SignalStore as t, DocumentCacheOperation$1 as tn, StructuredDataDocument as tr, assertPrivateStore as tt, ContentFeatures as u, setIdentifierForgetMethod as un, Handler as ur, fastPush as ut, PendingRequest as v, CAUTION_MEGA_DANGER_ZONE_Extension as vn, NativeProxy as vt, PendingPromise as w, fromIdentity as wn, storeFor as wt, RequestState as x, ProcessedExtension as xn, _clearCaches as xt, RejectedRequest as y, ExtensibleField as yn, InstanceCache as yt, teardownRecord as z, FindRecordRequestOptions as zn, setPromiseResult as zt };
+//# sourceMappingURL=internal-D_WIXC4r.d.ts.map