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

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

@@ -16,7 +16,6 @@ import type { Meta, PaginationLinks } from "../../types/spec/json-api-raw.js";
 * @hideconstructor
 */
 export declare class ReactiveDocument<T> {
-	#private;
 	/**
 	* The links object for this document, if any
 	*
@@ -61,11 +60,6 @@ export declare class ReactiveDocument<T> {
 	* @public
 	*/
 	readonly identifier: RequestKey | null;
-	protected readonly _store: Store;
-	protected readonly _localCache: {
-		document: ResourceDocument;
-		request: ImmutableRequestInfo;
-	} | null;
 	constructor(store: Store, cacheKey: RequestKey | null, localCache: {
 		document: ResourceDocument;
 		request: ImmutableRequestInfo;

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

@@ -26,16 +26,14 @@ export declare class ContextOwner {
 	setResponse(response: ResponseInfo | Response | null): void;
 }
 export declare class Context {
-	private ___owner;
 	request: ImmutableRequestInfo;
 	id: number;
-	private _isCacheHandler;
-	private _finalized;
 	constructor(owner: ContextOwner, isCacheHandler: boolean);
 	setStream(stream: ReadableStream | Promise<ReadableStream | null>): void;
 	setResponse(response: ResponseInfo | Response | null): void;
 	setIdentifier(identifier: RequestKey): void;
 	get hasRequestedStream(): boolean;
+	/** @private */
 	_finalize(): void;
 }
 export type HandlerRequestContext = Context;

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/managers/cache-manager.d.ts

@@ -29,7 +29,6 @@ import type { StoreRequestContext } from "../cache-handler/handler.js";
 */
 export declare class CacheManager implements Cache {
 	version: "2";
-	private ___cache;
 	constructor(cache: Cache);
 	// Cache Management
 	// ================

package/declarations/store/-private/managers/notification-manager.d.ts

@@ -72,7 +72,6 @@ export default class NotificationManager {
 	notify(cacheKey: ResourceKey, value: "errors" | "meta" | "identity" | "state", key?: null): boolean;
 	notify(cacheKey: ResourceKey, value: CacheOperation, key?: null): boolean;
 	notify(cacheKey: RequestKey, value: DocumentCacheOperation, key?: null): boolean;
-	private _scheduleNotify;
 }
 /**
 * This type exists for internal use only for

package/declarations/store/-private/managers/record-array-manager.d.ts

@@ -75,7 +75,6 @@ export declare class RecordArrayManager {
 	getCollection(config: LegacyQueryInit): LegacyQueryArray;
 	getCollection(config: AnonymousRequestCollectionInit): ReactiveResourceArray;
 	getCollection(config: RequestCollectionInit): ReactiveResourceArray;
-	private dirtyArray;
 	/**
 	* @private
 	*/

package/declarations/store/-private/network/request-cache.d.ts

@@ -43,9 +43,6 @@ export type RequestSubscription = (requestState: RequestCacheRequestState) => vo
 */
 export declare class RequestStateService {
 	constructor(store: Store);
-	private _flushRequest;
-	private _dequeue;
-	private _addDone;
 	/**
 	* Subscribe to requests for a given resource identity.
 	*

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-state.d.ts

@@ -10,21 +10,6 @@ import type { PendingPromise, RejectedPromise, ResolvedPromise } from "./promise
 * @hideconstructor
 */
 export declare class RequestLoadingState {
-	private _sizeHint;
-	private _bytesLoaded;
-	private _startTime;
-	private _endTime;
-	private _lastPacketTime;
-	private _isPending;
-	private _isStarted;
-	private _isComplete;
-	private _isCancelled;
-	private _isErrored;
-	private _error;
-	private _stream;
-	private _future;
-	private _triggered;
-	private _trigger;
 	promise: Promise<void> | null;
 	get isPending(): boolean;
 	get sizeHint(): number;

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
 */
@@ -156,16 +153,6 @@ export declare class RequestSubscription<
 	constructor(store: Store | RequestManager, args: SubscriptionArgs<RT, E>);
 	get isIdle(): boolean;
 	get autorefreshTypes(): Set<AutorefreshBehaviorType>;
-	// we only run this function on component creation
-	// and when an update is triggered, so it does not
-	// react to changes in the autorefreshThreshold
-	// or autorefresh args.
-	//
-	// if we need to react to those changes, we can
-	// use a modifier or internal component or some
-	// such to trigger a re-run of this function.
-	private _scheduleInterval;
-	private _clearInterval;
 	/**
 	* Retry the request, reloading it from the server.
 	*/
@@ -177,7 +164,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/{context-Bh-MA_tH.js → context-C_7OLieY.js}

@@ -639,6 +639,12 @@ class ContextOwner {
   }
 }
 class Context {
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
   constructor(owner, isCacheHandler) {
     this.id = owner.requestId;
     this.___owner = owner;
@@ -663,6 +669,8 @@ class Context {
   get hasRequestedStream() {
     return this.___owner.hasRequestedStream;
   }
+
+  /** @private */
   _finalize() {
     this._finalized = true;
   }

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 { 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-C_7OLieY.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-CxDzTjFX.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-CxDzTjFX.js";
+export { O as checkout, P as commit } from "./request-state-CxDzTjFX.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-CxDzTjFX.js}

@@ -6,8 +6,8 @@ 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 { g as getPromiseResult, s as setPromiseResult } from "./context-Bh-MA_tH.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-C_7OLieY.js";
 import { RecordStore } from './types/symbols.js';
 const INITIALIZER_PROTO = {
   isInitializer: true
@@ -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();
   };
@@ -352,6 +535,10 @@ class ReactiveDocument {
    * @public
    */
 
+  /** @internal */
+
+  /** @internal */
+
   constructor(store, cacheKey, localCache) {
     this._store = store;
     this._localCache = localCache;
@@ -375,6 +562,8 @@ class ReactiveDocument {
       });
     }
   }
+
+  /** @internal */
   async #request(link, options = withBrand({
     url: '',
     method: 'GET'
@@ -1191,7 +1380,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 +1473,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 +1488,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 +2942,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 +2979,7 @@ function isLightMode() {
 function _log(scope, prefix, subScop1, subScop2, subScop3, subScop4) {
   const isLight = isLightMode();
   switch (scope) {
+    case 'request':
     case 'reactive-ui':
     case 'notify':
       {
@@ -4267,6 +4468,9 @@ function unloadRecord(instances, identifier) {
  */
 class CacheManager {
   version = '2';
+
+  /** @internal */
+
   constructor(cache) {
     this.___cache = cache;
   }
@@ -4945,6 +5149,8 @@ class NotificationManager {
   _onNextFlush(cb) {
     this._onFlushCB = cb;
   }
+
+  /** @internal */
   _scheduleNotify() {
     const asyncFlush = this.store._enableAsyncFlush;
     if (this._hasFlush) {
@@ -5862,6 +6068,8 @@ class RecordArrayManager {
     this._managed.add(array);
     return array;
   }
+
+  /** @internal */
   dirtyArray(array, delta, shouldSyncFromCache) {
     if (array === FAKE_ARR) {
       return;
@@ -6226,6 +6434,8 @@ class RequestStateService {
     });
     this._toFlush = [];
   }
+
+  /** @internal */
   _flushRequest(req) {
     req[Touching].forEach(identifier => {
       const subscriptions = this._subscriptions.get(identifier);
@@ -6234,10 +6444,14 @@ class RequestStateService {
       }
     });
   }
+
+  /** @internal */
   _dequeue(identifier, request) {
     const pending = this._pending.get(identifier);
     this._pending.set(identifier, pending.filter(req => req !== request));
   }
+
+  /** @internal */
   _addDone(request) {
     request[Touching].forEach(identifier => {
       // TODO add support for multiple
@@ -8397,8 +8611,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 +8637,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 +8661,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 +9475,8 @@ function isNeverString(val) {
  * Utilities to assist in recovering from the error.
  */
 
+/** @deprecated use {@link RecoveryFeatures} */
+
 /**
  * Utilities for keeping the request fresh
  */
@@ -9398,6 +9642,7 @@ class RequestSubscription {
   // if we need to react to those changes, we can
   // use a modifier or internal component or some
   // such to trigger a re-run of this function.
+  /** @internal */
   static {
     decorateMethodV2(this.prototype, "autorefreshTypes", [memoized]);
   }
@@ -9437,6 +9682,8 @@ class RequestSubscription {
       this._maybeUpdate();
     }, autorefreshThreshold);
   }
+
+  /** @internal */
   _clearInterval() {
     if (this._nextInterval) {
       clearTimeout(this._nextInterval);
@@ -9910,9 +10157,35 @@ async function watchStream(stream, loadingState) {
  * @hideconstructor
  */
 class RequestLoadingState {
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
   _stream = null;
+  /** @internal */
   _future;
+  /** @internal */
   _triggered = false;
+  /** @internal */
   _trigger() {
     if (this._triggered) {
       return;
@@ -10276,4 +10549,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/request.js

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

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-CxDzTjFX.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.32";
 
 // 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.32",
   "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.32"
   },
   "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.32",
     "decorator-transforms": "^2.3.0",
     "ember-source": "~6.6.0",
     "expect-type": "^1.2.1",