@warp-drive-mirror/core 5.10.0-alpha.10 → 5.10.0-alpha.13

package/dist/{internal-9XuWZdDv.d.ts → internal-CgOlgOt3.d.ts}

@@ -1,21 +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 { 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-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";
+import { c as RequestKey, l as ResourceKey, n as CacheKeyType, s as PersistedResourceKey } from "./identifier-B_tK3FUw.js";
+import { t as QueryParamsSerializationOptions } from "./params-dbHiSOMF.js";
+import { a as Type, n as RequestSignature } from "./symbols-Cu9un1NR.js";
+import { c as TypedRecordInstance, i as OpaqueRecordInstance$1, o as TypeFromInstance, s as TypeFromInstanceOrString } from "./record-DDxPtzcY.js";
+import { i as Value, n as ObjectValue } from "./raw-CiC64nCY.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-BxzNsCg0.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-D6173Q_a.js";
+import { n as HashFn, r as Transformation$1, t as Derivation } from "./concepts-DzuY5M1K.js";
+import { n as WithPartial } from "./utils-CNmQoKm8.js";
+import { t as ResourceBlob } from "./aliases-BQmAxXmb.js";
+import { t as Change } from "./change-DClXcHvr.js";
+import { n as Mutation } from "./mutations-C81gbYjB.js";
+import { r as ResourceRelationship, t as CollectionRelationship } from "./relationship-BlGIXgj4.js";
+import { i as MergeOperation, o as Operation$1 } from "./operations-B4pQM7D6.js";
+import { t as ApiError } from "./error-APuUdUGk.js";
+import { o as SingleResourceDataDocument, r as ResourceDocument, t as CollectionResourceDataDocument } from "./document-Ni8Ns26t.js";
+import { i as RemoteRelationshipOperation, n as LocalRelationshipOperation, t as DeleteRecordOperation } from "./graph-rjTyJ-gd.js";
+import { i as SignalRef, t as ARRAY_SIGNAL } from "./configure-CjsojjiI.js";
 //#region src/request/-private/manager.d.ts
 /**
  * ## Import
@@ -24,7 +24,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 +48,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 +85,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 +137,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 +167,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
    */
@@ -187,6 +236,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 +254,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 +274,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 +336,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 +348,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.
 
@@ -388,6 +452,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 +474,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 {
@@ -452,6 +520,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 {
@@ -517,6 +587,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 {
   /**
@@ -562,12 +635,18 @@ interface FetchError extends DOMException {
  * 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 +659,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 +718,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 +755,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 +788,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 +831,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 +881,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 +927,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 +972,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 +1015,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 +1052,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 +1067,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 +1097,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 +1127,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 +1212,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 +1233,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 +1329,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 +1356,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 +1394,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 {
   /**
@@ -1335,6 +1483,8 @@ type KeyOrString<T> = keyof T & string extends never ? string : keyof T & string
  * 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> {
   /**
@@ -1532,6 +1682,9 @@ declare class RecordReference {
  * 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.
+ *
+ * @summary Legacy reload, background-reload, include, and adapterOptions settings shared by `store.findRecord` and
+ * `store.findAll`.
  */
 interface BaseFinderOptions {
   /**
@@ -1563,6 +1716,9 @@ interface BaseFinderOptions {
 }
 /**
  * Options for `store.findRecord()`.
+ *
+ * @summary Legacy options for `store.findRecord`, adding a discouraged `preload` of field values to the shared
+ * reload and adapter settings.
  */
 interface FindRecordOptions extends BaseFinderOptions {
   /**
@@ -1587,16 +1743,24 @@ interface FindRecordOptions extends BaseFinderOptions {
  * {@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 = {
   /**
@@ -1616,6 +1780,9 @@ type LegacyResourceQuery = {
  * 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 CAUTION_MEGA_DANGER_ZONE_Extension {
   /**
@@ -1712,6 +1879,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. */
@@ -1750,6 +1920,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. */
@@ -1779,14 +1952,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}
@@ -1829,6 +2007,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;
@@ -1837,9 +2017,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;
@@ -1856,6 +2041,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. */
@@ -1879,6 +2067,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 {
@@ -1967,6 +2161,8 @@ declare class SchemaService$1 implements SchemaService {
  * 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>;
@@ -1975,6 +2171,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>;
@@ -1985,6 +2183,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.
  *
@@ -2029,6 +2231,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 {
@@ -2470,6 +2674,8 @@ 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;
@@ -2502,6 +2708,8 @@ 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;
@@ -2517,6 +2725,8 @@ 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;
@@ -2534,6 +2744,8 @@ Takes a method which can expect to be called when the parent application is dest
 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;
@@ -2550,6 +2762,8 @@ This configuration MUST occur prior to the store instance being created.
 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;
@@ -2684,15 +2898,24 @@ interface PrivateCacheKeyManager extends CacheKeyManager {
 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;
 /**
@@ -2701,6 +2924,8 @@ type NotificationType = "attributes" | "relationships" | "identity" | "errors" |
  * 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
  */
@@ -2736,6 +2961,8 @@ type NotifyKeys = Set<string>;
  * `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";
@@ -2757,6 +2984,8 @@ interface DocumentOperationCallback$1 {
  * 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
  */
@@ -2864,6 +3093,8 @@ interface PrivateNotificationManager extends NotificationManager$1 {
  *
  * 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 = {
@@ -3025,12 +3256,16 @@ type OpaqueRecordInstance = unknown;
  * 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 = {
@@ -3088,6 +3323,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 {
@@ -4016,6 +4256,8 @@ declare function graphFor(store: CacheCapabilitiesManager$1 | Store$1): Graph;
  * 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>;
@@ -4034,6 +4276,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> = {
@@ -4061,6 +4305,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;
@@ -4068,6 +4314,8 @@ 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;
@@ -4076,6 +4324,9 @@ declare function getPromiseResult<T, E>(promise: Promise<T> | Awaitable<T, E>):
 /**
  * Brands the supplied object with the supplied response type.
  *
+ * 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';
@@ -4088,6 +4339,8 @@ declare function getPromiseResult<T, E>(promise: Promise<T> | Awaitable<T, E>):
  * 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. */
@@ -4098,6 +4351,9 @@ 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`.
  *
+ * 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'
@@ -4121,6 +4377,8 @@ declare function withResponseType<T>(obj: RequestInfo): RequestInfo<T> & {
  * 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>> & {
@@ -4128,6 +4386,8 @@ 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;
@@ -4140,6 +4400,9 @@ type LooseStoreRequestInfo<RT = unknown> = Omit<ImmutableRequestInfo<RT>, "recor
 /**
  * The request shape accepted by {@link Store.request}, either a fully-formed
  * {@link ImmutableRequestInfo} or the looser {@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 {
@@ -4151,6 +4414,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.
@@ -4186,7 +4452,10 @@ 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
@@ -4196,12 +4465,18 @@ declare const CacheHandler: CacheHandler$1;
  * 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 {
@@ -4395,6 +4670,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> & {
@@ -4425,6 +4702,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> & {
@@ -4452,10 +4731,15 @@ 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>;
@@ -4870,6 +5154,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.
 */
@@ -4987,6 +5272,8 @@ 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)";
@@ -5040,10 +5327,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>, "[]"> {}
@@ -5196,6 +5488,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> {
@@ -5292,6 +5586,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> {
@@ -5590,6 +5886,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
@@ -6569,6 +6885,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.
@@ -6576,6 +6896,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
  */
@@ -6684,12 +7005,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
    *
@@ -6734,6 +7068,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>;
@@ -7280,6 +7637,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> {
@@ -7546,10 +7904,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
  */
@@ -7575,6 +7937,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
@@ -7589,6 +7953,8 @@ 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>;
@@ -7603,6 +7969,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;
@@ -7611,6 +7979,8 @@ 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;
@@ -7624,6 +7994,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';
  *
@@ -7631,6 +8004,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
  */
@@ -7676,6 +8051,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. */
@@ -7731,6 +8109,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;
@@ -7793,6 +8173,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]
@@ -7804,6 +8187,8 @@ interface PolicyConfigConstraints {
  * }
  * ```
  *
+ * @summary Options for `DefaultCachePolicy`: soft and hard expiration times, header-based expiration
+ * constraints, and test-mode behavior.
  */
 interface PolicyConfig {
   /**
@@ -7884,6 +8269,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]
@@ -7961,6 +8349,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 {
@@ -8043,11 +8433,15 @@ declare class DefaultCachePolicy implements CachePolicy {
 //#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> {
   /**
@@ -8132,6 +8526,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';
@@ -8234,6 +8631,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;
@@ -8254,6 +8654,8 @@ declare function useRecommendedStore<T extends Cache>(options: StoreSetupOptions
  * 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 {
   /**
@@ -8317,6 +8719,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> {
   /**
@@ -8380,6 +8784,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> {
   /**
@@ -8447,11 +8853,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.
@@ -8501,6 +8912,9 @@ 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
@@ -8510,6 +8924,8 @@ declare function getPromiseState<T = unknown, E = unknown>(promise: Promise<T> |
  * 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 {
@@ -8729,9 +9145,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> {
@@ -8865,11 +9283,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';
  *
@@ -8916,6 +9356,10 @@ 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
@@ -8928,16 +9372,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 {
   /**
@@ -8955,6 +9408,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> {
   /**
@@ -8988,6 +9444,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> {
   /**
@@ -9006,6 +9465,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> {
   /**
@@ -9070,6 +9531,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> {
@@ -9134,6 +9597,9 @@ 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
@@ -9260,5 +9726,5 @@ declare function peekInternalSignal(signals: SignalStore | undefined, key: strin
  */
 declare function notifyInternalSignal(signal: WarpDriveSignal | undefined): void;
 //#endregion
-export { PrivateRequestStateService as $, UpdateRequestOptions as $n, NotificationType as $t, PolicyConfig as A, CreateRequestOptions as An, withReactiveResponse as At, logGroup as B, ImmutableRequestInfo as Bn, GraphEdge as Bt, getPromiseState as C, FindAllOptions as Cn, ReactiveDocument as Ct, useRecommendedStore as D, ModelSchema as Dn, StoreRequestContext as Dt, StoreSetupOptions as E, QueryOptions as En, CacheHandler as Et, PrivateReactiveResource as F, HTTPMethod as Fn, createDeferred as Ft, ensureStringId as G, RequestContext as Gn, Cache as Gt, createLegacyManyArray as H, PostQueryRequestOptions as Hn, ImplicitEdge as Ht, ReactiveResource as I, IS_FUTURE as In, graphFor as It, PrivateStore as J, STRUCTURED as Jn, CacheCapabilitiesManager$1 as Jt, constructResource as K, RequestInfo as Kn, ChangedAttributesHash as Kt, checkout as L, ImmutableCreateRequestOptions as Ln, peekGraph as Lt, Fetch as M, EnableHydration as Mn, Awaitable as Mt, instantiateRecord as N, FindRecordOptions$2 as Nn, getPromiseResult as Nt, CacheControlValue as O, CacheOptions as On, StoreRequestInput as Ot, teardownRecord as P, FindRecordRequestOptions as Pn, setPromiseResult as Pt, FindRecordQuery as Q, StructuredErrorDocument as Qn, NotificationManager$1 as Qt, commit as R, ImmutableDeleteRequestOptions as Rn, isBelongsTo as Rt, ResolvedPromise as S, BaseFinderOptions as Sn, ReactiveDataDocument as St, Document as T, LegacyResourceQuery as Tn, CachePolicy as Tt, normalizeModelName as U, QueryRequestOptions as Un, CollectionEdge as Ut, LegacyManyArray as V, ImmutableUpdateRequestOptions as Vn, ResourceEdge as Vt, coerceId as W, RemotelyAccessibleIdentifier as Wn, UpgradedMeta as Wt, assertPrivateStore as X, StructuredDataDocument as Xn, DocumentCacheOperation$1 as Xt, Store$1 as Y, SkipCache as Yn, CacheOperation$1 as Yt, isPrivateStore as Z, StructuredDocument as Zn, NotificationChannel as Zt, RequestState as _, SchemaService$1 as _n, recordIdentifierFor as _t, notifyInternalSignal as a, setIdentifierForgetMethod as an, Handler as ar, fastPush as at, PromiseState as b, registerDerivations as bn, PrivateCacheCapabilitiesManager as bt, AutorefreshBehaviorCombos as c, setIdentifierUpdateMethod as cn, RequestManager as cr, PrivateReactiveResourceArray as ct, RecoveryFeatures as d, RelationshipsSchema as dn, Checkout as dt, NotifyKeys as en, FetchError as er, Request$1 as et, RequestArgs as f, SchemaService as fn, Context as ft, RequestLoadingState as g, ProcessedExtension as gn, _clearCaches as gt, createRequestSubscription as h, ExtensionDef as hn, StoreMap as ht, makeInitializer as i, isResourceKey as in, Future as ir, RecordArrayManager as it, parseCacheControl as j, DeleteRequestOptions as jn, withResponseType as jt, DefaultCachePolicy as k, ConstrainedRequestOptions as kn, withBrand as kt, ContentFeatures as l, setKeyInfoForResource as ln, ReactiveResourceArray as lt, SubscriptionArgs as m, ExtensibleField as mn, InstanceCache as mt, WarpDriveSignal as n, fieldValueIdentity as nn, CacheHandler$1 as nr, RequestStateService as nt, peekInternalSignal as o, setIdentifierGenerationMethod as on, ManagedRequestPriority as or, LegacyQueryArray as ot, RequestSubscription as p, CAUTION_MEGA_DANGER_ZONE_Extension as pn, NativeProxy as pt, CreateRecordProperties as q, ResponseInfo as qn, RelationshipDiff as qt, getOrCreateInternalSignal as r, isRequestKey as rn, Deferred as rr, SaveRecordMutation as rt, withSignalStore as s, setIdentifierResetMethod as sn, NextFn as sr, LegacyLiveArray as st, SignalStore as t, FieldValueIdentity as tn, Context$1 as tr, RequestCacheRequestState as tt, DISPOSE as u, AttributesSchema as un, ManagedArray as ut, getRequestState as v, Transformation as vn, setRecordIdentifier as vt, ConfiguredStore as w, FindRecordOptions as wn, ReactiveErrorDocument as wt, RejectedPromise as x, withDefaults as xn, assertPrivateCapabilities as xt, PendingPromise as y, fromIdentity as yn, storeFor as yt, log as z, ImmutableHeaders as zn, Graph as zt };
-//# sourceMappingURL=internal-9XuWZdDv.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-CgOlgOt3.d.ts.map