@warp-drive/legacy 5.10.0-alpha.2 → 5.10.0-alpha.21

package/dist/{compat-BbNNmTM-.d.ts → compat-DoWEarkU.d.ts}

@@ -9,11 +9,13 @@ import { ChangedAttributesHash } from "@warp-drive/core/types/cache";
 import { PersistedResourceKey, ResourceKey as ResourceKey$1 } from "@warp-drive/core/types/identifier";
 import { TypeFromInstance, TypedRecordInstance } from "@warp-drive/core/types/record";
 import { LegacyAttributeField, LegacyRelationshipField } from "@warp-drive/core/types/schema/fields";
-//#region src/compat/legacy-network-handler/minimum-adapter-interface.d.ts
 type Group = Snapshot[];
 /**
  * The raw payload shape returned by a legacy adapter's request methods,
  * prior to being normalized by a {@link MinimumSerializerInterface}.
+ *
+ * @summary Raw object or array payload a legacy adapter resolves with, before a serializer normalizes it into a
+ * JSON:API document.
  */
 type AdapterPayload = Record<string, unknown> | unknown[];
 /**
@@ -29,6 +31,8 @@ application might expect these methods to be called.
 
 Methods that are not required are marked as **optional**.
 
+@summary Legacy contract for adapters: the `findRecord`, `query`, `createRecord`, and other methods the store
+calls to load and save data, and which are optional.
 @class (Interface) Adapter
 @public
 */
@@ -531,11 +535,12 @@ interface MinimumAdapterInterface {
    */
   destroy?(): void;
 }
-//#endregion
-//#region src/compat/legacy-network-handler/minimum-serializer-interface.d.ts
 /**
  * Options accepted by {@link MinimumSerializerInterface.serialize | serialize}
  * and related legacy serializer methods.
+ *
+ * @summary Options for legacy serializer `serialize` calls, such as `includeId` to include the record id in the
+ * output.
  */
 type SerializerOptions = {
   /**
@@ -556,6 +561,8 @@ application might expect these methods to be called.
 
 Methods that are not required are marked as **optional**.
 
+@summary Legacy contract for serializers: `normalizeResponse` to turn adapter payloads into JSON:API, plus
+`serialize` and other optional methods.
 @public
 */
 interface MinimumSerializerInterface {
@@ -746,8 +753,6 @@ interface MinimumSerializerInterface {
    */
   destroy?(): void;
 }
-//#endregion
-//#region src/compat/legacy-network-handler/snapshot.d.ts
 type RecordId = string | null;
 /**
 Snapshot is not directly instantiable.
@@ -1011,8 +1016,6 @@ declare class Snapshot<R = unknown> {
 	*/
   serialize(options?: SerializerOptions): unknown;
 }
-//#endregion
-//#region src/compat/legacy-network-handler/snapshot-record-array.d.ts
 /**
 SnapshotRecordArray is not directly instantiable.
 Instances are provided to consuming application's
@@ -1136,8 +1139,6 @@ declare class SnapshotRecordArray {
 	*/
   snapshots(): Snapshot[];
 }
-//#endregion
-//#region src/compat/legacy-network-handler/fetch-manager.d.ts
 type Deferred<T> = ReturnType<typeof createDeferred<T>>;
 declare const SaveOp: "___(unique) Symbol(SaveOp)";
 type FetchMutationOptions = FindRecordOptions & {
@@ -1185,25 +1186,24 @@ declare class FetchManager {
   fetchDataIfNeededForIdentifier(identifier: PersistedResourceKey, options: FindRecordOptions | undefined, request: ImmutableRequestInfo): Promise<PersistedResourceKey>;
   destroy(): void;
 }
-//#endregion
-//#region src/compat/-private.d.ts
 declare function upgradeStore(store: Store): asserts store is CompatStore;
-//#endregion
-//#region src/compat/legacy-network-handler/legacy-network-handler.d.ts
 /**
  * A {@link Handler} that fulfills legacy `findRecord`/`findAll`/`query`/
  * `queryRecord`/`findBelongsTo`/`findHasMany`/`createRecord`/`updateRecord`/
  * `deleteRecord` requests using the store's configured {@link MinimumAdapterInterface | adapter}
  * and {@link MinimumSerializerInterface | serializer}, passing any other
  * request through to the next handler unchanged.
+ *
+ * @summary Legacy `RequestManager` handler that fulfills find, query, create, update, and delete operations through
+ * the store's adapters and serializers, passing other requests along.
  */
 declare const LegacyNetworkHandler: Handler;
-//#endregion
-//#region src/compat.d.ts
 /**
  * Extends the signature of {@link Store} with additional
  * methods available when using the legacy network layer.
  *
+ * @summary Legacy `Store` type extended with `adapterFor`, `serializerFor`, `normalize`, `pushPayload`, and
+ * `serializeRecord` from the adapter and serializer network layer.
  * @public
  * @noInheritDoc
  * @legacy
@@ -1257,6 +1257,8 @@ interface LegacyStoreCompat extends Store {
   }>;
 }
 /**
+ * @summary Deprecated alias of `LegacyStoreCompat`, the `Store` type extended with legacy adapter and serializer
+ * methods.
  * @deprecated - use {@link LegacyStoreCompat} instead
  */
 type CompatStore = LegacyStoreCompat;
@@ -1269,6 +1271,8 @@ If no `person` adapter is found, this method will look
 for an `application` adapter (the default adapter for
 your entire application).
 
+@summary Legacy store method that returns the cached adapter for a model type, falling back to the `application`
+adapter.
 @public
 @param modelName
 */
@@ -1286,6 +1290,8 @@ your entire application).
 If a serializer cannot be found on the adapter, it will fall back
 to an instance of `JSONSerializer`.
 
+@summary Legacy store method that returns the cached serializer for a model type, falling back to the
+`application` serializer, or `null` if neither exists.
 @public
 @param modelName the record to serialize
 */
@@ -1309,6 +1315,8 @@ store.push(store.normalize(modelName, data));
 });
 ```
 
+@summary Legacy store method that converts a raw payload into the normalized document `store.push` expects, using
+the serializer for the given model type.
 @legacy
 @public
 @param modelName The name of the model type for this payload
@@ -1366,6 +1374,8 @@ store.pushPayload(pushData); // Will use the application serializer
 store.pushPayload('post', pushData); // Will use the post serializer
 ```
 
+@summary Legacy store method that pushes a raw payload into the store after the application serializer, or the
+given model type's serializer, normalizes it.
 @public
 @param modelName Optionally, a model type used to determine which serializer will be used
 @param inputPayload
@@ -1374,13 +1384,16 @@ declare function pushPayload(this: Store, modelName: string, inputPayload: Objec
 /**
  * Serializes a record using the store's legacy network layer, as with
  * {@link LegacyStoreCompat.serializeRecord | store.serializeRecord}.
+ *
+ * @summary Legacy store method that serializes a record into a payload using its model type's serializer.
  */
 declare function serializeRecord(this: Store, record: unknown, options?: SerializerOptions): unknown;
 /**
  * Destroys any adapters/serializers the legacy network layer has created
  * for this store, invoked when the store itself is destroyed.
+ *
+ * @summary Legacy store teardown hook that destroys every adapter and serializer instance the store has cached.
  */
 declare function cleanup(this: Store): void;
-//#endregion
 export { AdapterPayload as _, normalize as a, serializerFor as c, FetchManager as d, SaveOp as f, SerializerOptions as g, MinimumSerializerInterface as h, cleanup as i, LegacyNetworkHandler as l, Snapshot as m, LegacyStoreCompat as n, pushPayload as o, SnapshotRecordArray as p, adapterFor as r, serializeRecord as s, CompatStore as t, upgradeStore as u, MinimumAdapterInterface as v };
-//# sourceMappingURL=compat-BbNNmTM-.d.ts.map
+//# sourceMappingURL=compat-DoWEarkU.d.ts.map

package/dist/compat-DoWEarkU.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compat-DoWEarkU.d.ts","names":["RelationshipSchema","ResourceKey","ResourceKey"],"sources":["../src/compat/legacy-network-handler/minimum-adapter-interface.ts","../src/compat/legacy-network-handler/minimum-serializer-interface.ts","../src/compat/legacy-network-handler/snapshot.ts","../src/compat/legacy-network-handler/snapshot-record-array.ts","../src/compat/legacy-network-handler/fetch-manager.ts","../src/compat/-private.ts","../src/compat/legacy-network-handler/legacy-network-handler.ts","../src/compat.ts"],"mappings":"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"}

package/dist/compat.d.ts

@@ -1,2 +1,2 @@
-import { _ as AdapterPayload, a as normalize, c as serializerFor, g as SerializerOptions, h as MinimumSerializerInterface, i as cleanup, l as LegacyNetworkHandler, n as LegacyStoreCompat, o as pushPayload, r as adapterFor, s as serializeRecord, t as CompatStore, v as MinimumAdapterInterface } from "./compat-BbNNmTM-.js";
+import { _ as AdapterPayload, a as normalize, c as serializerFor, g as SerializerOptions, h as MinimumSerializerInterface, i as cleanup, l as LegacyNetworkHandler, n as LegacyStoreCompat, o as pushPayload, r as adapterFor, s as serializeRecord, t as CompatStore, v as MinimumAdapterInterface } from "./compat-DoWEarkU.js";
 export { type AdapterPayload, CompatStore, LegacyNetworkHandler, LegacyStoreCompat, type MinimumAdapterInterface, type MinimumSerializerInterface, type SerializerOptions, adapterFor, cleanup, normalize, pushPayload, serializeRecord, serializerFor };

package/dist/compat.js

@@ -1,3 +1,3 @@
-import { a as serializeRecord, i as pushPayload, n as cleanup, o as serializerFor, r as normalize, s as LegacyNetworkHandler, t as adapterFor } from "./compat-DcHVxuuZ.js";
+import { a as serializeRecord, i as pushPayload, n as cleanup, o as serializerFor, r as normalize, s as LegacyNetworkHandler, t as adapterFor } from "./compat-C-yQnbkF.js";
 
 export { LegacyNetworkHandler, adapterFor, cleanup, normalize, pushPayload, serializeRecord, serializerFor };

package/dist/{error-CzkyXr1Q.d.ts → error-798wGD3r.d.ts}

@@ -1,7 +1,9 @@
 import { ApiError } from "@warp-drive/core/types/spec/error";
-//#region src/adapter/error.d.ts
 /**
  * The shape of the errors thrown/returned by {@link AdapterError} and its subclasses.
+ *
+ * @summary Legacy adapter error shape: an `Error` flagged `isAdapterError` with a `code` string and a {json:api}
+ * `errors` array, as thrown by `AdapterError` and its subclasses.
  */
 interface AdapterRequestError<T extends string = string> extends Error {
   /**
@@ -20,6 +22,9 @@ interface AdapterRequestError<T extends string = string> extends Error {
 /**
  * The static interface shared by {@link AdapterError} and its subclasses,
  * allowing further subclassing via {@link AdapterRequestErrorConstructor.extend | extend}.
+ *
+ * @summary Static side of the legacy adapter error constructors: `new (errors?, message?)` plus `extend({ message })`
+ * for creating further error subclasses.
  */
 interface AdapterRequestErrorConstructor<Instance extends AdapterRequestError = AdapterRequestError> {
   new (errors?: unknown[], message?: string): Instance;
@@ -32,6 +37,9 @@ interface AdapterRequestErrorConstructor<Instance extends AdapterRequestError =
 }
 /**
  * The {@link AdapterRequestError} shape thrown by the {@link AdapterError} constructor.
+ *
+ * @summary Legacy base error an adapter returns or throws to signal a failed API request; extend it to define
+ * app-specific error types.
  */
 type AdapterError = AdapterRequestError<"AdapterError">;
 /**
@@ -130,11 +138,15 @@ type AdapterError = AdapterRequestError<"AdapterError">;
  * or on whichever of the {@link AdapterError} subclasses' `code` values
  * (e.g. `'InvalidError'`, `'NotFoundError'`) the error's `code` matches.
  *
+ * @summary Legacy base error constructor an adapter uses to signal a failed API request; call `extend` on it to
+ * define app-specific error types.
  * @public
  */
 declare const AdapterError: AdapterRequestErrorConstructor<AdapterError>;
 /**
  * The {@link AdapterRequestError} shape thrown by the {@link InvalidError} constructor.
+ * @summary Instance type of the legacy `InvalidError`, the adapter error for a request the API rejected as
+ * semantically invalid.
  */
 type InvalidError = AdapterRequestError<"InvalidError">;
 /**
@@ -192,11 +204,15 @@ type InvalidError = AdapterRequestError<"InvalidError">;
  * model. As a result, it is safe for the `InvalidError` to wrap the error
  * payload unaltered.
  *
+ * @summary Legacy adapter error signaling that the API rejected a request as semantically invalid, typically failed
+ * server-side validation, putting the record in the `invalid` state.
  * @public
  */
 declare const InvalidError: AdapterRequestErrorConstructor<InvalidError>;
 /**
  * The {@link AdapterRequestError} shape thrown by the {@link TimeoutError} constructor.
+ *
+ * @summary Legacy adapter error signaling that a request to the API timed out without receiving a response.
  */
 type TimeoutError = AdapterRequestError<"TimeoutError">;
 /**
@@ -224,11 +240,15 @@ type TimeoutError = AdapterRequestError<"TimeoutError">;
  * }
  * ```
  *
+ * @summary Legacy adapter error constructor for signaling that a request to the API timed out without receiving a
+ * response.
  * @public
  */
 declare const TimeoutError: AdapterRequestErrorConstructor<TimeoutError>;
 /**
  * The {@link AdapterRequestError} shape thrown by the {@link AbortError} constructor.
+ *
+ * @summary Legacy adapter error signaling that a request to the API was aborted before a response arrived.
  */
 type AbortError = AdapterRequestError<"AbortError">;
 /**
@@ -258,11 +278,16 @@ type AbortError = AdapterRequestError<"AbortError">;
  * }
  * ```
  *
+ * @summary Legacy adapter error constructor for signaling that a request to the API was aborted before a response
+ * arrived.
  * @public
  */
 declare const AbortError: AdapterRequestErrorConstructor<AbortError>;
 /**
  * The {@link AdapterRequestError} shape thrown by the {@link UnauthorizedError} constructor.
+ *
+ * @summary Legacy adapter error for an HTTP 401 response, signaling that authorization is required and failed or
+ * was not provided.
  */
 type UnauthorizedError = AdapterRequestError<"UnauthorizedError">;
 /**
@@ -291,11 +316,16 @@ type UnauthorizedError = AdapterRequestError<"UnauthorizedError">;
  * }
  * ```
  *
+ * @summary Legacy adapter error constructor for an HTTP 401 response, signaling that authorization is required and
+ * failed or was not provided.
  * @public
  */
 declare const UnauthorizedError: AdapterRequestErrorConstructor<UnauthorizedError>;
 /**
  * The {@link AdapterRequestError} shape thrown by the {@link ForbiddenError} constructor.
+ *
+ * @summary Legacy adapter error for an HTTP 403 response, signaling that the server refused a valid request the
+ * user lacks permission for.
  */
 type ForbiddenError = AdapterRequestError<"ForbiddenError">;
 /**
@@ -326,11 +356,16 @@ type ForbiddenError = AdapterRequestError<"ForbiddenError">;
  * }
  * ```
  *
+ * @summary Legacy adapter error constructor for an HTTP 403 response, signaling that the server refused a valid
+ * request the user lacks permission for.
  * @public
  */
 declare const ForbiddenError: AdapterRequestErrorConstructor<ForbiddenError>;
 /**
  * The {@link AdapterRequestError} shape thrown by the {@link NotFoundError} constructor.
+ *
+ * @summary Legacy adapter error for an HTTP 404 response, signaling that the requested resource does not exist on
+ * the API.
  */
 type NotFoundError = AdapterRequestError<"NotFoundError">;
 /**
@@ -362,11 +397,16 @@ type NotFoundError = AdapterRequestError<"NotFoundError">;
  * }
  * ```
  *
+ * @summary Legacy adapter error constructor for an HTTP 404 response, signaling that the requested resource does not
+ * exist on the API.
  * @public
  */
 declare const NotFoundError: AdapterRequestErrorConstructor<NotFoundError>;
 /**
  * The {@link AdapterRequestError} shape thrown by the {@link ConflictError} constructor.
+ *
+ * @summary Legacy adapter error for an HTTP 409 response, signaling that the request conflicts with existing
+ * server state, such as a duplicate client-generated id.
  */
 type ConflictError = AdapterRequestError<"ConflictError">;
 /**
@@ -395,11 +435,16 @@ type ConflictError = AdapterRequestError<"ConflictError">;
  * }
  * ```
  *
+ * @summary Legacy adapter error constructor for an HTTP 409 response, signaling that the request conflicts with
+ * existing server state, such as a duplicate client-generated id.
  * @public
  */
 declare const ConflictError: AdapterRequestErrorConstructor<ConflictError>;
 /**
  * The {@link AdapterRequestError} shape thrown by the {@link ServerError} constructor.
+ *
+ * @summary Legacy adapter error for an HTTP 500 response, signaling that the API failed internally and an
+ * immediate retry is unlikely to succeed.
  */
 type ServerError = AdapterRequestError<"ServerError">;
 /**
@@ -427,9 +472,10 @@ type ServerError = AdapterRequestError<"ServerError">;
  * }
  * ```
  *
+ * @summary Legacy adapter error constructor for an HTTP 500 response, signaling that the API failed internally and
+ * an immediate retry is unlikely to succeed.
  * @public
  */
 declare const ServerError: AdapterRequestErrorConstructor<ServerError>;
-//#endregion
 export { ConflictError as a, NotFoundError as c, UnauthorizedError as d, AdapterRequestErrorConstructor as i, ServerError as l, AdapterError as n, ForbiddenError as o, AdapterRequestError as r, InvalidError as s, AbortError as t, TimeoutError as u };
-//# sourceMappingURL=error-CzkyXr1Q.d.ts.map
+//# sourceMappingURL=error-798wGD3r.d.ts.map

package/dist/error-798wGD3r.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-798wGD3r.d.ts","names":[],"sources":["../src/adapter/error.ts"],"mappings":";;;;;;;UAgDiB,oBAAoB,mCAAmC;;;;EAItE;;;;EAIA,MAAM;;;;EAIN,QAAQ;;;;;;;;;UASO,+BAA+B,iBAAiB,sBAAsB;OAChF,oBAAoB,mBAAmB;;;;EAI5C,OAAO;IAAW;MAAoB;;;;;;;;KAc5B,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqGd,cAAc,+BAA+B;;;;;;KAgC9C,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4Dd,cAAc,+BAA+B;;;;;;KAW9C,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8Bd,cAAc,+BAA+B;;;;;;KAW9C,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgCZ,YAAY,+BAA+B;;;;;;;KAY5C,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BnB,mBAAmB,+BAA+B;;;;;;;KAYnD,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiChB,gBAAgB,+BAA+B;;;;;;;KAYhD,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCf,eAAe,+BAA+B;;;;;;;KAY/C,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+Bf,eAAe,+BAA+B;;;;;;;KAY/C,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8Bb,aAAa,+BAA+B"}

package/dist/{errors-CS110tMl.js → errors-BEExAZtv.js}

@@ -1,5 +1,5 @@
-import { t as upgradeStore } from "./-private-DccRZQsm.js";
-import { n as decorateMethodV2, r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-DMTJ0Kb3.js";
+import { t as upgradeStore } from "./-private-0_Oc-M3x.js";
+import { n as decorateMethodV2 } from "./runtime--fcdnjmJ-5yaSpa-d.js";
 import { assertPrivateStore, createLegacyManyArray, fastPush, isPrivateStore, isResourceKey, recordIdentifierFor, storeFor } from "@warp-drive/core/store/-private";
 import { Context } from "@warp-drive/core/reactive/-private";
 import { defineNonEnumerableSignal, defineSignal, memoized, notifyInternalSignal } from "@warp-drive/core/signals/-leaked";
@@ -11,13 +11,11 @@ import PromiseProxyMixin from "@ember/object/promise-proxy-mixin";
 import ObjectProxy from "@ember/object/proxy";
 import { A } from "@ember/array";
 import ArrayProxy from "@ember/array/proxy";
-import { mapBy, not } from "@ember/object/computed";
 
-//#region src/model/-private/promise-proxy-base.js
+// src/model/-private/promise-proxy-base.js
 const PromiseObject = ObjectProxy.extend(PromiseProxyMixin);
 
-//#endregion
-//#region src/model/-private/promise-belongs-to.ts
+// src/model/-private/promise-belongs-to.ts
 const LegacyPromiseProxy = Symbol.for("LegacyPromiseProxy");
 const Extended = PromiseObject;
 /**
@@ -56,8 +54,7 @@ Use \`record.belongsTo(relationshipName).meta()\` instead.`);
 };
 PromiseBelongsTo.prototype[LegacyPromiseProxy] = true;
 
-//#endregion
-//#region src/model/-private/promise-many-array.ts
+// src/model/-private/promise-many-array.ts
 /**
 This class is returned as the result of accessing an async hasMany relationship
 on an instance of a Model extending from `@warp-drive/legacy/model`.
@@ -71,6 +68,8 @@ In your JS code you should resolve the promise first.
 const comments = await post.comments;
 ```
 
+@summary Legacy promise-like, iterable proxy returned by an async `hasMany` on a `Model`, which templates can
+consume while the related records load.
 @public
 */
 var PromiseManyArray = class {
@@ -241,8 +240,7 @@ function tapPromise(proxy, promise) {
 	});
 }
 
-//#endregion
-//#region src/model/-private/debug/assert-polymorphic-type.ts
+// src/model/-private/debug/assert-polymorphic-type.ts
 let assertPolymorphicType;
 if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) assertPolymorphicType = function assertPolymorphicType(parentIdentifier, parentDefinition, addedIdentifier, store) {
 	if (parentDefinition.inverseIsImplicit) return;
@@ -259,8 +257,7 @@ if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) assertPolymorphicType
 	}
 };
 
-//#endregion
-//#region src/model/-private/references/has-many.ts
+// src/model/-private/references/has-many.ts
 function isResourceIdentiferWithRelatedLinks$1(value) {
 	return Boolean(value && value.links && value.links.related);
 }
@@ -800,8 +797,7 @@ function ensureRefCanSubscribe(rel) {
 	return true;
 }
 
-//#endregion
-//#region src/model/-private/references/belongs-to.ts
+// src/model/-private/references/belongs-to.ts
 function isResourceIdentiferWithRelatedLinks(value) {
 	return Boolean(value && value.links && value.links.related);
 }
@@ -1298,8 +1294,7 @@ var BelongsToReference = class {
 };
 defineNonEnumerableSignal(BelongsToReference.prototype, "_ref", 0);
 
-//#endregion
-//#region src/model/-private/legacy-relationships-support.ts
+// src/model/-private/legacy-relationships-support.ts
 const LEGACY_SUPPORT = getOrSetGlobal("LEGACY_SUPPORT", /* @__PURE__ */ new Map());
 function releaseLegacySupport(identifier) {
 	const support = LEGACY_SUPPORT.get(identifier);
@@ -1587,16 +1582,17 @@ var LegacySupport = class {
 		if (this.graph) {
 			if (!resource) return;
 			const { definition, state } = relationship;
-			/* @__PURE__ */ upgradeStore(this.store);
-			const adapter = this.store.adapterFor?.(definition.type);
-			const { isStale, hasDematerializedInverse, hasReceivedData, isEmpty, shouldForceReload } = state;
-			const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this.store, resource);
-			const identifiers = resource.data;
-			const shouldFindViaLink = resource.links && resource.links.related && (typeof adapter?.findHasMany === "function" || typeof identifiers === "undefined") && (shouldForceReload || hasDematerializedInverse || isStale || !allInverseRecordsAreLoaded && !isEmpty);
 			const field = this.store.schema.fields({ type: definition.inverseType }).get(definition.key);
 			macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) && ((test) => {
 				if (!test) throw new Error(`Expected a hasMany field definition for ${definition.inverseType}.${definition.key}`);
 			})(field && field.kind === "hasMany");
+			/* @__PURE__ */ upgradeStore(this.store);
+			const isLinksMode = Boolean(field.options.linksMode);
+			const adapter = isLinksMode ? void 0 : this.store.adapterFor?.(definition.type);
+			const { isStale, hasDematerializedInverse, hasReceivedData, isEmpty, shouldForceReload } = state;
+			const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this.store, resource);
+			const identifiers = resource.data;
+			const shouldFindViaLink = resource.links && resource.links.related && (isLinksMode || typeof adapter?.findHasMany === "function" || typeof identifiers === "undefined") && (shouldForceReload || hasDematerializedInverse || isStale || !allInverseRecordsAreLoaded && !isEmpty);
 			const request = {
 				useLink: shouldFindViaLink,
 				field,
@@ -1618,6 +1614,12 @@ var LegacySupport = class {
 					method: "GET",
 					records: identifiers || [],
 					data: request,
+					options: {
+						field,
+						identifier: parentIdentifier,
+						links: resource.links,
+						meta: resource.meta
+					},
 					[EnableHydration]: false
 				} : {
 					op: "findHasMany",
@@ -1683,6 +1685,12 @@ var LegacySupport = class {
 				method: "GET",
 				records: identifier ? [identifier] : [],
 				data: request,
+				options: {
+					field,
+					identifier: parentIdentifier,
+					links: resource.links,
+					meta: resource.meta
+				},
 				[EnableHydration]: false
 			} : {
 				op: "findBelongsTo",
@@ -1812,8 +1820,7 @@ function getRealFieldName(context, key) {
 	return field ? field.sourceKey ?? field.name : key;
 }
 
-//#endregion
-//#region src/model/-private/errors.ts
+// src/model/-private/errors.ts
 const ArrayProxyWithCustomOverrides = ArrayProxy;
 /**
 Holds validation errors for a given record, organized by attribute names.
@@ -1941,15 +1948,17 @@ var Errors = class extends ArrayProxyWithCustomOverrides {
 	@public
 	@type {Array}
 	*/
-	static {
-		decorateFieldV2(this.prototype, "messages", [mapBy("content", "message")]);
+	get messages() {
+		return A(this.content.map((error) => error.message));
 	}
-	#messages = (initializeDeferredDecorator(this, "messages"), void 0);
 	/**
 	@property content
 	@type {Array}
 	@private
 	*/
+	static {
+		decorateMethodV2(this.prototype, "messages", [computed("content.@each.message")]);
+	}
 	get content() {
 		return A();
 	}
@@ -1978,10 +1987,9 @@ var Errors = class extends ArrayProxyWithCustomOverrides {
 	@public
 	@readonly
 	*/
-	static {
-		decorateFieldV2(this.prototype, "isEmpty", [not("length")]);
+	get isEmpty() {
+		return !this.length;
 	}
-	#isEmpty = (initializeDeferredDecorator(this, "isEmpty"), void 0);
 	/**
 	Manually adds errors to the record. This will trigger the `becameInvalid` event/ lifecycle method on
 	the record and transition the record into an `invalid` state.
@@ -2013,6 +2021,9 @@ var Errors = class extends ArrayProxyWithCustomOverrides {
 	@param {String} attribute - the property name of an attribute or relationship
 	@param {string[]|string} messages - an error message or array of error messages for the attribute
 	*/
+	static {
+		decorateMethodV2(this.prototype, "isEmpty", [computed("length")]);
+	}
 	add(attribute, messages) {
 		const errors = this._findOrCreateMessages(attribute, messages);
 		this.addObjects(errors);
@@ -2136,6 +2147,5 @@ var Errors = class extends ArrayProxyWithCustomOverrides {
 	}
 };
 
-//#endregion
 export { PromiseManyArray as a, releaseLegacySupport as i, LEGACY_SUPPORT as n, PromiseBelongsTo as o, lookupLegacySupport as r, Errors as t };
-//# sourceMappingURL=errors-CS110tMl.js.map
+//# sourceMappingURL=errors-BEExAZtv.js.map