@warp-drive/core 5.7.0-alpha.23 → 5.7.0-alpha.24

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

@@ -301,6 +301,12 @@ export declare class SchemaService implements SchemaServiceInterface {
 	* @internal
 	*/
 	_kind<T extends keyof KindFns>(mode: string, kind: T): KindFns[T];
+	/**
+	* Registers a {@link HashFn} for use with a {@link HashField} for
+	* either {@link ObjectSchema} identity or polymorphic type calculation.
+	*
+	* @public
+	*/
 	registerHashFn<T extends object>(hashFn: HashFn<T>): void;
 	fields({ type }: {
 		type: string;

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

@@ -1,5 +1,5 @@
 import type { RequestKey } from "../../types/identifier.js";
-import type { RequestInfo } from "../../types/request.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";
 /**
@@ -90,7 +90,7 @@ import { IS_CACHE_HANDLER } from "./utils.js";
 * type StructuredDocument<T> = StructuredDataDocument<T> | StructuredErrorDocument;
 * ```
 *
-* @class RequestManager
+* @hideconstructor
 * @public
 */
 export declare class RequestManager {
@@ -132,8 +132,6 @@ export declare class RequestManager {
 	* curry the request, or pass along a modified request.
 	*
 	* @public
-	* @param {Handler[]} newHandlers
-	* @return {ThisType}
 	*/
 	use(newHandlers: Handler[]): this;
 	/**
@@ -142,8 +140,6 @@ export declare class RequestManager {
 	* Returns a Future that fulfills with a StructuredDocument
 	*
 	* @public
-	* @param {RequestInfo} request
-	* @return {Future}
 	*/
 	request<RT>(request: RequestInfo<RT>): Future<RT>;
 	/**

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

@@ -1,6 +1,8 @@
 /* eslint-disable no-irregular-whitespace */
+import type { Store } from "../../store/-private.js";
 import type { RequestKey } from "../../types/identifier.js";
 import type { IS_FUTURE, RequestContext, RequestInfo, ResponseInfo, StructuredDataDocument } from "../../types/request.js";
+import type { RequestManager } from "./manager.js";
 export interface GodContext {
 	controller: AbortController;
 	response: ResponseInfo | null;
@@ -8,6 +10,7 @@ export interface GodContext {
 	hasRequestedStream: boolean;
 	id: number;
 	identifier: RequestKey | null;
+	requester: RequestManager | Store;
 }
 export type Deferred<T> = {
 	resolve(v: T): void;
@@ -32,10 +35,14 @@ export type DeferredStream = {
 * @public
 */
 export interface Future<T> extends Promise<StructuredDataDocument<T>> {
+	/** @internal */
 	[IS_FUTURE]: true;
 	/**
 	* Cancel this request by firing the {@link AbortController}'s signal.
 	*
+	* This method can be used as an action or event handler as its
+	* context is bound to the Future instance.
+	*
 	* @privateRemarks
 	* [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortController/abort)
 	*
@@ -46,8 +53,10 @@ export interface Future<T> extends Promise<StructuredDataDocument<T>> {
 	/**
 	* Get the response stream, if any, once made available.
 	*
+	* This method can be used as an action or event handler as its
+	* context is bound to the Future instance.
+	*
 	* @public
-	* @return {Promise<ReadableStream | null>}
 	*/
 	getStream(): Promise<ReadableStream | null>;
 	/**
@@ -55,28 +64,27 @@ export interface Future<T> extends Promise<StructuredDataDocument<T>> {
 	*  mostly useful for instrumentation and infrastructure.
 	*
 	* @param cb the callback to run
-	* @public
-	* @return {void}
 	*/
 	onFinalize(cb: () => void): void;
 	/**
 	* The identifier of the associated request, if any, as
 	* assigned by the CacheHandler.
-	*
-	* @property lid
-	* @type {RequestKey | null}
-	* @public
 	*/
 	lid: RequestKey | null;
 	/**
 	* The id of the associated request, if any, as assigned
 	* by the RequestManager
 	*
-	* @property id
-	* @type {Number}
-	* @public
+	* This is not unique across Manager instances and cannot
+	* be used to identify or dedupe requests.
 	*/
 	id: number;
+	/**
+	* The RequestManager or Store that initiated this request.
+	*
+	* @private
+	*/
+	requester: RequestManager | Store;
 }
 export type DeferredFuture<T> = {
 	resolve(v: StructuredDataDocument<T>): void;
@@ -191,8 +199,6 @@ 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.
 
-
-@class (Interface) Handler
 @public
 */
 export interface Handler {
@@ -202,20 +208,17 @@ export interface Handler {
 	* other handlers.
 	*
 	* @public
-	* @param context
-	* @param next
 	*/
 	request<T = unknown>(context: RequestContext, next: NextFn<T>): Promise<T | StructuredDataDocument<T>> | Future<T>;
 }
 /**
-* The CacheHandler is identical to other handlers ecxept that it
+* The CacheHandler is identical to other handlers except that it
 * is allowed to return a value synchronously. This is useful for
 * features like reducing microtask queueing when de-duping.
 *
 * A RequestManager may only have one CacheHandler, registered via
 * `manager.useCache(CacheHandler)`.
 *
-* @class (Interface) CacheHandler
 * @public
 */
 export interface CacheHandler {
@@ -225,8 +228,6 @@ export interface CacheHandler {
 	* other handlers.
 	*
 	* @public
-	* @param context
-	* @param next
 	*/
 	request<T = unknown>(context: RequestContext, next: NextFn<T>): Promise<T | StructuredDataDocument<T>> | Future<T> | T;
 }

package/declarations/store/-private/new-core-tmp/request-state.d.ts

@@ -7,6 +7,7 @@ import type { PendingPromise, RejectedPromise, ResolvedPromise } from "./promise
 * reactive properties that can be used to build UIs that respond
 * to the progress of a request.
 *
+* @hideconstructor
 */
 export declare class RequestLoadingState {
 	private _sizeHint;
@@ -71,11 +72,52 @@ export interface PendingRequest extends PendingPromise {
 *
 */
 export interface ResolvedRequest<RT> extends ResolvedPromise<RT> {
+	/**
+	* Retries the request with high (blocking) priority. This is the
+	* same as having passed `cacheOptions.reload = true` on the original
+	* request.
+	*
+	* This will not change the existing request's state. To subscribe
+	* to the new request's state, use `getRequestState` on the returned
+	* {@link Future}.
+	*
+	* ```ts
+	* const future = state.reload();
+	* const state = getRequestState(future);
+	* ```
+	*
+	* It is safe to pass this around as an "action" or "event" handler
+	* as its context is bound.
+	*/
+	reload(): Future<RT>;
+	/**
+	* Retries the request with low (non-blocking) priority. This is the
+	* same as having passed `cacheOptions.backgroundReload = true` on the original
+	* request.
+	*
+	* This will not change the existing request's state. To subscribe
+	* to the new request's state, use `getRequestState` on the returned
+	* {@link Future}.
+	*
+	* ```ts
+	* const future = state.reload();
+	* const state = getRequestState(future);
+	* ```
+	*
+	* It is safe to pass this around as an "action" or "event" handler
+	* as its context is bound.
+	*/
+	refresh(usePolicy?: boolean): Future<RT>;
 	/**
 	* Whether the request is cancelled.
 	*
 	*/
 	isCancelled: false;
+	/**
+	* A lazily created {@link RequestLoadingState} instance
+	* which provides a number of reactive properties that can be used
+	* to build UIs that respond to the progress of a request.
+	*/
 	loadingState: RequestLoadingState;
 	request: ImmutableRequestInfo<RT> | null;
 	response: Response | ResponseInfo | null;
@@ -92,6 +134,42 @@ export interface RejectedRequest<
 	RT,
 	E extends StructuredErrorDocument = StructuredErrorDocument
 > extends RejectedPromise<E> {
+	/**
+	* Retries the request with high (blocking) priority. This is the
+	* same as having passed `cacheOptions.reload = true` on the original
+	* request.
+	*
+	* This will not change the existing request's state. To subscribe
+	* to the new request's state, use `getRequestState` on the returned
+	* {@link Future}.
+	*
+	* ```ts
+	* const future = state.reload();
+	* const state = getRequestState(future);
+	* ```
+	*
+	* It is safe to pass this around as an "action" or "event" handler
+	* as its context is bound.
+	*/
+	reload(): Future<RT>;
+	/**
+	* Retries the request with low (non-blocking) priority. This is the
+	* same as having passed `cacheOptions.backgroundReload = true` on the original
+	* request.
+	*
+	* This will not change the existing request's state. To subscribe
+	* to the new request's state, use `getRequestState` on the returned
+	* {@link Future}.
+	*
+	* ```ts
+	* const future = state.reload();
+	* const state = getRequestState(future);
+	* ```
+	*
+	* It is safe to pass this around as an "action" or "event" handler
+	* as its context is bound.
+	*/
+	refresh(usePolicy?: boolean): Future<RT>;
 	/**
 	* Whether the request is cancelled.
 	*
@@ -111,6 +189,42 @@ export interface CancelledRequest<
 	RT,
 	E extends StructuredErrorDocument = StructuredErrorDocument
 > {
+	/**
+	* Retries the request with high (blocking) priority. This is the
+	* same as having passed `cacheOptions.reload = true` on the original
+	* request.
+	*
+	* This will not change the existing request's state. To subscribe
+	* to the new request's state, use `getRequestState` on the returned
+	* {@link Future}.
+	*
+	* ```ts
+	* const future = state.reload();
+	* const state = getRequestState(future);
+	* ```
+	*
+	* It is safe to pass this around as an "action" or "event" handler
+	* as its context is bound.
+	*/
+	reload(): Future<RT>;
+	/**
+	* Retries the request with low (non-blocking) priority. This is the
+	* same as having passed `cacheOptions.backgroundReload = true` on the original
+	* request.
+	*
+	* This will not change the existing request's state. To subscribe
+	* to the new request's state, use `getRequestState` on the returned
+	* {@link Future}.
+	*
+	* ```ts
+	* const future = state.reload();
+	* const state = getRequestState(future);
+	* ```
+	*
+	* It is safe to pass this around as an "action" or "event" handler
+	* as its context is bound.
+	*/
+	refresh(usePolicy?: boolean): Future<RT>;
 	/**
 	* The status of the request.
 	*

package/declarations/store/-private/new-core-tmp/request-subscription.d.ts

@@ -29,14 +29,14 @@ export interface SubscriptionArgs<
 	* by either the `store.request` or `store.requestManager.request` methods.
 	*
 	*/
-	request?: Future<RT>;
+	request?: Future<RT> | undefined | null;
 	/**
 	* A query to use for the request. This should be an object that can be
 	* passed to `store.request`. Use this in place of `@request` if you would
 	* like the component to also initiate the request.
 	*
 	*/
-	query?: StoreRequestInput<RT>;
+	query?: StoreRequestInput<RT> | undefined | null;
 	/**
 	* The autorefresh behavior for the request. This can be a boolean, or any
 	* combination of the following values: `'online'`, `'interval'`, `'invalid'`.
@@ -227,6 +227,10 @@ export declare class RequestSubscription<
 	*/
 	private _maybeUpdate;
 	/**
+	* @internal
+	*/
+	private _getRequester;
+	/**
 	* Retry the request, reloading it from the server.
 	*/
 	retry: () => Promise<void>;

package/declarations/types/request.d.ts

@@ -1,9 +1,9 @@
+import type { Store } from "../store/-private.js";
 import type { ResourceKey } from "./identifier.js";
 import type { QueryParamsSerializationOptions } from "./params.js";
 import type { TypeFromInstanceOrString } from "./record.js";
 import type { ResourceIdentifierObject } from "./spec/json-api-raw.js";
 import type { RequestSignature } from "./symbols.js";
-type Store = unknown;
 export declare const SkipCache: "___(unique) Symbol(SkipCache)";
 export declare const EnableHydration: "___(unique) Symbol(EnableHydration)";
 export declare const IS_FUTURE: "___(unique) Symbol(IS_FUTURE)";

package/dist/{context-kQXhkeBj.js → context-BNZebmoO.js}

@@ -450,6 +450,7 @@ function upgradePromise(promise, future) {
   promise.onFinalize = future.onFinalize;
   promise.id = future.id;
   promise.lid = future.lid;
+  promise.requester = future.requester;
   return promise;
 }
 function createFuture(owner) {
@@ -477,6 +478,7 @@ function createFuture(owner) {
   };
   promise.id = owner.requestId;
   promise.lid = owner.god.identifier;
+  promise.requester = owner.god.requester;
   deferred.promise = promise;
   return deferred;
 }

package/dist/index.js

@@ -1,9 +1,10 @@
 import { setLogging, getRuntimeConfig } from './types/runtime.js';
-import { a as cloneResponseProperties, I as IS_CACHE_HANDLER, b as assertValidRequest, e as executeNextHandler, d as getRequestResult, u as upgradePromise, s as setPromiseResult, f as clearRequestResult } from "./context-kQXhkeBj.js";
+import { a as cloneResponseProperties, I as IS_CACHE_HANDLER, b as assertValidRequest, e as executeNextHandler, d as getRequestResult, u as upgradePromise, s as setPromiseResult, f as clearRequestResult } from "./context-BNZebmoO.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { w as waitFor } from "./configure-B48bFHOl.js";
 import { peekUniversalTransient, setUniversalTransient } from './types/-private.js';
-export { C as CacheHandler, S as Store, r as recordIdentifierFor, M as setIdentifierForgetMethod, K as setIdentifierGenerationMethod, N as setIdentifierResetMethod, L as setIdentifierUpdateMethod, O as setKeyInfoForResource, s as storeFor } from "./request-state-55umD7hP.js";
+import { EnableHydration } from './types/request.js';
+export { C as CacheHandler, S as Store, r as recordIdentifierFor, M as setIdentifierForgetMethod, K as setIdentifierGenerationMethod, N as setIdentifierResetMethod, L as setIdentifierUpdateMethod, O as setKeyInfoForResource, s as storeFor } from "./request-state-CcOnn4ej.js";
 import '@ember/debug';
 import './utils/string.js';
 import "./symbols-sql1_mdx.js";
@@ -187,6 +188,7 @@ function isDict(v) {
   return v !== null && typeof v === 'object';
 }
 class RequestManager {
+  /** @internal */
   #handlers = [];
   /** @internal */
 
@@ -239,8 +241,6 @@ class RequestManager {
    * curry the request, or pass along a modified request.
    *
    * @public
-   * @param {Handler[]} newHandlers
-   * @return {ThisType}
    */
   use(newHandlers) {
     const handlers = this.#handlers;
@@ -267,8 +267,6 @@ class RequestManager {
    * Returns a Future that fulfills with a StructuredDocument
    *
    * @public
-   * @param {RequestInfo} request
-   * @return {Future}
    */
   request(request) {
     const handlers = this.#handlers;
@@ -290,7 +288,8 @@ class RequestManager {
       stream: null,
       hasRequestedStream: false,
       id: requestId,
-      identifier: null
+      identifier: null,
+      requester: request[EnableHydration] && request.store ? request.store : this
     };
     const promise = executeNextHandler(handlers, request, 0, context);
 

package/dist/reactive.js

@@ -1,5 +1,5 @@
-import { F as ReactiveResource, G as isNonIdentityCacheableField, H as getFieldCacheKeyStrict, r as recordIdentifierFor, z as withSignalStore } from "./request-state-55umD7hP.js";
-export { I as checkout, J as commit } from "./request-state-55umD7hP.js";
+import { F as ReactiveResource, G as isNonIdentityCacheableField, H as getFieldCacheKeyStrict, r as recordIdentifierFor, z as withSignalStore } from "./request-state-CcOnn4ej.js";
+export { I as checkout, J as commit } from "./request-state-CcOnn4ej.js";
 import { isResourceSchema } from './types/schema/fields.js';
 import { D as Destroy, C as Context } from "./symbols-sql1_mdx.js";
 export { a as Checkout } from "./symbols-sql1_mdx.js";
@@ -589,6 +589,13 @@ class SchemaService {
     })(kinds[kind]) : {};
     return kinds[kind];
   }
+
+  /**
+   * Registers a {@link HashFn} for use with a {@link HashField} for
+   * either {@link ObjectSchema} identity or polymorphic type calculation.
+   *
+   * @public
+   */
   registerHashFn(hashFn) {
     this._hashFns.set(hashFn[Type], hashFn);
   }

package/dist/{request-state-55umD7hP.js → request-state-CcOnn4ej.js}

@@ -7,7 +7,7 @@ import { CACHE_OWNER, DEBUG_STALE_CACHE_OWNER, DEBUG_KEY_TYPE, DEBUG_CLIENT_ORIG
 import { dasherize } from './utils/string.js';
 import { S as SOURCE, C as Context, D as Destroy, a as Checkout, b as Commit } from "./symbols-sql1_mdx.js";
 import { a as createSignal, b as consumeSignal, n as notifySignal, c as createMemo, A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, d as willSyncFlushWatchers } from "./configure-B48bFHOl.js";
-import { g as getPromiseResult, s as setPromiseResult } from "./context-kQXhkeBj.js";
+import { g as getPromiseResult, s as setPromiseResult } from "./context-BNZebmoO.js";
 import { RecordStore } from './types/symbols.js';
 
 /**
@@ -9269,14 +9269,12 @@ class RequestSubscription {
     this._removeSubscriptions();
 
     // if we have a request, we need to subscribe to it
-    const {
-      store
-    } = this;
+    const store = this._getRequester();
     if (requestId && isStore(store)) {
       this._subscribedTo = requestId;
       this._subscription = store.notifications.subscribe(requestId, (_id, op) => {
         // ignore subscription events that occur while our own component's request
-        // is ocurring
+        // is occurring
         if (this._isUpdating) {
           return;
         }
@@ -9345,8 +9343,9 @@ class RequestSubscription {
    * @internal
    */
   _removeSubscriptions() {
-    if (this._subscription && isStore(this.store)) {
-      this.store.notifications.unsubscribe(this._subscription);
+    const store = this._getRequester();
+    if (this._subscription && isStore(store)) {
+      store.notifications.unsubscribe(this._subscription);
       this._subscribedTo = null;
       this._subscription = null;
     }
@@ -9411,6 +9410,12 @@ class RequestSubscription {
     if (this.isIdle) {
       return;
     }
+    const {
+      reqState
+    } = this;
+    if (reqState.isPending) {
+      return;
+    }
     const canAttempt = Boolean(this.isOnline && !this.isHidden && (mode || this.autorefreshTypes.size));
     if (!canAttempt) {
       if (!silent && mode && mode !== '_invalidated') {
@@ -9447,35 +9452,26 @@ class RequestSubscription {
     this._invalidated = false;
     if (shouldAttempt) {
       this._clearInterval();
-      const request = Object.assign({}, this.reqState.request);
+      this._isUpdating = true;
       const realMode = mode === '_invalidated' ? null : mode;
       const val = realMode ?? this._args.autorefreshBehavior ?? 'policy';
       switch (val) {
         case 'reload':
-          request.cacheOptions = Object.assign({}, request.cacheOptions, {
-            reload: true
-          });
+          this._latestRequest = reqState.reload();
           break;
         case 'refresh':
-          request.cacheOptions = Object.assign({}, request.cacheOptions, {
-            backgroundReload: true
-          });
+          this._latestRequest = reqState.refresh();
           break;
         case 'policy':
+          this._latestRequest = reqState.refresh(true);
           break;
         default:
-          throw new Error(`Invalid ${mode ? 'update mode' : '@autorefreshBehavior'} for <Request />: ${isNeverString(val)}`);
+          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+            {
+              throw new Error(`Invalid ${mode ? 'update mode' : '@autorefreshBehavior'} for <Request />: ${isNeverString(val)}`);
+            }
+          })() : {};
       }
-      const wasStoreRequest = request[EnableHydration] === true;
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-        if (!test) {
-          throw new Error(`Cannot supply a different store than was used to create the request`);
-        }
-      })(!request.store || request.store === this.store) : {};
-      const store = request.store || this.store;
-      const requester = !wasStoreRequest && 'requestManager' in store ? store.requestManager : store;
-      this._isUpdating = true;
-      this._latestRequest = requester.request(request);
       if (val !== 'refresh') {
         this._localRequest = this._latestRequest;
       }
@@ -9486,6 +9482,16 @@ class RequestSubscription {
     }
   }
 
+  /**
+   * @internal
+   */
+  _getRequester() {
+    if (this._args.request) {
+      return this._args.request.requester;
+    }
+    return this.store;
+  }
+
   /**
    * Retry the request, reloading it from the server.
    */
@@ -9573,7 +9579,6 @@ class RequestSubscription {
         throw new Error(`You must provide either @request or an @query arg with the <Request> component`);
       }
     })(query) : {};
-    // @ts-expect-error TODO investigate this
     return this.store.request(query);
   }
   static {
@@ -9710,6 +9715,7 @@ async function watchStream(stream, loadingState) {
  * reactive properties that can be used to build UIs that respond
  * to the progress of a request.
  *
+ * @hideconstructor
  */
 class RequestLoadingState {
   _stream = null;
@@ -9900,6 +9906,24 @@ defineNonEnumerableSignal(RequestLoadingState.prototype, '_lastPacketTime', 0);
  */
 
 const RequestStateProto = {};
+function performRefresh(requester, request, isReload) {
+  const req = Object.assign({}, request);
+  const cacheOptions = Object.assign({}, req.cacheOptions);
+  if (isReload) {
+    // force direct to network
+    cacheOptions.reload = true;
+  } else if (isReload === false) {
+    // delete reload to ensure we use backgroundReload / policy
+    delete cacheOptions.reload;
+    cacheOptions.backgroundReload = true;
+  } else {
+    // delete props to ensure we use the policy
+    delete cacheOptions.backgroundReload;
+    delete cacheOptions.reload;
+  }
+  req.cacheOptions = cacheOptions;
+  return requester.request(req);
+}
 
 // TODO introduce a new mechanism for defining multiple properties
 // that share a common signal
@@ -9931,6 +9955,25 @@ function createRequestState(future) {
   const state = getPromiseResult(future);
   const promiseState = Object.create(RequestStateProto);
   promiseState._request = future;
+  // @ts-expect-error - we still attach it for PendingState
+  promiseState.reload = () => {
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Cannot reload a request that is still pending. Await or abort the original request first.`);
+      }
+    })(!promiseState.isPending) : {};
+    return performRefresh(future.requester, promiseState.request, true);
+  };
+
+  // @ts-expect-error - we still attach it for PendingState
+  promiseState.refresh = (usePolicy = false) => {
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Cannot refresh a request that is still pending. Await or abort the original request first.`);
+      }
+    })(!promiseState.isPending) : {};
+    return performRefresh(future.requester, promiseState.request, usePolicy === true ? null : false);
+  };
   if (state) {
     if (state.isError) {
       promiseState.error = state.result;

package/dist/request.js

@@ -1 +1 @@
-export { c as createDeferred, g as getPromiseResult, s as setPromiseResult } from "./context-kQXhkeBj.js";
+export { c as createDeferred, g as getPromiseResult, s as setPromiseResult } from "./context-BNZebmoO.js";

package/dist/store/-private.js

@@ -1,2 +1,2 @@
-export { C as CacheHandler, D as DISPOSE, R as RecordArrayManager, x as Signals, S as Store, g as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, b as coerceId, c as constructResource, B as consumeInternalSignal, h as createLegacyManyArray, m as createRequestSubscription, v as defineGate, w as defineNonEnumerableSignal, u as defineSignal, e as ensureStringId, t as entangleSignal, f as fastPush, q as gate, E as getOrCreateInternalSignal, k as getPromiseState, o as getRequestState, a as isRequestKey, i as isResourceKey, l as log, j as logGroup, p as memoized, A as notifyInternalSignal, y as peekInternalSignal, r as recordIdentifierFor, d as setRecordIdentifier, s as storeFor, z as withSignalStore } from "../request-state-55umD7hP.js";
+export { C as CacheHandler, D as DISPOSE, R as RecordArrayManager, x as Signals, S as Store, g as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, b as coerceId, c as constructResource, B as consumeInternalSignal, h as createLegacyManyArray, m as createRequestSubscription, v as defineGate, w as defineNonEnumerableSignal, u as defineSignal, e as ensureStringId, t as entangleSignal, f as fastPush, q as gate, E as getOrCreateInternalSignal, k as getPromiseState, o as getRequestState, a as isRequestKey, i as isResourceKey, l as log, j as logGroup, p as memoized, A as notifyInternalSignal, y as peekInternalSignal, r as recordIdentifierFor, d as setRecordIdentifier, s as storeFor, z as withSignalStore } from "../request-state-CcOnn4ej.js";
 export { A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, c as createMemo, w as waitFor } from "../configure-B48bFHOl.js";

package/dist/types/-private.js

@@ -1,6 +1,6 @@
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 const name = "@warp-drive/core";
-const version = "5.7.0-alpha.23";
+const version = "5.7.0-alpha.24";
 
 // in testing mode, we utilize globals to ensure only one copy exists of
 // these maps, due to bugs in ember-auto-import

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@warp-drive/core",
-  "version": "5.7.0-alpha.23",
+  "version": "5.7.0-alpha.24",
   "description": "Core package for WarpDrive | All the Universal Basics",
   "keywords": [
     "ember-addon"
@@ -37,13 +37,13 @@
   },
   "dependencies": {
     "@embroider/macros": "^1.16.12",
-    "@warp-drive/build-config": "5.7.0-alpha.23"
+    "@warp-drive/build-config": "5.7.0-alpha.24"
   },
   "devDependencies": {
     "@babel/core": "^7.26.10",
     "@babel/plugin-transform-typescript": "^7.27.0",
     "@babel/preset-typescript": "^7.27.0",
-    "@warp-drive/internal-config": "5.7.0-alpha.23",
+    "@warp-drive/internal-config": "5.7.0-alpha.24",
     "decorator-transforms": "^2.3.0",
     "ember-source": "~6.3.0",
     "expect-type": "^1.2.1",