@warp-drive/core 5.7.0-alpha.30 → 5.7.0-alpha.31

package/declarations/store/-private/debug/utils.d.ts

@@ -1,6 +1,7 @@
 export declare function logGroup(scope: "cache", prefix: string, type: string, lid: string, bucket: string, key: string): void;
 export declare function logGroup(scope: "reactive-ui", prefix: string, type: string, lid: string, bucket: string, key: ""): void;
 export declare function logGroup(scope: "notify", prefix: string, type: string, lid: string, bucket: string, key: string): void;
+export declare function log(scope: "request", prefix: string, type: string, lid: string, bucket: string, key: string): void;
 export declare function log(scope: "cache", prefix: string, type: string, lid: string, bucket: string, key: string): void;
 export declare function log(scope: "reactive-ui", prefix: string, type: string, lid: string, bucket: string, key: ""): void;
 export declare function log(scope: "notify", prefix: string, type: string, lid: string, bucket: string, key: string): void;

package/declarations/store/-private/new-core-tmp/reactivity/internal.d.ts

@@ -147,6 +147,8 @@ export declare function initializeSignalStore<T extends object>(obj: T): asserts
 };
 export declare function createInternalSignal(signals: SignalStore, obj: object, key: string | symbol, initialValue: unknown): WarpDriveSignal;
 export declare function getOrCreateInternalSignal(signals: SignalStore, obj: object, key: string | symbol, initialValue: unknown): WarpDriveSignal;
+export declare function createInternalMemo<T>(signals: SignalStore, object: object, key: string | symbol, fn: () => T): () => T;
+export declare function consumeInternalMemo<T>(fn: () => T): T;
 export declare function peekInternalSignal(signals: SignalStore | undefined, key: string | symbol): WarpDriveSignal | undefined;
 export declare function consumeInternalSignal(signal: WarpDriveSignal): void;
 export declare function notifyInternalSignal(signal: WarpDriveSignal | undefined): void;

package/declarations/store/-private/new-core-tmp/reactivity/signal.d.ts

@@ -7,6 +7,7 @@ import type { SignalStore, WarpDriveSignal } from "./internal.js";
 * @private
 */
 export declare function entangleSignal<T extends object>(signals: SignalStore, obj: T, key: string | symbol, initialValue: unknown): WarpDriveSignal;
+export declare function entangleInitiallyStaleSignal<T extends object>(signals: SignalStore, obj: T, key: string | symbol, initialValue: unknown): WarpDriveSignal;
 export declare function createSignalDescriptor(key: string | symbol, intialValue: unknown): PropertyDescriptor;
 /**
 * define an enumerable signal property.

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

@@ -3,11 +3,6 @@ import type { Future } from "../../../request.js";
 import type { StructuredErrorDocument } from "../../../types/request.js";
 import type { RequestState } from "../../-private.js";
 export declare const DISPOSE: "(symbol) dispose";
-export interface ErrorFeatures {
-	isHidden: boolean;
-	isOnline: boolean;
-	retry: () => Promise<void>;
-}
 export type AutorefreshBehaviorType = "online" | "interval" | "invalid";
 export type AutorefreshBehaviorCombos = boolean | AutorefreshBehaviorType | `${AutorefreshBehaviorType},${AutorefreshBehaviorType}` | `${AutorefreshBehaviorType},${AutorefreshBehaviorType},${AutorefreshBehaviorType}`;
 /**
@@ -18,6 +13,8 @@ export interface RecoveryFeatures {
 	isHidden: boolean;
 	retry: () => Promise<void>;
 }
+/** @deprecated use {@link RecoveryFeatures} */
+export type ErrorFeatures = RecoveryFeatures;
 /**
 * Utilities for keeping the request fresh
 */
@@ -177,7 +174,7 @@ export declare class RequestSubscription<
 	/**
 	* features to yield to the error slot of a component
 	*/
-	get errorFeatures(): ErrorFeatures;
+	get errorFeatures(): RecoveryFeatures;
 	/**
 	* features to yield to the content slot of a component
 	*/

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

@@ -30,6 +30,6 @@ export { log, logGroup } from "./-private/debug/utils.js";
 export { getPromiseState, type PromiseState } from "./-private/new-core-tmp/promise-state.js";
 export { DISPOSE, createRequestSubscription, type RequestArgs, type SubscriptionArgs, type RequestComponentArgs, type RequestSubscription, type ContentFeatures, type RecoveryFeatures, type AutorefreshBehaviorCombos, type AutorefreshBehaviorType } from "./-private/new-core-tmp/request-subscription.js";
 export { getRequestState, type RequestLoadingState, type RequestCacheRequestState as RequestState } from "./-private/new-core-tmp/request-state.js";
-export { createMemo, type SignalHooks, waitFor } from "./-private/new-core-tmp/reactivity/configure.js";
-export { signal, memoized, gate, entangleSignal, defineSignal, defineGate, defineNonEnumerableSignal } from "./-private/new-core-tmp/reactivity/signal.js";
-export { ARRAY_SIGNAL, OBJECT_SIGNAL, Signals, type WarpDriveSignal, peekInternalSignal, withSignalStore, notifyInternalSignal, consumeInternalSignal, getOrCreateInternalSignal } from "./-private/new-core-tmp/reactivity/internal.js";
+export { type SignalHooks, waitFor } from "./-private/new-core-tmp/reactivity/configure.js";
+export { signal, memoized, gate, entangleSignal, entangleInitiallyStaleSignal, defineSignal, defineGate, defineNonEnumerableSignal } from "./-private/new-core-tmp/reactivity/signal.js";
+export { ARRAY_SIGNAL, OBJECT_SIGNAL, Signals, type WarpDriveSignal, peekInternalSignal, createInternalMemo, withSignalStore, notifyInternalSignal, consumeInternalSignal, getOrCreateInternalSignal } from "./-private/new-core-tmp/reactivity/internal.js";

package/dist/{configure-CiFDHArV.js → configure-C3x8YXzL.js}

@@ -178,4 +178,4 @@ function waitFor(promise) {
   }
   return promise;
 }
-export { ARRAY_SIGNAL as A, OBJECT_SIGNAL as O, createSignal as a, consumeSignal as b, createMemo as c, willSyncFlushWatchers as d, notifySignal as n, setupSignals as s, waitFor as w };
+export { ARRAY_SIGNAL as A, OBJECT_SIGNAL as O, consumeSignal as a, createMemo as b, createSignal as c, willSyncFlushWatchers as d, notifySignal as n, setupSignals as s, waitFor as w };

package/dist/configure.js

@@ -1 +1 @@
-export { s as setupSignals } from "./configure-CiFDHArV.js";
+export { s as setupSignals } from "./configure-C3x8YXzL.js";

package/dist/index.js

@@ -1,10 +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-Bh-MA_tH.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
-import { w as waitFor } from "./configure-CiFDHArV.js";
+import { w as waitFor } from "./configure-C3x8YXzL.js";
 import { peekUniversalTransient, setUniversalTransient } from './types/-private.js';
 import { EnableHydration } from './types/request.js';
-export { C as CacheHandler, S as Store, r as recordIdentifierFor, Q as setIdentifierForgetMethod, O as setIdentifierGenerationMethod, T as setIdentifierResetMethod, P as setIdentifierUpdateMethod, U as setKeyInfoForResource, s as storeFor } from "./request-state-B908BvPK.js";
+export { C as CacheHandler, S as Store, r as recordIdentifierFor, U as setIdentifierForgetMethod, Q as setIdentifierGenerationMethod, V as setIdentifierResetMethod, T as setIdentifierUpdateMethod, W as setKeyInfoForResource, s as storeFor } from "./request-state-DGyt5EV8.js";
 import '@ember/debug';
 import './utils/string.js';
 import "./symbols-sql1_mdx.js";

package/dist/reactive.js

@@ -1,5 +1,5 @@
-import { J as ReactiveResource, K as isNonIdentityCacheableField, L as getFieldCacheKeyStrict, r as recordIdentifierFor, F as withSignalStore } from "./request-state-B908BvPK.js";
-export { M as checkout, N as commit } from "./request-state-B908BvPK.js";
+import { L as ReactiveResource, M as isNonIdentityCacheableField, N as getFieldCacheKeyStrict, r as recordIdentifierFor, H as withSignalStore, G as createInternalMemo } from "./request-state-DGyt5EV8.js";
+export { O as checkout, P as commit } from "./request-state-DGyt5EV8.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";
@@ -8,7 +8,7 @@ import { warn, deprecate } from '@ember/debug';
 import './index.js';
 import './types/request.js';
 import './utils/string.js';
-import { c as createMemo } from "./configure-CiFDHArV.js";
+import "./configure-C3x8YXzL.js";
 import { getOrSetGlobal } from './types/-private.js';
 import { Type } from './types/symbols.js';
 function instantiateRecord(store, identifier, createArgs) {
@@ -311,10 +311,9 @@ function makeCachedDerivation(derivation) {
     const signals = withSignalStore(record);
     let signal = signals.get(prop);
     if (!signal) {
-      signal = createMemo(record, prop, () => {
+      signal = createInternalMemo(signals, record, prop, () => {
         return derivation(record, options, prop);
       }); // a total lie, for convenience of reusing the storage
-      signals.set(prop, signal);
     }
     return signal();
   };

package/dist/{request-state-B908BvPK.js → request-state-DGyt5EV8.js}

@@ -6,7 +6,7 @@ import { getOrSetGlobal, peekTransient, setTransient } from './types/-private.js
 import { CACHE_OWNER, DEBUG_STALE_CACHE_OWNER, DEBUG_KEY_TYPE, DEBUG_CLIENT_ORIGINATED } from './types/identifier.js';
 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-CiFDHArV.js";
+import { c as createSignal, a as consumeSignal, n as notifySignal, b as createMemo, A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, d as willSyncFlushWatchers } from "./configure-C3x8YXzL.js";
 import { g as getPromiseResult, s as setPromiseResult } from "./context-Bh-MA_tH.js";
 import { RecordStore } from './types/symbols.js';
 const INITIALIZER_PROTO = {
@@ -121,10 +121,25 @@ function getOrCreateInternalSignal(signals, obj, key, initialValue) {
   }
   return signal;
 }
+function createInternalMemo(signals, object, key, fn) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected no signal/memo to exist for key "${String(key)}"`);
+    }
+  })(!peekInternalSignal(signals, key)) : {};
+  if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    return withFrame(signals, object, key, fn);
+  } else {
+    const memo = createMemo(object, key, fn);
+    signals.set(key, memo);
+    return memo;
+  }
+}
 function peekInternalSignal(signals, key) {
   return signals?.get(key);
 }
 function consumeInternalSignal(signal) {
+  TrackingFrame?.signals.add(signal);
   consumeSignal(signal.signal);
 }
 function notifyInternalSignal(signal) {
@@ -133,6 +148,164 @@ function notifyInternalSignal(signal) {
     notifySignal(signal.signal);
   }
 }
+let TrackingFrame = null;
+
+/**
+ * This is currently just for signals debugging, but it could be used in production
+ * if we wanted to eliminate the need for frameworks to implement createMemo / to
+ * allow us to add our own Watcher.
+ *
+ * @internal
+ */
+function withFrame(signals, object, key, fn) {
+  const frameSignals = new Set();
+  const frameFn = () => {
+    if (frameSignals.size) {
+      frameSignals.clear();
+    }
+    TrackingFrame = {
+      object,
+      key,
+      signals: frameSignals,
+      parent: TrackingFrame
+    };
+    try {
+      return fn();
+    } finally {
+      TrackingFrame = TrackingFrame.parent;
+    }
+  };
+  const memo = createMemo(object, key, frameFn);
+  // @ts-expect-error
+  memo.signals = frameSignals;
+  signals.set(key, memo);
+  return memo;
+}
+function isMemo(obj) {
+  // @ts-expect-error
+  return typeof obj === 'function' && obj.signals instanceof Set;
+}
+if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+  // @ts-expect-error adding to global API
+  globalThis.debugWarpDriveSignals = (obj, key) => {
+    const signals = obj[Signals];
+    if (!signals) {
+      log$1('The object has no associated signals');
+      return false;
+    }
+    if (key) {
+      const signal = signals.get(key);
+      if (!signal) {
+        log$1(`No signal found for key "${String(key)}"`);
+        return false;
+      }
+      log$1(signal);
+      if (isMemo(signal)) {
+        colorizeLines(printMemo(signal, key));
+        return true;
+      } else {
+        colorizeLines(printSignal(signal, key));
+        return true;
+      }
+    }
+    const lines = [];
+    for (const [k, signal] of signals) {
+      if (isMemo(signal)) continue;
+      printSignal(signal, k, lines);
+    }
+    for (const [k, signal] of signals) {
+      if (isMemo(signal)) {
+        printMemo(signal, k, lines);
+      }
+    }
+    log$1(signals);
+    colorizeLines(lines);
+    return true;
+  };
+}
+const LightColors = {
+  red: 'color: red;',
+  green: 'color: green;',
+  reset: 'color: inherit;'
+};
+const DarkColors = {
+  red: 'color: red;',
+  green: 'color: lightgreen;',
+  reset: 'color: inherit;'
+};
+function isLightMode$1() {
+  if (window?.matchMedia?.('(prefers-color-scheme: light)').matches) {
+    return true;
+  }
+  return false;
+}
+const RED = {};
+const GREEN = {};
+const RESET = {};
+const EOL = {};
+function colorizeLines(lines) {
+  const Colors = isLightMode$1() ? LightColors : DarkColors;
+  const colors = [];
+  let line = '';
+  for (const str of lines) {
+    if (str === RED) {
+      colors.push(Colors.red);
+      line += '%c';
+    } else if (str === GREEN) {
+      colors.push(Colors.green);
+      line += '%c';
+    } else if (str === RESET) {
+      colors.push(Colors.reset);
+      line += '%c';
+    } else if (str === EOL) {
+      line += '\n';
+    } else {
+      line += str;
+    }
+  }
+  log$1(line, ...colors);
+}
+function log$1(...args) {
+  // eslint-disable-next-line no-console
+  console.log(...args);
+}
+function isDirty(signal) {
+  return signal.isStale;
+}
+function isDirtyMemo(memo) {
+  // iterate simple signals first to get fastest answer
+  for (const signal of memo.signals) {
+    if (isMemo(signal)) continue;
+    if (isDirty(signal)) {
+      return true;
+    }
+  }
+  for (const signal of memo.signals) {
+    if (isMemo(signal)) {
+      return isDirtyMemo(signal);
+    }
+  }
+  return false;
+}
+function printSignal(signal, key, lines = [], depth = 0) {
+  const _dirty = isDirty(signal);
+  lines.push(`${''.padStart(depth * 2, ' ')}${_dirty ? '❌' : '✅'} `, _dirty ? RED : GREEN, `${String(key)}`, RESET, EOL);
+  return lines;
+}
+function printMemo(memo, key, lines = [], depth = 0) {
+  const _dirty = isDirtyMemo(memo);
+  lines.push(`${''.padStart(depth * 2, ' ')}${_dirty ? '❌' : '✅'} `, _dirty ? RED : GREEN, `<memo> ${String(key)}`, RESET, `: (consumes ${memo.signals.size} signals)`, EOL);
+  for (const signal of memo.signals) {
+    if (isMemo(signal)) continue;
+    printSignal(signal, signal.key, lines, depth + 1);
+  }
+  for (const signal of memo.signals) {
+    if (isMemo(signal)) {
+      printMemo(signal, signal.key, lines, depth + 1);
+    }
+  }
+  return lines;
+}
 function entangleSignal(signals, obj, key, initialValue) {
   let internalSignal = peekInternalSignal(signals, key);
   if (!internalSignal) {
@@ -141,13 +314,24 @@ function entangleSignal(signals, obj, key, initialValue) {
   consumeInternalSignal(internalSignal);
   return internalSignal;
 }
+function entangleInitiallyStaleSignal(signals, obj, key, initialValue) {
+  let internalSignal = peekInternalSignal(signals, key);
+  if (!internalSignal) {
+    internalSignal = createInternalSignal(signals, obj, key, initialValue);
+    internalSignal.isStale = true; // mark it as stale
+  }
+  consumeInternalSignal(internalSignal);
+  return internalSignal;
+}
 function createSignalDescriptor(key, intialValue) {
   return {
     enumerable: true,
     configurable: false,
     get() {
       const signals = withSignalStore(this);
-      return entangleSignal(signals, this, key, intialValue).value;
+      const internalSignal = entangleSignal(signals, this, key, intialValue);
+      internalSignal.isStale = false; // reset stale state
+      return internalSignal.value;
     },
     set(value) {
       const signals = withSignalStore(this);
@@ -229,8 +413,7 @@ function memoized(target, key, descriptor) {
     const signals = withSignalStore(this);
     let memoSignal = signals.get(key);
     if (!memoSignal) {
-      memoSignal = createMemo(this, key, getter.bind(this));
-      signals.set(key, memoSignal);
+      memoSignal = createInternalMemo(signals, this, key, getter.bind(this));
     }
     return memoSignal();
   };
@@ -1191,7 +1374,7 @@ function setArrayField(context) {
   return true;
 }
 function getAttributeField(context) {
-  entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  entangleInitiallyStaleSignal(context.signals, context.record, context.path.at(-1), null);
   const {
     cache
   } = context.store;
@@ -1284,7 +1467,12 @@ function setDerivedField(context) {
   return false;
 }
 function getGenericField(context) {
-  entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  const signal = entangleInitiallyStaleSignal(context.signals, context.record, context.path.at(-1), null);
+  // FIXME we should be able to cache the computation here, but some tests fail.
+  // if (!signal.isStale) {
+  //   return signal.value;
+  // }
+  signal.isStale = false;
   const {
     cache,
     schema
@@ -1294,9 +1482,12 @@ function getGenericField(context) {
     field
   } = context;
   if (!field.type) {
+    // signal.value = rawValue;
     return rawValue;
   }
   const transform = schema.transformation(field);
+  // signal.value = transform.hydrate(rawValue, field.options ?? null, context.record);
+  // return signal.value;
   return transform.hydrate(rawValue, field.options ?? null, context.record);
 }
 function setGenericField(context) {
@@ -2745,6 +2936,9 @@ function badge(isLight, color, bgColor, border) {
   return [`color: ${correctColor(isLight, color)}; background-color: ${correctColor(isLight, bgColor)}; padding: ${border}px ${2 * border}px; border-radius: ${border}px;`, `color: ${TEXT_COLORS.TEXT}; background-color: ${BG_COLORS.TEXT};`];
 }
 function colorForBucket(isLight, scope, bucket) {
+  if (scope === 'request') {
+    return bucket === 'blocking' ? badge(isLight, 'red', 'transparent', 0) : bucket === 'cached' ? badge(isLight, 'lightgreen', 'transparent', 0) : bucket === 'non-blocking' ? badge(isLight, 'orange', 'transparent', 0) : badge(isLight, 'gray', 'transparent', 0);
+  }
   if (scope === 'notify') {
     return bucket === 'added' ? badge(isLight, 'lightgreen', 'transparent', 0) : bucket === 'removed' ? badge(isLight, 'red', 'transparent', 0) : badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]);
   }
@@ -2779,6 +2973,7 @@ function isLightMode() {
 function _log(scope, prefix, subScop1, subScop2, subScop3, subScop4) {
   const isLight = isLightMode();
   switch (scope) {
+    case 'request':
     case 'reactive-ui':
     case 'notify':
       {
@@ -8397,8 +8592,18 @@ const CacheHandler = {
         activeRequest.priority = {
           blocking: true
         };
+        if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_REQUESTS)) {
+          if (getGlobalConfig().WarpDrive.debug.LOG_REQUESTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REQUESTS) {
+            log('request', '', 'DEDUPED', identifier.lid, 'blocking', '');
+          }
+        }
         return activeRequest.promise;
       }
+      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_REQUESTS)) {
+        if (getGlobalConfig().WarpDrive.debug.LOG_REQUESTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REQUESTS) {
+          log('request', '', 'ISSUED', identifier?.lid ?? context.request.url ?? context.request.op ?? '<unknown request>', 'blocking', '');
+        }
+      }
       let promise = fetchContentAndHydrate(next, context, identifier, {
         blocking: true
       });
@@ -8413,7 +8618,9 @@ const CacheHandler = {
           },
           promise
         });
-        store.notifications.notify(identifier, 'state', null);
+        queueMicrotask(() => {
+          store.notifications.notify(identifier, 'state', null);
+        });
       }
       store.requestManager._pending.set(context.id, promise);
       return promise;
@@ -8435,10 +8642,26 @@ const CacheHandler = {
           },
           promise
         });
-        store.notifications.notify(identifier, 'state', null);
+        queueMicrotask(() => {
+          store.notifications.notify(identifier, 'state', null);
+        });
+      }
+      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_REQUESTS)) {
+        if (getGlobalConfig().WarpDrive.debug.LOG_REQUESTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REQUESTS) {
+          if (activeRequest && identifier) {
+            log('request', '', 'DEDUPED', identifier.lid, activeRequest.priority.blocking ? 'blocking' : 'non-blocking', '');
+          } else {
+            log('request', '', 'ISSUED', identifier?.lid ?? context.request.url ?? context.request.op ?? '<unknown request>', 'non-blocking', '');
+          }
+        }
       }
       store.requestManager._pending.set(context.id, promise);
     }
+    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_REQUESTS)) {
+      if (getGlobalConfig().WarpDrive.debug.LOG_REQUESTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REQUESTS) {
+        log('request', '', 'CACHE-HIT', identifier?.lid ?? context.request.url ?? context.request.op ?? '<unknown request>', 'cached', '');
+      }
+    }
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
         throw new Error(`Expected a peeked request to be present`);
@@ -9233,6 +9456,8 @@ function isNeverString(val) {
  * Utilities to assist in recovering from the error.
  */
 
+/** @deprecated use {@link RecoveryFeatures} */
+
 /**
  * Utilities for keeping the request fresh
  */
@@ -10276,4 +10501,4 @@ function getRequestState(future) {
   }
   return state;
 }
-export { defineNonEnumerableSignal as A, Signals as B, CacheHandler as C, DISPOSE as D, peekInternalSignal as E, withSignalStore as F, notifyInternalSignal as G, consumeInternalSignal as H, getOrCreateInternalSignal as I, ReactiveResource as J, isNonIdentityCacheableField as K, getFieldCacheKeyStrict as L, checkout as M, commit as N, setIdentifierGenerationMethod as O, setIdentifierUpdateMethod as P, setIdentifierForgetMethod as Q, RecordArrayManager as R, Store as S, setIdentifierResetMethod as T, setKeyInfoForResource as U, _clearCaches as _, isRequestKey as a, coerceId as b, constructResource as c, assertPrivateStore as d, ensureStringId as e, fastPush as f, isPrivateStore as g, assertPrivateCapabilities as h, isResourceKey as i, setRecordIdentifier as j, StoreMap as k, createLegacyManyArray as l, log as m, normalizeModelName as n, logGroup as o, getPromiseState as p, createRequestSubscription as q, recordIdentifierFor as r, storeFor as s, getRequestState as t, signal as u, memoized as v, gate as w, entangleSignal as x, defineSignal as y, defineGate as z };
+export { defineGate as A, defineNonEnumerableSignal as B, CacheHandler as C, DISPOSE as D, Signals as E, peekInternalSignal as F, createInternalMemo as G, withSignalStore as H, notifyInternalSignal as I, consumeInternalSignal as J, getOrCreateInternalSignal as K, ReactiveResource as L, isNonIdentityCacheableField as M, getFieldCacheKeyStrict as N, checkout as O, commit as P, setIdentifierGenerationMethod as Q, RecordArrayManager as R, Store as S, setIdentifierUpdateMethod as T, setIdentifierForgetMethod as U, setIdentifierResetMethod as V, setKeyInfoForResource as W, _clearCaches as _, isRequestKey as a, coerceId as b, constructResource as c, assertPrivateStore as d, ensureStringId as e, fastPush as f, isPrivateStore as g, assertPrivateCapabilities as h, isResourceKey as i, setRecordIdentifier as j, StoreMap as k, createLegacyManyArray as l, log as m, normalizeModelName as n, logGroup as o, getPromiseState as p, createRequestSubscription as q, recordIdentifierFor as r, storeFor as s, getRequestState as t, signal as u, memoized as v, gate as w, entangleSignal as x, entangleInitiallyStaleSignal as y, defineSignal as z };

package/dist/store/-private.js

@@ -1,2 +1,2 @@
-export { C as CacheHandler, D as DISPOSE, R as RecordArrayManager, B as Signals, S as Store, k as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, h as assertPrivateCapabilities, d as assertPrivateStore, b as coerceId, c as constructResource, H as consumeInternalSignal, l as createLegacyManyArray, q as createRequestSubscription, z as defineGate, A as defineNonEnumerableSignal, y as defineSignal, e as ensureStringId, x as entangleSignal, f as fastPush, w as gate, I as getOrCreateInternalSignal, p as getPromiseState, t as getRequestState, g as isPrivateStore, a as isRequestKey, i as isResourceKey, m as log, o as logGroup, v as memoized, G as notifyInternalSignal, E as peekInternalSignal, r as recordIdentifierFor, j as setRecordIdentifier, u as signal, s as storeFor, F as withSignalStore } from "../request-state-B908BvPK.js";
-export { A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, c as createMemo, w as waitFor } from "../configure-CiFDHArV.js";
+export { C as CacheHandler, D as DISPOSE, R as RecordArrayManager, E as Signals, S as Store, k as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, h as assertPrivateCapabilities, d as assertPrivateStore, b as coerceId, c as constructResource, J as consumeInternalSignal, G as createInternalMemo, l as createLegacyManyArray, q as createRequestSubscription, A as defineGate, B as defineNonEnumerableSignal, z as defineSignal, e as ensureStringId, y as entangleInitiallyStaleSignal, x as entangleSignal, f as fastPush, w as gate, K as getOrCreateInternalSignal, p as getPromiseState, t as getRequestState, g as isPrivateStore, a as isRequestKey, i as isResourceKey, m as log, o as logGroup, v as memoized, I as notifyInternalSignal, F as peekInternalSignal, r as recordIdentifierFor, j as setRecordIdentifier, u as signal, s as storeFor, H as withSignalStore } from "../request-state-DGyt5EV8.js";
+export { A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, w as waitFor } from "../configure-C3x8YXzL.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.30";
+const version = "5.7.0-alpha.31";
 
 // 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.30",
+  "version": "5.7.0-alpha.31",
   "description": "Core package for WarpDrive | All the Universal Basics",
   "keywords": [
     "ember-addon"
@@ -37,13 +37,13 @@
   },
   "dependencies": {
     "@embroider/macros": "^1.18.1",
-    "@warp-drive/build-config": "5.7.0-alpha.30"
+    "@warp-drive/build-config": "5.7.0-alpha.31"
   },
   "devDependencies": {
     "@babel/core": "^7.28.0",
     "@babel/plugin-transform-typescript": "^7.28.0",
     "@babel/preset-typescript": "^7.27.1",
-    "@warp-drive/internal-config": "5.7.0-alpha.30",
+    "@warp-drive/internal-config": "5.7.0-alpha.31",
     "decorator-transforms": "^2.3.0",
     "ember-source": "~6.6.0",
     "expect-type": "^1.2.1",