@warp-drive/core 5.7.0-alpha.2 → 5.7.0-alpha.21

package/declarations/reactive/-private/kind/generic-field.d.ts

@@ -0,0 +1,4 @@
+import type { GenericField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getGenericField(context: KindContext<GenericField>): unknown;
+export declare function setGenericField(context: KindContext<GenericField>): boolean;

package/declarations/reactive/-private/kind/has-many-field.d.ts

@@ -0,0 +1,4 @@
+import type { LegacyHasManyField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getHasManyField(context: KindContext<LegacyHasManyField>): unknown;
+export declare function setHasManyField(context: KindContext<LegacyHasManyField>): boolean;

package/declarations/reactive/-private/kind/hash-field.d.ts

@@ -0,0 +1,4 @@
+import type { HashField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getHashField(context: KindContext<HashField>): unknown;
+export declare function setHashField(context: KindContext<HashField>): boolean;

package/declarations/reactive/-private/kind/identity-field.d.ts

@@ -0,0 +1,4 @@
+import type { IdentityField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getIdentityField(context: KindContext<IdentityField>): unknown;
+export declare function setIdentityField(context: KindContext<IdentityField>): boolean;

package/declarations/reactive/-private/kind/local-field.d.ts

@@ -0,0 +1,4 @@
+import type { LocalField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getLocalField(context: KindContext<LocalField>): unknown;
+export declare function setLocalField(context: KindContext<LocalField>): boolean;

package/declarations/reactive/-private/kind/object-field.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getObjectField(context: KindContext<ObjectField>): unknown;
+export declare function setObjectField(context: KindContext<ObjectField>): boolean;

package/declarations/reactive/-private/kind/resource-field.d.ts

@@ -0,0 +1,4 @@
+import type { ResourceField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getResourceField(context: KindContext<ResourceField>): unknown;
+export declare function setResourceField(context: KindContext<ResourceField>): boolean;

package/declarations/reactive/-private/kind/schema-array-field.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaArrayField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export { getArrayField as getSchemaArrayField } from "./array-field.js";
+export declare function setSchemaArrayField(context: KindContext<SchemaArrayField>): boolean;

package/declarations/reactive/-private/kind/schema-object-field.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaObjectField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getSchemaObjectField(context: KindContext<SchemaObjectField>): unknown;
+export declare function setSchemaObjectField(context: KindContext<SchemaObjectField>): boolean;

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

@@ -1,37 +1,28 @@
-import type { Store } from "../../index.js";
-import type { StableRecordIdentifier } from "../../types/identifier.js";
-import type { SchemaArrayField, SchemaObjectField } from "../../types/schema/fields.js";
+import type { Store } from "../../store/-private.js";
 import { RecordStore } from "../../types/symbols.js";
-import { Checkout, Destroy, Editable, EmbeddedField, EmbeddedPath, Identifier, Legacy, Parent } from "./symbols.js";
-export { Editable, Legacy, Checkout } from "./symbols.js";
+import type { ObjectContext, ResourceContext } from "./default-mode.js";
+import { Checkout, Commit, Context, Destroy } from "./symbols.js";
 export interface ReactiveResource {
-	[Symbol.toStringTag]: `ReactiveResource<${string}>`;
-	/** @internal */
-	[RecordStore]: Store;
-	/** @internal */
-	[Identifier]: StableRecordIdentifier;
 	/** @internal */
-	[Parent]: StableRecordIdentifier;
-	/** @internal */
-	[EmbeddedField]: SchemaArrayField | SchemaObjectField | null;
-	/** @internal */
-	[EmbeddedPath]: string[] | null;
+	[Symbol.toStringTag]: `ReactiveResource<${string}>`;
 	/** @internal */
-	[Editable]: boolean;
+	[Context]: ObjectContext | ResourceContext;
 	/** @internal */
-	[Legacy]: boolean;
+	[RecordStore]: Store;
 	/** @internal */
 	___notifications: object;
 	/** @internal */
 	[Destroy](): void;
+	/** @internal */
+	[Commit](): Promise<void>;
 	/**
 	* Create an editable copy of the record
 	*
 	* ReactiveResource instances are not editable by default. This method creates an editable copy of the record. To use,
-	* import the `Checkout` symbol from `@warp-drive/schema-record` and call it on the record.
+	* import the `Checkout` symbol from `@warp-drive/core/reactive` and call it on the record.
 	*
 	* ```ts
-	* import { Checkout } from '@warp-drive/schema-record';
+	* import { Checkout } from '@warp-drive/core/reactive';
 	*
 	* const record = store.peekRecord('user', '1');
 	* const editableRecord = await record[Checkout]();
@@ -39,13 +30,13 @@ export interface ReactiveResource {
 	*
 	* @returns a promise that resolves to the editable record
 	* @throws if the record is already editable or if the record is embedded
-	*
+	* @internal
 	*/
 	[Checkout]<T>(): Promise<T>;
 }
 /**
 * A class that uses a the ResourceSchema for a ResourceType
-* and a ResouceKey to transform data from the cache into a rich, reactive
+* and a ResourceKey to transform data from the cache into a rich, reactive
 * object.
 *
 * This class is not directly instantiable. To use it, you should
@@ -57,8 +48,42 @@ export interface ReactiveResource {
 */
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export declare class ReactiveResource {
-	constructor(store: Store, identifier: StableRecordIdentifier, Mode: {
-		[Editable]: boolean;
-		[Legacy]: boolean;
-	}, isEmbedded?: boolean, embeddedField?: SchemaArrayField | SchemaObjectField | null, embeddedPath?: string[] | null);
+	constructor(context: ResourceContext | ObjectContext);
 }
+export declare function _CHECKOUT(record: ReactiveResource): ReactiveResource;
+/**
+* Checkout an immutable resource for editing.
+*
+* {@link ReactiveResource | ReactiveResources} are not editable by default. This method
+* creates an editable copy of the resource.
+*
+* This returns a promise which resolves with the editable
+* version of the resource.
+*
+* ```ts
+* import { checkout } from '@warp-drive/core/reactive';
+*
+* const immutable = store.peekRecord('user', '1');
+* const editable = await checkout(immutable);
+* ```
+*
+* Edits to editable resources will be automatically committed if a new
+* payload from the cache matches their existing value.
+*
+* @public
+*
+* @returns a promise that resolves to the editable resource
+* @throws if the resource is already editable or if resource is an embedded object
+*/
+export declare function checkout<T>(resource: unknown): Promise<T & ReactiveResource>;
+/**
+* Forcibly commit all local changes on an editable resource to
+* the remote (immutable) version.
+*
+* This API should only be used cautiously. Typically a better
+* approach is for either the API or a Handler to reflect saved
+* changes back to update the cache.
+*
+* @public
+*/
+export declare function commit(record: ReactiveResource): Promise<void>;

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

@@ -1,9 +1,9 @@
 import type { Store } from "../../store/-private.js";
 import type { SchemaService as SchemaServiceInterface } from "../../types.js";
-import type { StableRecordIdentifier } from "../../types/identifier.js";
+import type { ResourceKey } from "../../types/identifier.js";
 import type { ObjectValue, Value } from "../../types/json/raw.js";
 import type { Derivation, HashFn } from "../../types/schema/concepts.js";
-import { type ArrayField, type DerivedField, type FieldSchema, type GenericField, type HashField, type LegacyAttributeField, type LegacyBelongsToField, type LegacyHasManyField, type LegacyRelationshipField, type ObjectField, type ObjectSchema, type PolarisResourceSchema, type ResourceSchema, type Trait } from "../../types/schema/fields.js";
+import { type ArrayField, type CacheableFieldSchema, type DerivedField, type FieldSchema, type GenericField, type HashField, type IdentityField, type LegacyAttributeField, type LegacyBelongsToField, type LegacyHasManyField, type LegacyRelationshipField, type ObjectField, type ObjectSchema, type PolarisResourceSchema, type ResourceSchema, type Trait } from "../../types/schema/fields.js";
 import { Type } from "../../types/symbols.js";
 import type { WithPartial } from "../../types/utils.js";
 import type { ReactiveResource } from "./record.js";
@@ -95,11 +95,11 @@ interface FromIdentityDerivation {
 	}, key: string): string | null;
 	(record: ReactiveResource, options: {
 		key: "^";
-	}, key: string): StableRecordIdentifier;
+	}, key: string): ResourceKey;
 	(record: ReactiveResource, options: null, key: string): asserts options;
 	(record: ReactiveResource, options: {
 		key: "id" | "lid" | "type" | "^";
-	} | null, key: string): StableRecordIdentifier | string | null;
+	} | null, key: string): ResourceKey | string | null;
 	[Type]: "@identity";
 }
 /**
@@ -141,6 +141,7 @@ interface InternalSchema {
 	finalized: boolean;
 	traits: Set<string>;
 	fields: Map<string, FieldSchema>;
+	cacheFields: Map<string, Exclude<CacheableFieldSchema, IdentityField>>;
 	attributes: Record<string, LegacyAttributeField>;
 	relationships: Record<string, LegacyRelationshipField>;
 }
@@ -150,18 +151,18 @@ export type Transformation<
 > = {
 	serialize(value: PT, options: Record<string, unknown> | null, record: ReactiveResource): T;
 	hydrate(value: T | undefined, options: Record<string, unknown> | null, record: ReactiveResource): PT;
-	defaultValue?(options: Record<string, unknown> | null, identifier: StableRecordIdentifier): T;
+	defaultValue?(options: Record<string, unknown> | null, identifier: ResourceKey): T;
 	[Type]: string;
 };
 interface KindFns {
 	belongsTo: {
-		get: (store: Store, record: object, resourceKey: StableRecordIdentifier, field: LegacyBelongsToField) => unknown;
-		set: (store: Store, record: object, cacheKey: StableRecordIdentifier, field: LegacyBelongsToField, value: unknown) => void;
+		get: (store: Store, record: object, resourceKey: ResourceKey, field: LegacyBelongsToField) => unknown;
+		set: (store: Store, record: object, cacheKey: ResourceKey, field: LegacyBelongsToField, value: unknown) => void;
 	};
 	hasMany: {
-		get: (store: Store, record: object, resourceKey: StableRecordIdentifier, field: LegacyHasManyField) => unknown;
-		set: (store: Store, record: object, cacheKey: StableRecordIdentifier, field: LegacyHasManyField, value: unknown) => void;
-		notify: (store: Store, record: object, cacheKey: StableRecordIdentifier, field: LegacyHasManyField) => boolean;
+		get: (store: Store, record: object, resourceKey: ResourceKey, field: LegacyHasManyField) => unknown;
+		set: (store: Store, record: object, cacheKey: ResourceKey, field: LegacyHasManyField, value: unknown) => void;
+		notify: (store: Store, record: object, cacheKey: ResourceKey, field: LegacyHasManyField) => boolean;
 	};
 }
 export interface SchemaService {
@@ -211,7 +212,7 @@ export declare class SchemaService implements SchemaServiceInterface {
 	constructor();
 	resourceTypes(): Readonly<string[]>;
 	hasTrait(type: string): boolean;
-	resourceHasTrait(resource: StableRecordIdentifier | {
+	resourceHasTrait(resource: ResourceKey | {
 		type: string;
 	}, trait: string): boolean;
 	transformation(field: GenericField | ObjectField | ArrayField | {
@@ -223,7 +224,7 @@ export declare class SchemaService implements SchemaServiceInterface {
 	hashFn(field: HashField | {
 		type: string;
 	}): HashFn;
-	resource(resource: StableRecordIdentifier | {
+	resource(resource: ResourceKey | {
 		type: string;
 	}): ResourceSchema | ObjectSchema;
 	registerResources(schemas: Array<ResourceSchema | ObjectSchema>): void;
@@ -267,10 +268,10 @@ export declare class SchemaService implements SchemaServiceInterface {
 		FM extends ObjectValue | null
 	>(derivation: Derivation<R, T, FM>): void;
 	CAUTION_MEGA_DANGER_ZONE_registerExtension(extension: CAUTION_MEGA_DANGER_ZONE_Extension): void;
-	CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource: StableRecordIdentifier | {
+	CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource: ResourceKey | {
 		type: string;
 	}): null | ProcessedExtension["features"];
-	CAUTION_MEGA_DANGER_ZONE_objectExtensions(field: ExtensibleField): null | ProcessedExtension["features"];
+	CAUTION_MEGA_DANGER_ZONE_objectExtensions(field: ExtensibleField, resolvedType: string | null): null | ProcessedExtension["features"];
 	CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field: ExtensibleField): null | ProcessedExtension["features"];
 	CAUTION_MEGA_DANGER_ZONE_hasExtension(ext: {
 		kind: "object" | "array";
@@ -304,6 +305,9 @@ export declare class SchemaService implements SchemaServiceInterface {
 	fields({ type }: {
 		type: string;
 	}): InternalSchema["fields"];
+	cacheFields({ type }: {
+		type: string;
+	}): InternalSchema["cacheFields"];
 	hasResource(resource: {
 		type: string;
 	}): boolean;

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

@@ -25,12 +25,7 @@
 // Note that none of these symbols are part of the public API, these are used for
 // debugging DX and as a safe way to provide an intimate contract on public objects.
 export declare const SOURCE: "___(unique) Symbol(SOURCE)";
-export declare const MUTATE: "___(unique) Symbol(MUTATE)";
 export declare const Destroy: "___(unique) Symbol(Destroy)";
-export declare const Identifier: "___(unique) Symbol(Identifier)";
-export declare const Editable: "___(unique) Symbol(Editable)";
-export declare const Parent: "___(unique) Symbol(Parent)";
 export declare const Checkout: "___(unique) Symbol(Checkout)";
-export declare const Legacy: "___(unique) Symbol(Legacy)";
-export declare const EmbeddedPath: "___(unique) Symbol(EmbeddedPath)";
-export declare const EmbeddedField: "___(unique) Symbol(EmbeddedField)";
+export declare const Commit: "___(unique) Symbol(Commit)";
+export declare const Context: "___(unique) Symbol(Context)";

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

@@ -1 +1 @@
-export { Editable, Legacy } from "./-private/symbols.js";
+export { Context } from "./-private/symbols.js";

package/declarations/reactive.d.ts

@@ -1,4 +1,281 @@
+/**
+* # About
+*
+* This module provides an implementation of reactive objects that a Store may use for creating
+* reactive representations of the raw data for requests, resources and their relationships
+* stored in the cache.
+*
+* - For configuring the store to use these reactive objects, see [The Setup Guide](/guides/1-configuration/2-setup/1-universal.md)
+* - For defining resource schemas, see [The Schema Guide](/guides)
+*
+* Any method that returns a record instance will use the `instantiateRecord`
+* hook configured above to instantiate a ReactiveResource once this is in place.
+* After that, its up to you what ReactiveResource can do.
+*
+* ## Modes
+*
+* ReactiveResource has two modes: `legacy` and `polaris`.
+*
+* **LegacyMode** can be used to emulate the behaviors and capabilities of WarpDrive's `Model` class,
+* and because there is little distinction between Model and a ReactiveResource in LegacyMode we refer
+* to both of these approaches as LegacyMode. This mode is the default experience in V5.
+*
+* In LegacyMode:
+*
+* - records are mutable
+* - local changes immediately reflect app wide
+* - records have all the APIs of Model (references, state props, currentState, methods etc)
+* - the continued use of `@warp-drive/legacy` is required (though most imports from it can be removed)
+* - `async: true` relationships are supported (but not recommended outside of [LinksMode](https://github.com/emberjs/data/blob/main/guides/relationships/features/links-mode.md))
+*
+* ---
+*
+* **PolarisMode** is an upcoming suite of features that will become the default experience in V6.
+*
+* In PolarisMode:
+*
+* - records are immutable, unless creating a new resource or explicitly checking out a record for editing
+* - local changes are isolated until committed, displaying only via the editable version of the record
+* - records have a more limited API, focused on only what is in their schema.
+* - some common operations may have more friction to perform because intended utilities are not yet available
+* - `async: true` relationships are not supported (see [LinksMode](https://github.com/emberjs/data/blob/main/guides/relationships/features/links-mode.md))
+* - The `@warp-drive/legacy` package is not required
+*
+* These modes are interopable. The reactive object (record) for a resource in PolarisMode can relate to
+* a record in LegacyMode and vice-versa. This interopability is true whether the record in LegacyMode is
+* a ReactiveResource or a Model.
+*
+* ---
+*
+* ## Basic Usage
+*
+* ReactiveResource is a reactive object that transforms raw data from an associated
+* cache into reactive data backed by Signals.
+*
+* The shape of the object and the transformation of raw cache data into its
+* reactive form is controlled by a resource schema.
+*
+* For instance, lets say your API is a [{JSON:API}](https://jsonapi.org) and your store is using
+* the Cache provided by [@warp-drive/json-api](/api/@warp-drive/json-api), and a request
+* returns the following raw data:
+*
+* ```ts
+* {
+*   data: {
+*     type: 'user',
+*     id: '1',
+*     attributes: { firstName: 'Chris', lastName: 'Thoburn' },
+*     relationships: { pets: { data: [{ type: 'dog', id: '1' }] }}
+*   },
+*   included: [
+*     {
+*       type: 'dog',
+*       id: '1',
+*       attributes: { name: 'Rey' },
+*       relationships: { owner: { data: { type: 'user', id: '1' }}}
+*     }
+*   ]
+* }
+* ```
+*
+* We could describe the `'user'` and `'dog'` resources in the above payload
+* with the following schemas:
+*
+* ```ts
+* store.schema.registerResources([
+*   {
+*     type: 'user',
+*     identity: { type: '@id', name: 'id' },
+*     fields: [
+*       {
+*         type: '@identity',
+*         name: '$type',
+*         kind: 'derived',
+*         options: { key: 'type' },
+*       },
+*       { kind: 'field', name: 'firstName' },
+*       { kind: 'field', name: 'lastName' },
+*       {
+*         kind: 'derived',
+*         name: 'name',
+*         type: 'concat',
+*         options: { fields: ['firstName', 'lastName'], separator: ' ' }
+*       },
+*       {
+*         kind: 'hasMany',
+*         name: 'pets',
+*         type: 'pet',
+*         options: {
+*           async: false,
+*           inverse: 'owner',
+*           polymorphic: true,
+*           linksMode: true,
+*         }
+*       }
+*     ]
+*   },
+*   {
+*     type: 'dog',
+*     identity: { type: '@id', name: 'id' },
+*     fields: [
+*       {
+*         type: '@identity',
+*         name: '$type',
+*         kind: 'derived',
+*         options: { key: 'type' },
+*       },
+*       { kind: 'field', name: 'name' },
+*       {
+*         kind: 'belongsTo',
+*         name: 'owner',
+*         type: 'user',
+*         options: {
+*           async: false,
+*           inverse: 'pets',
+*           as: 'pet',
+*           linksMode: true,
+*         }
+*       }
+*     ]
+*   }
+* ]);
+* ```
+*
+* With these schemas in place, the reactive objects that the store would
+* provide us whenever we encountered a `'user'` or a `'dog'` would be:
+*
+* ```ts
+* interface Pet {
+*   readonly id: string;
+*   readonly owner: User;
+* }
+*
+* interface Dog extends Pet {
+*   readonly $type: 'dog';
+*   readonly name: string;
+* }
+*
+* interface EditableUser {
+*   readonly $type: 'user';
+*   readonly id: string;
+*   firstName: string;
+*   lastName: string;
+*   readonly name: string;
+*   pets: Array<Dog | Pet>;
+* }
+*
+* interface User {
+*   readonly $type: 'user';
+*   readonly id: string;
+*   readonly firstName: string;
+*   readonly lastName: string;
+*   readonly name: string;
+*   readonly pets: Readonly<Array<Dog | Pet>>;
+*   [Checkout]: Promise<EditableUser>
+* }>
+* ```
+*
+* Note how based on the schema the reactive object we receive is able to produce
+* `name` on user (despite no name field being in the cache), provide `$type`
+* pulled from the identity of the resource, and flatten the individual attributes
+* and relationships onto the record for easier use.
+*
+* Notice also how we typed this object with `readonly`. This is because while
+* ReactiveResource instances are ***deeply reactive***, they are also ***immutable***.
+*
+* We can mutate a ReactiveResource only be explicitly asking permission to do so, and
+* in the process gaining access to an editable copy. The immutable version will
+* not show any in-process edits made to this editable copy.
+*
+* ```ts
+* import { Checkout } from '@warp-drive/schema-record';
+*
+* const editable = await user[Checkout]();
+* ```
+*
+* ## Utilities
+*
+* ReactiveResource provides a schema builder that simplifies setting up a couple of
+* conventional fields like identity and `$type`. We can rewrite the schema
+* definition above using this utility like so:
+*
+* ```ts
+* import { withDefaults } from '@warp-drive/core/reactive';
+*
+* store.schema.registerResources([
+*   withDefaults({
+*     type: 'user',
+*     fields: [
+*       { kind: 'field', name: 'firstName' },
+*       { kind: 'field', name: 'lastName' },
+*       {
+*         kind: 'derived',
+*         name: 'name',
+*         type: 'concat',
+*         options: { fields: ['firstName', 'lastName'], separator: ' ' }
+*       },
+*       {
+*         kind: 'hasMany',
+*         name: 'pets',
+*         type: 'pet',
+*         options: {
+*           async: false,
+*           inverse: 'owner',
+*           polymorphic: true,
+*           linksMode: true,
+*           resetOnRemoteUpdate: false,
+*         }
+*       }
+*     ]
+*   }),
+*   withDefaults({
+*     type: 'dog',
+*     fields: [
+*       { kind: 'field', name: 'name' },
+*       {
+*         kind: 'belongsTo',
+*         name: 'owner',
+*         type: 'user',
+*         options: {
+*           async: false,
+*           inverse: 'pets',
+*           as: 'pet',
+*           linksMode: true,
+*           resetOnRemoteUpdate: false,
+*         }
+*       }
+*     ]
+*   })
+* ]);
+* ```
+*
+* ## Type Support
+*
+* ### Resource Schemas
+*
+* - {@link PolarisResourceSchema}
+* - {@link LegacyResourceSchema}
+* - {@link ObjectSchema}
+*
+* ### Resource Schema Type Utils
+*
+* - {@link resourceSchema}
+* - {@link objectSchema}
+* - {@link isResourceSchema}
+* - {@link isLegacyResourceSchema}
+*
+* ### Field Schemas
+*
+* - {@link LegacyModeFieldSchema}
+* - {@link PolarisModeFieldSchema}
+*
+* @module
+*/
+import { checkout } from "./reactive/-private/record.js";
 export { instantiateRecord, teardownRecord } from "./reactive/-private/hooks.js";
 export { type CAUTION_MEGA_DANGER_ZONE_Extension, type ProcessedExtension, type ExtensionDef, type Transformation, SchemaService, withDefaults, fromIdentity, registerDerivations } from "./reactive/-private/schema.js";
-export { type ReactiveResource } from "./reactive/-private/record.js";
+export { commit, type ReactiveResource } from "./reactive/-private/record.js";
+export { checkout };
 export { Checkout } from "./reactive/-private/symbols.js";
+export { type ReactiveDocument } from "./reactive/-private/document.js";
+export { getExpensiveRequestSubscription } from "./store/-private/new-core-tmp/expensive-subscription.js";

package/declarations/request/-private/context.d.ts

@@ -1,4 +1,4 @@
-import type { StableDocumentIdentifier } from "../../types/identifier.js";
+import type { RequestKey } from "../../types/identifier.js";
 import type { ImmutableHeaders, ImmutableRequestInfo, RequestInfo, ResponseInfo } from "../../types/request.js";
 import type { DeferredStream, GodContext } from "./types.js";
 export declare function upgradeHeaders(headers: Headers | ImmutableHeaders): ImmutableHeaders;
@@ -34,7 +34,7 @@ export declare class Context {
 	constructor(owner: ContextOwner, isCacheHandler: boolean);
 	setStream(stream: ReadableStream | Promise<ReadableStream | null>): void;
 	setResponse(response: ResponseInfo | Response | null): void;
-	setIdentifier(identifier: StableDocumentIdentifier): void;
+	setIdentifier(identifier: RequestKey): void;
 	get hasRequestedStream(): boolean;
 	_finalize(): void;
 }

package/declarations/request/-private/fetch.d.ts

@@ -1,4 +1,6 @@
 import { type Context } from "./context.js";
+import type { FetchError } from "./utils.js";
+export type { FetchError };
 interface FastbootRequest extends Request {
 	protocol: string;
 	host: string;

package/declarations/request/-private/manager.d.ts

@@ -1,4 +1,4 @@
-import type { StableDocumentIdentifier } from "../../types/identifier.js";
+import type { RequestKey } from "../../types/identifier.js";
 import type { RequestInfo } from "../../types/request.js";
 import type { CacheHandler, Future, GenericCreateArgs, Handler, ManagedRequestPriority } from "./types.js";
 import { IS_CACHE_HANDLER } from "./utils.js";
@@ -107,7 +107,7 @@ export declare class RequestManager {
 	*/
 	_pending: Map<number, Promise<unknown>>;
 	/** @internal */
-	_deduped: Map<StableDocumentIdentifier, {
+	_deduped: Map<RequestKey, {
 		priority: ManagedRequestPriority;
 		promise: Promise<unknown>;
 	}>;
@@ -145,10 +145,7 @@ export declare class RequestManager {
 	* @param {RequestInfo} request
 	* @return {Future}
 	*/
-	request<
-		RT,
-		T = unknown
-	>(request: RequestInfo<RT, T>): Future<RT>;
+	request<RT>(request: RequestInfo<RT>): Future<RT>;
 	/**
 	* This method exists so that the RequestManager can be created
 	* can be created by container/factory systems that expect to

package/declarations/request/-private/types.d.ts

@@ -1,5 +1,5 @@
 /* eslint-disable no-irregular-whitespace */
-import type { StableDocumentIdentifier } from "../../types/identifier.js";
+import type { RequestKey } from "../../types/identifier.js";
 import type { IS_FUTURE, RequestContext, RequestInfo, ResponseInfo, StructuredDataDocument } from "../../types/request.js";
 export interface GodContext {
 	controller: AbortController;
@@ -7,7 +7,7 @@ export interface GodContext {
 	stream: ReadableStream | Promise<ReadableStream | null> | null;
 	hasRequestedStream: boolean;
 	id: number;
-	identifier: StableDocumentIdentifier | null;
+	identifier: RequestKey | null;
 }
 export type Deferred<T> = {
 	resolve(v: T): void;
@@ -64,10 +64,10 @@ export interface Future<T> extends Promise<StructuredDataDocument<T>> {
 	* assigned by the CacheHandler.
 	*
 	* @property lid
-	* @type {StableDocumentIdentifier | null}
+	* @type {RequestKey | null}
 	* @public
 	*/
-	lid: StableDocumentIdentifier | null;
+	lid: RequestKey | null;
 	/**
 	* The id of the associated request, if any, as assigned
 	* by the RequestManager