@warp-drive/legacy 5.8.0-beta.0 → 5.8.0-beta.2

package/declarations/model/migration-support.d.ts

@@ -7,7 +7,7 @@ import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { ObjectValue } from "@warp-drive/core/types/json/raw";
 import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
 import type { Derivation, HashFn, Transformation } from "@warp-drive/core/types/schema/concepts";
-import type { ArrayField, DerivedField, FieldSchema, GenericField, HashField, LegacyResourceSchema, ObjectField, ObjectSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
+import type { ArrayField, CacheableFieldSchema, DerivedField, FieldSchema, GenericField, HashField, IdentityField, LegacyResourceSchema, ObjectField, ObjectSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
 import type { WithPartial } from "@warp-drive/core/types/utils";
 import type { Snapshot } from "../compat/-private.js";
 import type { MinimalLegacyRecord } from "./-private/model-methods.js";
@@ -56,14 +56,14 @@ interface LegacyModeRecord<T extends TypedRecordInstance> {
 }
 /**
 * A Type utility that enables quickly adding type information for the fields
-* defined by `import { withDefaults } from '@ember-data/model/migration-support'`.
+* defined by `import { withDefaults } from '@warp-drive/legacy/model/migration-support'`.
 *
 * Example:
 *
 * ```ts
-* import { withDefaults, WithLegacy } from '@ember-data/model/migration-support';
-* import { Type } from '@warp-drive/core-types/symbols';
-* import type { HasMany } from '@ember-data/model';
+* import { withDefaults, WithLegacy } from '@warp-drive/legacy/model/migration-support';
+* import { Type } from '@warp-drive/core/types/symbols';
+* import type { HasMany } from '@@warp-drive/legacy/model';
 *
 * export const UserSchema = withDefaults({
 *   type: 'user',
@@ -99,14 +99,14 @@ export type WithLegacy<T extends TypedRecordInstance> = T & LegacyModeRecord<T>;
 /**
 * A function which adds the necessary fields to a schema and marks it as
 * being in LegacyMode. This is used to support the legacy features of
-* @ember-data/model while migrating to WarpDrive.
+* @warp-drive/legacy/model while migrating to WarpDrive.
 *
 * Example:
 *
 * ```ts
-* import { withDefaults, WithLegacy } from '@ember-data/model/migration-support';
-* import { Type } from '@warp-drive/core-types/symbols';
-* import type { HasMany } from '@ember-data/model';
+* import { withDefaults, WithLegacy } from '@warp-drive/legacy/model/migration-support';
+* import { Type } from '@warp-drive/core/types/symbols';
+* import type { HasMany } from '@warp-drive/legacy/model';
 *
 * export const UserSchema = withDefaults({
 *   type: 'user',
@@ -141,26 +141,42 @@ export type WithLegacy<T extends TypedRecordInstance> = T & LegacyModeRecord<T>;
 * it requires with the schema service.
 *
 * ```ts
-* import { registerDerivations } from '@ember-data/model/migration-support';
+* import { registerDerivations } from '@warp-drive/legacy/model/migration-support';
 *
 * registerDerivations(schema);
 * ```
 *
-* @param {LegacyResourceSchema} schema The schema to add legacy support to.
-* @return {LegacyResourceSchema} The schema with legacy support added.
+* @param schema The schema to add legacy support to.
+* @return The schema with legacy support added.
 * @public
 */
 export declare function withDefaults(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): LegacyResourceSchema;
-export declare function withRestoredDeprecatedModelRequestBehaviors(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): LegacyResourceSchema;
 /**
-* A function which registers the necessary derivations to support
-* the LegacyMode features of @ember-data/model while migrating to WarpDrive.
+* Adds the necessasary fields to the schema for supporting
+* the deprecated request methods on LegacyMode schemas.
 *
-* This must be called in order to use the fields added by:
+* Use this instead of `withDefaults` to add the fields
+* and behaviors necessary to support Model-Like capabilities.
 *
 * ```ts
-* import { withDefaults } from '@ember-data/model/migration-support';
+* import { withRestoredDeprecatedModelRequestBehaviors } from '@warp-drive/legacy/model/migration-support';
+*
+* export const UserSchema = withRestoredDeprecatedModelRequestBehaviors({
+*   type: 'user',
+*   fields: [
+*     { name: 'firstName', kind: 'attribute' },
+*     { name: 'lastName', kind: 'attribute' },
+*   ]
+* });
 * ```
+*/
+export declare function withRestoredDeprecatedModelRequestBehaviors(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): LegacyResourceSchema;
+/**
+* A function which registers the necessary derivations to support
+* the LegacyMode features of @warp-drive/legacy/model while migrating to WarpDrive.
+*
+* This must be called in order to use the fields added by {@link withDefaults} or
+* {@link withRestoredDeprecatedModelRequestBehaviors}.
 *
 * @param schema The schema service to register the derivations with.
 * @public
@@ -180,8 +196,8 @@ export declare function registerDerivations(schema: SchemaService): void;
 * provide their own schema information to the application.
 *
 * ```ts
-* import { DelegatingSchemaService } from '@ember-data/model/migration-support';
-* import { SchemaService } from '@warp-drive/schema-record';
+* import { DelegatingSchemaService } from '@warp-drive/legacy/model/migration-support';
+* import { SchemaService } from '@warp-drive/core/reactive';
 *
 * class AppStore extends Store {
 *   createSchemaService() {
@@ -207,8 +223,6 @@ export interface DelegatingSchemaService {
 	doesTypeExist?(type: string): boolean;
 }
 export declare class DelegatingSchemaService implements SchemaService {
-	_preferred: SchemaService;
-	_secondary: SchemaService;
 	constructor(store: Store, schema: SchemaService);
 	isDelegated(resource: ResourceKey | {
 		type: string;
@@ -224,6 +238,9 @@ export declare class DelegatingSchemaService implements SchemaService {
 	fields(resource: ResourceKey | {
 		type: string;
 	}): Map<string, FieldSchema>;
+	cacheFields?(resource: {
+		type: string;
+	}): Map<string, Exclude<CacheableFieldSchema, IdentityField>>;
 	transformation(field: GenericField | ObjectField | ArrayField | {
 		type: string;
 	}): Transformation;
@@ -245,6 +262,10 @@ export declare class DelegatingSchemaService implements SchemaService {
 		FM extends ObjectValue | null
 	>(derivation: Derivation<R, T, FM>): void;
 	registerHashFn(hashFn: HashFn): void;
+	CAUTION_MEGA_DANGER_ZONE_hasExtension(ext: {
+		kind: "object" | "array";
+		name: string;
+	}): boolean;
 	CAUTION_MEGA_DANGER_ZONE_registerExtension(extension: CAUTION_MEGA_DANGER_ZONE_Extension): void;
 	CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource: ResourceKey | {
 		type: string;
@@ -252,4 +273,8 @@ export declare class DelegatingSchemaService implements SchemaService {
 	CAUTION_MEGA_DANGER_ZONE_objectExtensions(field: ExtensibleField, resolvedType: string | null): null | ProcessedExtension["features"];
 	CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field: ExtensibleField): null | ProcessedExtension["features"];
 }
+export interface PrivateDelegatingSchemaService extends DelegatingSchemaService {
+	_preferred: SchemaService;
+	_secondary: SchemaService;
+}
 export {};

package/declarations/model-fragments/extensions/fragment-array.d.ts

@@ -0,0 +1,16 @@
+import type { Fragment } from "./fragment.js";
+export declare class FragmentArray<T extends Fragment> {
+	isDestroying: boolean;
+	isDestroyed: boolean;
+	get hasDirtyAttributes(): boolean;
+	addFragment(fragment?: T): Fragment[] | undefined;
+	createFragment(fragment?: T): Fragment | undefined;
+	removeFragment(fragment?: T): void;
+	rollbackAttributes(): void;
+}
+export declare const FragmentArrayExtension: {
+	kind: "array";
+	name: "fragment-array";
+	features: typeof FragmentArray;
+};
+export default FragmentArrayExtension;

package/declarations/model-fragments/extensions/fragment.d.ts

@@ -0,0 +1,15 @@
+import type { PrivateReactiveResource } from "@warp-drive/core/reactive/-private";
+export declare class Fragment {
+	isDestroying: boolean;
+	isDestroyed: boolean;
+	get hasDirtyAttributes(): boolean;
+	get isFragment(): boolean;
+	get $type(): string | null | undefined;
+	rollbackAttributes(this: PrivateReactiveResource): void;
+}
+export declare const FragmentExtension: {
+	kind: "object";
+	name: "fragment";
+	features: typeof Fragment;
+};
+export default FragmentExtension;

package/declarations/model-fragments/hooks/model-for.d.ts

@@ -0,0 +1,20 @@
+import type { Store } from "@warp-drive/core";
+import type { ModelSchema } from "@warp-drive/core/types";
+import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
+import type { LegacyAttributeField, LegacyRelationshipField } from "@warp-drive/core/types/schema/fields";
+type KeyOrString<T> = keyof T & string extends never ? string : keyof T & string;
+export declare function getShimClass<T>(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string): ShimModelClass<T>;
+export declare class ShimModelClass<T = unknown> implements ModelSchema<T> {
+	__store: Store;
+	modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
+	constructor(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string);
+	get fields(): Map<KeyOrString<T>, "attribute" | "belongsTo" | "hasMany">;
+	get attributes(): Map<KeyOrString<T>, LegacyAttributeField>;
+	get relationshipsByName(): Map<KeyOrString<T>, LegacyRelationshipField>;
+	eachAttribute<K extends KeyOrString<T>>(callback: (key: K, attribute: LegacyAttributeField) => void, binding?: T): void;
+	eachRelationship<K extends KeyOrString<T>>(callback: (key: K, relationship: LegacyRelationshipField) => void, binding?: T): void;
+	eachTransformedAttribute<K extends KeyOrString<T>>(callback: (key: K, type: string | null) => void, binding?: T): void;
+}
+export declare function fragmentsModelFor<T extends TypedRecordInstance>(this: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string): ShimModelClass<T>;
+export declare const modelFor: typeof fragmentsModelFor;
+export {};

package/declarations/model-fragments/index.d.ts

@@ -0,0 +1,5 @@
+import type { WithArrayLike, WithEmberObject } from "../compat/extensions.js";
+import type { Fragment } from "./extensions/fragment.js";
+import type { FragmentArray } from "./extensions/fragment-array.js";
+export type WithFragment<T> = T & WithEmberObject<T> & Fragment;
+export type WithFragmentArray<T extends Fragment> = T & WithArrayLike<T> & FragmentArray<T>;

package/declarations/model-fragments/instance-initializers/fragment-extensions.d.ts

@@ -0,0 +1,9 @@
+import type ApplicationInstance from "@ember/application/instance";
+import type { SchemaService } from "@warp-drive/core/types";
+export declare function registerFragmentExtensions(schema: SchemaService): void;
+export declare function initialize(application: ApplicationInstance): void;
+declare const _default: {
+	name: string;
+	initialize: (application: ApplicationInstance) => void;
+};
+export default _default;

package/declarations/model-fragments/utilities/with-array-defaults.d.ts

@@ -0,0 +1,15 @@
+/**
+* Used as a helper to setup the relevant parts of an array
+* schema and add extensions etc.
+*
+* @param arrayName The name of the array
+* @returns The schema for an array
+*/
+export declare function withArrayDefaults<ArrayName extends string>(arrayName: ArrayName): {
+	kind: "array";
+	name: ArrayName;
+	type: `array:${string}`;
+	options: {
+		arrayExtensions: string[];
+	};
+};

package/declarations/model-fragments/utilities/with-fragment-array-defaults.d.ts

@@ -0,0 +1,20 @@
+/**
+* Used as a helper to setup the relevant parts of a fragment-array
+* schema and add extensions etc.
+*
+* @param fragmentArrayType The type of the fragment-array
+* @param fragmentArrayName The name of the fragment-array
+* @returns The schema for a fragment-array
+*/
+export declare function withFragmentArrayDefaults<
+	FragmentArrayType extends string,
+	FragmentArrayName extends string
+>(fragmentArrayType: FragmentArrayType, fragmentArrayName?: FragmentArrayName): {
+	kind: "schema-array";
+	type: `fragment:${string}`;
+	name: string;
+	options: {
+		arrayExtensions: string[];
+		defaultValue: boolean;
+	};
+};

package/declarations/model-fragments/utilities/with-fragment-defaults.d.ts

@@ -0,0 +1,19 @@
+/**
+* Used as a helper to setup the relevant parts of a fragment schema
+* and add extensions etc.
+*
+* @param fragmentType The type of the fragment
+* @param fragmentName The optional name of the fragment. If not provided, it will default to the fragmentType.
+* @returns The schema for a fragment
+*/
+export declare function withFragmentDefaults<
+	FragmentType extends string,
+	FragmentName extends string
+>(fragmentType: FragmentType, fragmentName?: FragmentName): {
+	kind: "schema-object";
+	type: `fragment:${FragmentType}`;
+	name: FragmentType | FragmentName;
+	options: {
+		objectExtensions: string[];
+	};
+};

package/declarations/model-fragments/utilities/with-legacy.d.ts

@@ -0,0 +1,3 @@
+import type { LegacyResourceSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
+import type { WithPartial } from "@warp-drive/core/types/utils";
+export declare function withLegacy(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): ResourceSchema;

package/declarations/model-fragments.d.ts

@@ -0,0 +1,9 @@
+export { withArrayDefaults } from "./model-fragments/utilities/with-array-defaults.js";
+export { withFragmentDefaults } from "./model-fragments/utilities/with-fragment-defaults.js";
+export { withFragmentArrayDefaults } from "./model-fragments/utilities/with-fragment-array-defaults.js";
+export { withLegacy } from "./model-fragments/utilities/with-legacy.js";
+export { registerFragmentExtensions } from "./model-fragments/instance-initializers/fragment-extensions.js";
+export { modelFor } from "./model-fragments/hooks/model-for.js";
+export { FragmentArray, FragmentArrayExtension } from "./model-fragments/extensions/fragment-array.js";
+export { Fragment, FragmentExtension } from "./model-fragments/extensions/fragment.js";
+export type { WithFragment, WithFragmentArray } from "./model-fragments/index.js";

package/declarations/model.d.ts

@@ -1,7 +1,7 @@
 /**
 * This package provides a Presentation Model for resource data in an WarpDrive Cache.
 *
-* Models are defined as classes extending from `import Model from '@ember-data/model';` and the
+* Models are defined as classes extending from `import Model from '@warp-drive/legacy/model';` and the
 * attributes and relationships on these classes are parsed at runtime to supply static "schema"
 * to WarpDrive's SchemaService.
 *
@@ -17,7 +17,7 @@ the resource data for a given `type` and `id`.
 ### Defining a Model
 
 ```js [app/models/person.js]
-import Model, { attr, belongsTo, hasMany } from '@ember-data/model';
+import Model, { attr, belongsTo, hasMany } from '@warp-drive/legacy/model';
 
 export default class PersonModel extends Model {
 @attr name;

package/declarations/serializer/-private/embedded-records-mixin.d.ts

@@ -14,7 +14,7 @@ Note also that this mixin does not work with JSONAPISerializer because the JSON:
 Below is an example of a per-type serializer (`post` type).
 
 ```js [app/serializers/post.js]
-import RESTSerializer, { EmbeddedRecordsMixin } from '@ember-data/serializer/rest';
+import RESTSerializer, { EmbeddedRecordsMixin } from '@warp-drive/legacy/serializer/rest';
 
 export default class PostSerializer extends RESTSerializer.extend(EmbeddedRecordsMixin) {
 attrs = {
@@ -85,11 +85,6 @@ instances must have an `id` property to be used with Ember Data.
 are. Please read the docs for the methods this mixin provides, in case you need
 to modify it to fit your specific needs.**
 
-For example, review the docs for each method of this mixin:
-* [normalize](/ember-data/release/classes/EmbeddedRecordsMixin/methods/normalize?anchor=normalize)
-* [serializeBelongsTo](/ember-data/release/classes/EmbeddedRecordsMixin/methods/serializeBelongsTo?anchor=serializeBelongsTo)
-* [serializeHasMany](/ember-data/release/classes/EmbeddedRecordsMixin/methods/serializeHasMany?anchor=serializeHasMany)
-
 @class EmbeddedRecordsMixin
 @public
 */

package/declarations/serializer/-private/transforms/boolean.d.ts

@@ -5,8 +5,8 @@ export interface BooleanTransform {
 /**
 The `BooleanTransform` class is used to serialize and deserialize
 boolean attributes on Ember Data record objects. This transform is
-used when `boolean` is passed as the type parameter to the
-[attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function.
+used when `'boolean'` is passed as the type parameter to the
+{@link attr}function.
 
 Usage
 

package/declarations/serializer/-private/transforms/date.d.ts

@@ -5,8 +5,8 @@ export interface DateTransform {
 /**
 The `DateTransform` class is used to serialize and deserialize
 date attributes on Ember Data record objects. This transform is used
-when `date` is passed as the type parameter to the
-[attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function. It uses the [`ISO 8601`](https://en.wikipedia.org/wiki/ISO_8601)
+when `'date'` is passed as the type parameter to the
+{@link attr} function. It uses the [`ISO 8601`](https://en.wikipedia.org/wiki/ISO_8601)
 standard.
 
 ```js [app/models/score.js]

package/declarations/serializer/-private/transforms/number.d.ts

@@ -6,7 +6,7 @@ export interface NumberTransform {
 The `NumberTransform` class is used to serialize and deserialize
 numeric attributes on Ember Data record objects. This transform is
 used when `number` is passed as the type parameter to the
-[attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function.
+{@link attr} function.
 
 Usage
 

package/declarations/serializer/-private/transforms/string.d.ts

@@ -6,7 +6,7 @@ export interface StringTransform {
 The `StringTransform` class is used to serialize and deserialize
 string attributes on Ember Data record objects. This transform is
 used when `string` is passed as the type parameter to the
-[attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function.
+{@link attr} function.
 
 Usage
 

package/declarations/serializer/json-api.d.ts

@@ -1,24 +1,23 @@
 /**
-* <blockquote style="margin: 1em; padding: .1em 1em .1em 1em; border-left: solid 1em #E34C32; background: #e0e0e0;">
-<p>
+* :::danger
 ⚠️ <strong>This is LEGACY documentation</strong> for a feature that is no longer encouraged to be used.
 If starting a new app or thinking of implementing a new adapter, consider writing a
-<a href="/ember-data/release/classes/%3CInterface%3E%20Handler">Handler</a> instead to be used with the <a href="https://github.com/emberjs/data/tree/main/packages/request#readme">RequestManager</a>
-</p>
-</blockquote>
+{@link Handler} instead to be used with the {@link RequestManager}
+:::
 
-In EmberData a Serializer is used to serialize and deserialize
+In WarpDrive a Serializer is used to serialize and deserialize
 records when they are transferred in and out of an external source.
 This process involves normalizing property names, transforming
 attribute values and serializing relationships.
 
-`JSONAPISerializer` supports the http://jsonapi.org/ spec and is the
-serializer recommended by Ember Data.
+`JSONAPISerializer` supports the http://jsonapi.org/ spec, though
+even compliant {json:api} servers may find writing an application
+specific serializer better suited to their needs and more performant.
 
 This serializer normalizes a JSON API payload that looks like:
 
 ```js [app/models/player.js]
-import Model, { attr, belongsTo } from '@ember-data/model';
+import Model, { attr, belongsTo } from '@warp-drive/legacy/model';
 
 export default class Player extends Model {
 @attr('string') name;
@@ -29,7 +28,7 @@ export default class Player extends Model {
 ```
 
 ```js [app/models/club.js]
-import Model, { attr, hasMany } from '@ember-data/model';
+import Model, { attr, hasMany } from '@warp-drive/legacy/model';
 
 export default class Club extends Model {
 @attr('string') name;
@@ -82,7 +81,7 @@ export default class Club extends Model {
 }
 ```
 
-to the format that the Ember Data store expects.
+to the format that the JSONAPICache expects.
 
 ### Customizing meta
 
@@ -94,7 +93,7 @@ below shows how this could be done using `normalizeArrayResponse` and
 `extractRelationship`.
 
 ```js [app/serializers/application.js]
-import JSONAPISerializer from '@ember-data/serializer/json-api';
+import JSONAPISerializer from '@warp-drive/legacy/serializer/json-api';
 
 export default class ApplicationSerializer extends JSONAPISerializer {
 normalizeArrayResponse(store, primaryModelClass, payload, id, requestType) {

package/declarations/serializer/json.d.ts

@@ -1,18 +1,16 @@
 /**
-* <blockquote style="margin: 1em; padding: .1em 1em .1em 1em; border-left: solid 1em #E34C32; background: #e0e0e0;">
-<p>
-⚠️ <strong>This is LEGACY documentation</strong> for a feature that is no longer encouraged to be used.
+* :::danger
+⚠️ **This is LEGACY documentation** for a feature that is no longer encouraged to be used.
 If starting a new app or thinking of implementing a new adapter, consider writing a
-<a href="/ember-data/release/classes/%3CInterface%3E%20Handler">Handler</a> instead to be used with the <a href="https://github.com/emberjs/data/tree/main/packages/request#readme">RequestManager</a>
-</p>
-</blockquote>
+{@link Handler} instead to be used with the {@link RequestManager}
+:::
 
-In EmberData a Serializer is used to serialize and deserialize
+In WarpDrive a Serializer is used to serialize and deserialize
 records when they are transferred in and out of an external source.
 This process involves normalizing property names, transforming
 attribute values and serializing relationships.
 
-By default, EmberData uses and recommends the `JSONAPISerializer`.
+By default, WarpDrive uses and recommends the `JSONAPISerializer`.
 
 `JSONSerializer` is useful for simpler or legacy backends that may
 not support the http://jsonapi.org/ spec.
@@ -20,7 +18,7 @@ not support the http://jsonapi.org/ spec.
 For example, given the following `User` model and JSON payload:
 
 ```js [app/models/user.js]
-import Model, { attr, belongsTo, hasMany } from '@ember-data/model';
+import Model, { attr, belongsTo, hasMany } from '@warp-drive/legacy/model';
 
 export default class UserModel extends Model {
 @hasMany('user') friends;
@@ -41,8 +39,8 @@ house: '/houses/lefkada'
 }
 ```
 
-`JSONSerializer` will normalize the JSON payload to the JSON API format that the
-Ember Data store expects.
+`JSONSerializer` will normalize the JSON payload to the {json:api} format that the
+JSONAPICache uses to cache data in the Store.
 
 You can customize how JSONSerializer processes its payload by passing options in
 the `attrs` hash or by subclassing the `JSONSerializer` and overriding hooks:

package/declarations/serializer/rest.d.ts

@@ -1,11 +1,9 @@
 /**
-* <blockquote style="margin: 1em; padding: .1em 1em .1em 1em; border-left: solid 1em #E34C32; background: #e0e0e0;">
-<p>
-⚠️ <strong>This is LEGACY documentation</strong> for a feature that is no longer encouraged to be used.
+* :::danger
+⚠️ **This is LEGACY documentation** for a feature that is no longer encouraged to be used.
 If starting a new app or thinking of implementing a new adapter, consider writing a
-<a href="/ember-data/release/classes/%3CInterface%3E%20Handler">Handler</a> instead to be used with the <a href="https://github.com/emberjs/data/tree/main/packages/request#readme">RequestManager</a>
-</p>
-</blockquote>
+{@link Handler} instead to be used with the {@link RequestManager}
+:::
 
 Normally, applications will use the `RESTSerializer` by implementing
 the `normalize` method.

package/declarations/serializer.d.ts

@@ -1,13 +1,11 @@
 /**
 ## Overview
 
-<blockquote style="margin: 1em; padding: .1em 1em .1em 1em; border-left: solid 1em #E34C32; background: #e0e0e0;">
-<p>
-⚠️ <strong>This is LEGACY documentation</strong> for a feature that is no longer encouraged to be used.
+:::danger
+⚠️ **This is LEGACY documentation** for a feature that is no longer encouraged to be used.
 If starting a new app or thinking of implementing a new serializer, consider writing a
-<a href="/ember-data/release/classes/%3CInterface%3E%20Handler">Handler</a> instead to be used with the <a href="https://github.com/emberjs/data/tree/main/packages/request#readme">RequestManager</a>
-</p>
-</blockquote>
+{@link Handler} instead to be used with the {@link RequestManager}
+:::
 
 In order to properly manage and present your data, WarpDrive
 needs to understand the structure of data it receives.
@@ -16,14 +14,14 @@ needs to understand the structure of data it receives.
 the format WarpDrive understands.
 
 Data received from an API response is **normalized** into
-[JSON:API](https://jsonapi.org/) (the format used internally
+[{json:api}](https://jsonapi.org/) (the format used internally
 by WarpDrive), while data sent to an API is **serialized**
 into the format the API expects.
 
 ### Implementing a Serializer
 
 There are only two required serializer methods, one for
-normalizing data from the server API format into JSON:API, and
+normalizing data from the server API format into {json:api}, and
 another for serializing records via `Snapshots` into the expected
 server API format.
 
@@ -69,7 +67,7 @@ store.serializerFor('author');
 //   app/serializers/application.js
 ```
 
-Most requests in @warp-drive/legacy are made with respect to a particular `type` (or `modelName`)
+Most requests in `@warp-drive/legacy` are made with respect to a particular `type` (or `modelName`)
 (e.g., "get me the full collection of **books**" or "get me the **employee** whose id is 37"). We
 refer to this as the **primary** resource `type`.
 
@@ -93,7 +91,7 @@ Any serializer in `app/serializers/` can be looked up by `name` using `store.ser
 ### Default Serializers
 
 For applications whose APIs are *very close to* or *exactly* the **REST** format or **JSON:API**
-format the `@ember-data/serializer` package contains implementations these applications can
+format the `@warp-drive/legacy/serializer` package contains implementations these applications can
 extend. It also contains a simple `JSONSerializer` for serializing to/from very basic JSON objects.
 
 Many applications will find writing their own serializer to be more performant and less
@@ -124,8 +122,7 @@ And you can optionally override the following methods:
 
 * `normalize()`
 
-For an example implementation, see
-[JSONSerializer](JSONSerializer), the included JSON serializer.
+For an example implementation, see the included {@link JSONSerializer}.
 
 @class Serializer
 @public

package/dist/{-private-8UmnAf9J.js → -private-BG3bMiKp.js}

@@ -1,7 +1,8 @@
 import { Context } from '@warp-drive/core/reactive/-private';
 import { warn } from '@ember/debug';
 import { createDeferred } from '@warp-drive/core/request';
-import { assertPrivateStore, waitFor, coerceId } from '@warp-drive/core/store/-private';
+import { waitFor } from '@warp-drive/core/signals/-leaked';
+import { assertPrivateStore, coerceId } from '@warp-drive/core/store/-private';
 import { getOrSetGlobal } from '@warp-drive/core/types/-private';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 
@@ -1202,7 +1203,7 @@ function _flushPendingSave(store, pending) {
 
 /**
  * Utilities - often temporary - for maintaining backwards compatibility with
- * older parts of EmberData.
+ * older parts of WarpDrive.
  *
   @module
 */

package/dist/adapter/-private.js

@@ -1 +1 @@
-export { d as determineBodyPromise, g as fetch, p as parseResponseHeaders, b as serializeIntoHash, s as serializeQueryParams, a as setupFastboot } from "../serialize-into-hash-CS0MIv4F.js";
+export { d as determineBodyPromise, g as fetch, p as parseResponseHeaders, b as serializeIntoHash, s as serializeQueryParams, a as setupFastboot } from "../serialize-into-hash-DPZYoF-i.js";