static-injector 6.4.0 → 7.0.0

package/index.js

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/import/index.ts
 var import_exports = {};
 __export(import_exports, {
+  APP_ID: () => APP_ID,
   ChangeDetectionScheduler: () => ChangeDetectionScheduler,
   ChangeDetectionSchedulerImpl: () => ChangeDetectionSchedulerImpl,
   DecoratorFlags: () => DecoratorFlags,
@@ -27,6 +28,7 @@ __export(import_exports, {
   EffectScheduler: () => EffectScheduler,
   EnvironmentInjector: () => EnvironmentInjector,
   ErrorHandler: () => ErrorHandler,
+  EventEmitter: () => EventEmitter,
   INJECTOR_SCOPE: () => INJECTOR_SCOPE,
   INTERNAL_APPLICATION_ERROR_HANDLER: () => INTERNAL_APPLICATION_ERROR_HANDLER,
   Inject: () => Inject,
@@ -40,20 +42,20 @@ __export(import_exports, {
   NotificationSource: () => NotificationSource,
   NullInjector: () => NullInjector,
   Optional: () => Optional,
-  PROVIDED_ZONELESS: () => PROVIDED_ZONELESS,
   PendingTasks: () => PendingTasks,
-  PendingTasksInternal: () => PendingTasksInternal,
   R3Injector: () => R3Injector,
+  ResourceDependencyError: () => ResourceDependencyError,
+  ResourceParamsStatus: () => ResourceParamsStatus,
   RetrievingInjector: () => RetrievingInjector,
   RootStaticInjectOptions: () => RootStaticInjectOptions,
-  SCHEDULE_IN_ROOT_ZONE: () => SCHEDULE_IN_ROOT_ZONE,
   SOURCE: () => SOURCE,
   Self: () => Self,
   SkipSelf: () => SkipSelf,
   StaticInjectOptions: () => StaticInjectOptions,
   THROW_IF_NOT_FOUND: () => THROW_IF_NOT_FOUND,
-  ZONELESS_ENABLED: () => ZONELESS_ENABLED,
-  ZONELESS_SCHEDULER_DISABLED: () => ZONELESS_SCHEDULER_DISABLED,
+  TransferState: () => TransferState,
+  Type: () => Type,
+  assertInInjectionContext: () => assertInInjectionContext,
   assertNotDestroyed: () => assertNotDestroyed,
   assertNotInReactiveContext: () => assertNotInReactiveContext,
   attachInjectFlag: () => attachInjectFlag,
@@ -61,8 +63,9 @@ __export(import_exports, {
   convertToBitFlags: () => convertToBitFlags,
   createInjector: () => createInjector2,
   createRootInjector: () => createRootInjector,
+  debounced: () => debounced,
   effect: () => effect,
-  formatError: () => formatError,
+  forwardRef: () => forwardRef,
   getCurrentInjector: () => getCurrentInjector,
   getInheritedInjectableDef: () => getInheritedInjectableDef,
   getInjectFlag: () => getInjectFlag,
@@ -71,12 +74,20 @@ __export(import_exports, {
   getNullInjector: () => getNullInjector,
   inject: () => inject2,
   injectArgs: () => injectArgs,
+  injectAsync: () => injectAsync,
   injectInjectorOnly: () => injectInjectorOnly,
   isInjectable: () => isInjectable,
   isSignal: () => isSignal2,
+  isWritableSignal: () => isWritableSignal,
   linkedSignal: () => linkedSignal,
+  makeStateKey: () => makeStateKey,
+  onIdle: () => onIdle,
+  provideIdleServiceWith: () => provideIdleServiceWith,
   providerToFactory: () => providerToFactory,
+  resolveForwardRef: () => resolveForwardRef,
   resource: () => resource,
+  resourceFromSnapshots: () => resourceFromSnapshots,
+  runInInjectionContext: () => runInInjectionContext,
   setCurrentInjector: () => setCurrentInjector,
   signal: () => signal,
   untracked: () => untracked2,
@@ -115,7 +126,7 @@ function formatRuntimeError(code, message) {
   if (ngDevMode && code < 0) {
     const addPeriodSeparator = !errorMessage.match(/[.,;!?\n]$/);
     const separator = addPeriodSeparator ? "." : "";
-    errorMessage = `${errorMessage}${separator} Find more at ${"https://v20.angular.dev/errors"}/${fullCode}`;
+    errorMessage = `${errorMessage}${separator} Find more at ${"https://v22.angular.dev/errors"}/${fullCode}`;
   }
   return errorMessage;
 }
@@ -157,9 +168,11 @@ function stringify(token) {
 var __forward_ref__ = getClosureSafeProperty({ __forward_ref__: getClosureSafeProperty });
 function forwardRef(forwardRefFn) {
   forwardRefFn.__forward_ref__ = forwardRef;
-  forwardRefFn.toString = function() {
-    return stringify(this());
-  };
+  if (ngDevMode) {
+    forwardRefFn.toString = function() {
+      return stringify(this());
+    };
+  }
   return forwardRefFn;
 }
 function resolveForwardRef(type) {
@@ -225,12 +238,12 @@ function producerAccessed(node) {
     if (nextProducerLink !== void 0 && nextProducerLink.producer === node) {
       activeConsumer.producersTail = nextProducerLink;
       nextProducerLink.lastReadVersion = node.version;
+      nextProducerLink.knownValidAtEpoch = epoch;
       return;
     }
   }
   const prevConsumerLink = node.consumersTail;
-  if (prevConsumerLink !== void 0 && prevConsumerLink.consumer === activeConsumer && // However, we have to make sure that the link we've discovered isn't from a node that is incrementally rebuilding its producer list
-  (!isRecomputing || isValidLink(prevConsumerLink, activeConsumer))) {
+  if (prevConsumerLink !== void 0 && prevConsumerLink.consumer === activeConsumer && (!isRecomputing || prevConsumerLink.knownValidAtEpoch === epoch)) {
     return;
   }
   const isLive = consumerIsLive(activeConsumer);
@@ -240,7 +253,12 @@ function producerAccessed(node) {
     // instead of eagerly destroying the previous link, we delay until we've finished recomputing
     // the producers list, so that we can destroy all of the old links at once.
     nextProducer: nextProducerLink,
-    prevConsumer: prevConsumerLink,
+    // Don't set prevConsumer here — it's only meaningful when the link is part of
+    // the producer's consumer list. producerAddLiveConsumer sets it correctly when
+    // the link is actually inserted. Setting it eagerly would create a dangling
+    // reference into the consumer list that prevents GC of removed entries.
+    prevConsumer: void 0,
+    knownValidAtEpoch: epoch,
     lastReadVersion: node.version,
     nextConsumer: void 0
   };
@@ -305,6 +323,13 @@ function consumerBeforeComputation(node) {
   return setActiveConsumer(node);
 }
 function resetConsumerBeforeComputation(node) {
+  if (node.producersTail?.knownValidAtEpoch === epoch) {
+    let producer = node.producers;
+    while (producer !== void 0) {
+      producer.knownValidAtEpoch = null;
+      producer = producer.nextProducer;
+    }
+  }
   node.producersTail = void 0;
   node.recomputing = true;
 }
@@ -404,22 +429,6 @@ function consumerIsLive(node) {
 function runPostProducerCreatedFn(node) {
   postProducerCreatedFn?.(node);
 }
-function isValidLink(checkLink, consumer) {
-  const producersTail = consumer.producersTail;
-  if (producersTail !== void 0) {
-    let link = consumer.producers;
-    do {
-      if (link === checkLink) {
-        return true;
-      }
-      if (link === producersTail) {
-        break;
-      }
-      link = link.nextProducer;
-    } while (link !== void 0);
-  }
-  return false;
-}
 
 // src/primitives/signals/src/formatter.ts
 var formatter = {
@@ -431,8 +440,8 @@ var formatter = {
     let value;
     try {
       value = sig();
-    } catch {
-      return ["span", "Signal(⚠️ Error)"];
+    } catch (e) {
+      return ["span", `Signal(⚠️ Error)${e.message ? `: ${e.message}` : ""}`];
     }
     const kind = "computation" in sig[SIGNAL] ? "Computed" : "Signal";
     const isPrimitive = value === null || !Array.isArray(value) && typeof value !== "object";
@@ -469,7 +478,7 @@ var formatter = {
       ["div", { style: `color: ${color}` }, "Signal value: "],
       ["div", { style: `padding-left: .5rem;` }, ["object", { object: sig(), config }]],
       ["div", { style: `color: ${color}` }, "Signal function: "],
-      ["div", { style: `padding-left: .5rem;` }, ["object", { object: sig, config: { ...config, skipFormatting: true } }]]
+      ["div", { style: `padding-left: .5rem;` }, ["object", { object: sig, config: { ...config, ngSkipFormatting: true } }]]
     ];
   }
 };
@@ -497,7 +506,7 @@ function prettifyPreview(value) {
       }
     }
     default: {
-      return ["object", { object: value, config: { skipFormatting: true } }];
+      return ["object", { object: value, config: { ngSkipFormatting: true } }];
     }
   }
 }
@@ -533,8 +542,7 @@ function createComputed(computation, equal) {
   };
   computed2[SIGNAL] = node;
   if (typeof ngDevMode !== "undefined" && ngDevMode) {
-    const debugName = node.debugName ? " (" + node.debugName + ")" : "";
-    computed2.toString = () => `[Computed${debugName}: ${node.value}]`;
+    computed2.toString = () => `[Computed${node.debugName ? " (" + node.debugName + ")" : ""}: ${String(node.value)}]`;
   }
   runPostProducerCreatedFn(node);
   return computed2;
@@ -600,8 +608,7 @@ function createSignal(initialValue, equal) {
   const getter = () => signalGetFn(node);
   getter[SIGNAL] = node;
   if (typeof ngDevMode !== "undefined" && ngDevMode) {
-    const debugName = node.debugName ? " (" + node.debugName + ")" : "";
-    getter.toString = () => `[Signal${debugName}: ${node.value}]`;
+    getter.toString = () => `[Signal${node.debugName ? " (" + node.debugName + ")" : ""}: ${String(node.value)}]`;
   }
   runPostProducerCreatedFn(node);
   const set = (newValue) => signalSetFn(node, newValue);
@@ -659,8 +666,7 @@ function createLinkedSignal(sourceFn, computationFn, equalityFn) {
   const getter = linkedSignalGetter;
   getter[SIGNAL] = node;
   if (typeof ngDevMode !== "undefined" && ngDevMode) {
-    const debugName = node.debugName ? " (" + node.debugName + ")" : "";
-    getter.toString = () => `[LinkedSignal${debugName}: ${node.value}]`;
+    getter.toString = () => `[LinkedSignal${node.debugName ? " (" + node.debugName + ")" : ""}: ${String(node.value)}]`;
   }
   runPostProducerCreatedFn(node);
   return getter;
@@ -672,6 +678,9 @@ function linkedSignalSetFn(node, newValue) {
 }
 function linkedSignalUpdateFn(node, updater) {
   producerUpdateValueVersion(node);
+  if (node.value === ERRORED) {
+    throw node.error;
+  }
   signalUpdateFn(node, updater);
   producerMarkClean(node);
 }
@@ -693,21 +702,25 @@ var LINKED_SIGNAL_NODE = /* @__PURE__ */ (() => ({
     node.value = COMPUTING;
     const prevConsumer = consumerBeforeComputation(node);
     let newValue;
+    let wasEqual = false;
     try {
       const newSourceValue = node.source();
-      const prev = oldValue === UNSET || oldValue === ERRORED ? void 0 : {
+      const oldValueValid = oldValue !== UNSET && oldValue !== ERRORED;
+      const prev = oldValueValid ? {
         source: node.sourceValue,
         value: oldValue
-      };
+      } : void 0;
       newValue = node.computation(newSourceValue, prev);
       node.sourceValue = newSourceValue;
+      setActiveConsumer(null);
+      wasEqual = oldValueValid && newValue !== ERRORED && node.equal(oldValue, newValue);
     } catch (err) {
       newValue = ERRORED;
       node.error = err;
     } finally {
       consumerAfterComputation(node, prevConsumer);
     }
-    if (oldValue !== UNSET && newValue !== ERRORED && node.equal(oldValue, newValue)) {
+    if (wasEqual) {
       node.value = oldValue;
       return;
     }
@@ -750,7 +763,7 @@ function runEffect(node) {
 }
 
 // src/primitives/signals/index.ts
-if (typeof ngDevMode !== "undefined" && ngDevMode) {
+if (typeof ngDevMode === "undefined" || ngDevMode) {
   installDevToolsSignalFormatter();
 }
 
@@ -810,12 +823,6 @@ var NG_INJ_DEF = getClosureSafeProperty({ ɵinj: getClosureSafeProperty });
 
 // src/import/di/injection_token.ts
 var InjectionToken = class {
-  /**
-   * @param _desc   Description for the token,
-   *                used only for debugging purposes,
-   *                it should but does not need to be unique
-   * @param options Options for the token's usage, as described above
-   */
   constructor(_desc, options) {
     this._desc = _desc;
     this.ɵprov = void 0;
@@ -886,7 +893,7 @@ function emitProviderConfiguredEvent(eventProvider, isViewProvider = false) {
 function emitInjectorToCreateInstanceEvent(token) {
   !ngDevMode && throwError("Injector profiler should never be called in production mode");
   injectorProfiler({
-    type: 4 /* InjectorToCreateInstanceEvent */,
+    type: 5 /* InjectorToCreateInstanceEvent */,
     context: getInjectorProfilerContext(),
     token
   });
@@ -962,11 +969,11 @@ function throwInvalidProviderError(ngModuleType, providers, provider) {
   } else if (isEnvironmentProviders(provider)) {
     if (provider.ɵfromNgModule) {
       throw new RuntimeError(
-        207 /* PROVIDER_IN_WRONG_CONTEXT */,
+        -207 /* PROVIDER_IN_WRONG_CONTEXT */,
         `Invalid providers from 'importProvidersFrom' present in a non-environment injector. 'importProvidersFrom' can't be used for component providers.`
       );
     } else {
-      throw new RuntimeError(207 /* PROVIDER_IN_WRONG_CONTEXT */, `Invalid providers present in a non-environment injector. 'EnvironmentProviders' can't be used for component providers.`);
+      throw new RuntimeError(-207 /* PROVIDER_IN_WRONG_CONTEXT */, `Invalid providers present in a non-environment injector. 'EnvironmentProviders' can't be used for component providers.`);
     }
   } else {
     throw new Error("Invalid provider");
@@ -1040,7 +1047,7 @@ if ((typeof ngDevMode === "undefined" || ngDevMode) && true) {
 }
 
 // src/import/di/initializer_token.ts
-var ENVIRONMENT_INITIALIZER = new InjectionToken(ngDevMode ? "ENVIRONMENT_INITIALIZER" : "");
+var ENVIRONMENT_INITIALIZER = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "ENVIRONMENT_INITIALIZER" : "");
 
 // src/import/di/interface/injector.ts
 var DecoratorFlags = /* @__PURE__ */ ((DecoratorFlags2) => {
@@ -1074,7 +1081,7 @@ function injectRootLimpMode(token, notFoundValue, flags) {
   }
   if (flags & 8 /* Optional */) return null;
   if (notFoundValue !== void 0) return notFoundValue;
-  throwProviderNotFoundError(token, "Injector");
+  throwProviderNotFoundError(token, typeof ngDevMode !== "undefined" && ngDevMode ? "Injector" : "");
 }
 
 // src/primitives/di/src/injector.ts
@@ -1120,8 +1127,6 @@ var RetrievingInjector = class {
   }
 };
 var NG_TEMP_TOKEN_PATH = "ngTempTokenPath";
-var NEW_LINE = /\n/gm;
-var NO_NEW_LINE = "ɵ";
 var SOURCE = "__source";
 function injectInjectorOnly(token, flags = 0 /* Default */) {
   const currentInjector = getCurrentInjector();
@@ -1213,27 +1218,10 @@ function attachInjectFlag(decorator, flag) {
 function getInjectFlag(token) {
   return token[DI_DECORATOR_FLAG];
 }
-function formatError(text, obj, injectorErrorName, source = null) {
-  text = text && text.charAt(0) === "\n" && text.charAt(1) == NO_NEW_LINE ? text.slice(2) : text;
-  let context = stringify(obj);
-  if (Array.isArray(obj)) {
-    context = obj.map(stringify).join(" -> ");
-  } else if (typeof obj === "object") {
-    const parts = [];
-    for (const key in obj) {
-      if (obj.hasOwnProperty(key)) {
-        const value = obj[key];
-        parts.push(key + ":" + (typeof value === "string" ? JSON.stringify(value) : stringify(value)));
-      }
-    }
-    context = `{${parts.join(", ")}}`;
-  }
-  return `${injectorErrorName}${source ? "(" + source + ")" : ""}[${context}]: ${text.replace(NEW_LINE, "\n  ")}`;
-}
 
 // src/import/di/injector_token.ts
 var INJECTOR = new InjectionToken(
-  ngDevMode ? "INJECTOR" : "",
+  typeof ngDevMode !== "undefined" && ngDevMode ? "INJECTOR" : "",
   // Disable tslint because this is const enum which gets inlined not top level prop access.
   // tslint:disable-next-line: no-toplevel-property-access
   -1 /* Injector */
@@ -1241,7 +1229,7 @@ var INJECTOR = new InjectionToken(
 );
 
 // src/import/di/internal_tokens.ts
-var INJECTOR_DEF_TYPES = new InjectionToken(ngDevMode ? "INJECTOR_DEF_TYPES" : "");
+var INJECTOR_DEF_TYPES = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "INJECTOR_DEF_TYPES" : "");
 
 // src/import/di/null_injector.ts
 var NullInjector = class {
@@ -1257,6 +1245,11 @@ var NullInjector = class {
 };
 
 // src/import/di/provider_collection.ts
+function makeEnvironmentProviders(providers) {
+  return {
+    ɵproviders: providers
+  };
+}
 var USE_VALUE = getClosureSafeProperty({
   provide: String,
   useValue: getClosureSafeProperty
@@ -1275,7 +1268,7 @@ function isTypeProvider(value) {
 }
 
 // src/import/di/scope.ts
-var INJECTOR_SCOPE = new InjectionToken(ngDevMode ? "Set Injector scope." : "");
+var INJECTOR_SCOPE = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "Set Injector scope." : "");
 
 // src/import/di/r3_injector.ts
 var NOT_YET = {};
@@ -1470,12 +1463,15 @@ var R3Injector = class extends EnvironmentInjector {
     }
   }
   toString() {
-    const tokens = [];
-    const records = this.records;
-    for (const token of records.keys()) {
-      tokens.push(stringify(token));
+    if (ngDevMode) {
+      const tokens = [];
+      const records = this.records;
+      for (const token of records.keys()) {
+        tokens.push(stringify(token));
+      }
+      return `R3Injector[${tokens.join(", ")}]`;
     }
-    return `R3Injector[${tokens.join(", ")}]`;
+    return "R3Injector[...]";
   }
   /**
    * Process a `SingleProvider` and add it.
@@ -1519,7 +1515,7 @@ var R3Injector = class extends EnvironmentInjector {
   hydrate(token, record, flags) {
     try {
       if (record.value === CIRCULAR) {
-        throw cyclicDependencyError(stringify(token));
+        throw cyclicDependencyError(ngDevMode ? stringify(token) : "");
       } else if (record.value === NOT_YET) {
         record.value = CIRCULAR;
         if (ngDevMode) {
@@ -1564,17 +1560,17 @@ function injectableDefOrInjectorDefFactory(token) {
     return factory;
   }
   if (token instanceof InjectionToken) {
-    throw new RuntimeError(204 /* INVALID_INJECTION_TOKEN */, ngDevMode && `Token ${stringify(token)} is missing a ɵprov definition.`);
+    throw new RuntimeError(-204 /* INVALID_INJECTION_TOKEN */, ngDevMode && `Token ${stringify(token)} is missing a ɵprov definition.`);
   }
   if (token instanceof Function) {
     return getUndecoratedInjectableFactory(token);
   }
-  throw new RuntimeError(204 /* INVALID_INJECTION_TOKEN */, ngDevMode && "unreachable");
+  throw new RuntimeError(-204 /* INVALID_INJECTION_TOKEN */, ngDevMode && "unreachable");
 }
 function getUndecoratedInjectableFactory(token) {
   const paramLength = token.length;
   if (paramLength > 0) {
-    throw new RuntimeError(204 /* INVALID_INJECTION_TOKEN */, ngDevMode && `Can't resolve all parameters for ${stringify(token)}: (${newArray(paramLength, "?").join(", ")}).`);
+    throw new RuntimeError(-204 /* INVALID_INJECTION_TOKEN */, ngDevMode && `Can't resolve all parameters for ${stringify(token)}: (${newArray(paramLength, "?").join(", ")}).`);
   }
   const inheritedInjectableDef = getInheritedInjectableDef(token);
   if (inheritedInjectableDef !== null) {
@@ -1622,7 +1618,7 @@ function providerToFactory(provider, ngModuleType, providers) {
 }
 function assertNotDestroyed(injector) {
   if (injector.destroyed) {
-    throw new RuntimeError(205 /* INJECTOR_ALREADY_DESTROYED */, ngDevMode && "Injector has already been destroyed.");
+    throw new RuntimeError(-205 /* INJECTOR_ALREADY_DESTROYED */, ngDevMode && "Injector has already been destroyed.");
   }
 }
 function makeRecord(factory, value, multi = false) {
@@ -1713,8 +1709,19 @@ function createInjector(defType, parent = null, additionalProviders = null, name
 }
 function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name, scopes = /* @__PURE__ */ new Set()) {
   const providers = [additionalProviders || EMPTY_ARRAY];
-  name = name || (typeof defType === "object" ? void 0 : stringify(defType));
-  return new R3Injector(providers, parent || getNullInjector(), name || null, scopes);
+  let source = void 0;
+  if (ngDevMode) {
+    source = name || (typeof defType === "object" ? void 0 : stringify(defType));
+  }
+  return new R3Injector(providers, parent || getNullInjector(), source || null, scopes);
+}
+
+// src/import/render3/debug/special_providers.ts
+var specialProviders = /* @__PURE__ */ new Set();
+function registerSpecialProvider(clazz) {
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
+    specialProviders.add(clazz);
+  }
 }
 
 // src/import/di/injector.ts
@@ -1744,6 +1751,9 @@ var Injector = class _Injector {
    */
   static __NG_ELEMENT_ID__ = -1 /* Injector */;
 };
+if (typeof ngDevMode === "undefined" || ngDevMode) {
+  registerSpecialProvider(Injector);
+}
 
 // src/import/render3/instructions/di.ts
 function ɵɵinvalidFactory() {
@@ -1755,13 +1765,17 @@ function ɵɵinvalidFactory() {
 function isSignal2(value) {
   return typeof value === "function" && value[SIGNAL] !== void 0;
 }
+function isWritableSignal(value) {
+  return isSignal2(value) && typeof value.set === "function";
+}
 
 // src/import/render3/reactivity/computed.ts
 function computed(computation, options) {
   const getter = createComputed(computation, options?.equal);
-  if (ngDevMode) {
-    getter.toString = () => `[Computed: ${getter()}]`;
-    getter[SIGNAL].debugName = options?.debugName;
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
+    const debugName = options?.debugName;
+    getter[SIGNAL].debugName = debugName;
+    getter.toString = () => `[Computed${debugName ? " (" + debugName + ")" : ""}: ${getter()}]`;
   }
   return getter;
 }
@@ -1777,9 +1791,10 @@ function signal(initialValue, options) {
   signalFn.set = set;
   signalFn.update = update;
   signalFn.asReadonly = signalAsReadonlyFn.bind(signalFn);
-  if (ngDevMode) {
-    signalFn.toString = () => `[Signal: ${signalFn()}]`;
-    node.debugName = options?.debugName;
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
+    const debugName = options?.debugName;
+    node.debugName = debugName;
+    signalFn.toString = () => `[Signal${debugName ? " (" + debugName + ")" : ""}: ${signalFn()}]`;
   }
   return signalFn;
 }
@@ -1805,9 +1820,9 @@ function linkedSignal(optionsOrComputation, options) {
   }
 }
 function upgradeLinkedSignalGetter(getter, debugName) {
-  if (ngDevMode) {
-    getter.toString = () => `[LinkedSignal: ${getter()}]`;
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
     getter[SIGNAL].debugName = debugName;
+    getter.toString = () => `[LinkedSignal${debugName ? " (" + debugName + ")" : ""}: ${getter()}]`;
   }
   const node = getter[SIGNAL];
   const upgradedGetter = getter;
@@ -1833,6 +1848,28 @@ function assertNotInReactiveContext(debugFn, extraContext) {
 }
 
 // src/import/di/contextual.ts
+function runInInjectionContext(injector, fn) {
+  let internalInjector;
+  if (injector instanceof R3Injector) {
+    assertNotDestroyed(injector);
+    internalInjector = injector;
+  } else {
+    internalInjector = new RetrievingInjector(injector);
+  }
+  let prevInjectorProfilerContext;
+  if (ngDevMode) {
+    prevInjectorProfilerContext = setInjectorProfilerContext({ injector, token: null });
+  }
+  const prevInjector = setCurrentInjector(internalInjector);
+  const previousInjectImplementation = setInjectImplementation(void 0);
+  try {
+    return fn();
+  } finally {
+    setCurrentInjector(prevInjector);
+    ngDevMode && setInjectorProfilerContext(prevInjectorProfilerContext);
+    setInjectImplementation(previousInjectImplementation);
+  }
+}
 function isInInjectionContext() {
   return getInjectImplementation() !== void 0 || getCurrentInjector() != null;
 }
@@ -1857,9 +1894,8 @@ var DestroyRef = class {
    */
   static __NG_ENV_ID__ = (injector) => injector;
 };
-
-// src/import/util/noop.ts
-function noop(...args) {
+if (typeof ngDevMode === "undefined" || ngDevMode) {
+  registerSpecialProvider(DestroyRef);
 }
 
 // src/import/change_detection/scheduling/zoneless_scheduling.ts
@@ -1882,10 +1918,6 @@ var NotificationSource = /* @__PURE__ */ ((NotificationSource2) => {
 })(NotificationSource || {});
 var ChangeDetectionScheduler = class {
 };
-var ZONELESS_ENABLED = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "Zoneless enabled" : "", { providedIn: "root", factory: () => false });
-var PROVIDED_ZONELESS = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "Zoneless provided" : "", { providedIn: "root", factory: () => false });
-var ZONELESS_SCHEDULER_DISABLED = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "scheduler disabled" : "");
-var SCHEDULE_IN_ROOT_ZONE = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "run changes outside zone in root" : "");
 
 // src/import/render3/reactivity/root_effect_scheduler.ts
 var EffectScheduler = class _EffectScheduler {
@@ -1994,7 +2026,7 @@ function effect(effectFn, options) {
   node = createRootEffect(effectFn, injector.get(EffectScheduler), notifier);
   node.injector = injector;
   if (destroyRef !== null) {
-    node.onDestroyFn = destroyRef.onDestroy(() => node.destroy());
+    node.onDestroyFns = [destroyRef.onDestroy(() => node.destroy())];
   }
   const effectRef = new EffectRefImpl(node);
   if (ngDevMode) {
@@ -2012,7 +2044,7 @@ var EFFECT_NODE = /* @__PURE__ */ (() => ({
   ...BASE_EFFECT_NODE,
   cleanupFns: void 0,
   zone: null,
-  onDestroyFn: noop,
+  onDestroyFns: null,
   run() {
     if (ngDevMode && isInNotificationPhase()) {
       throw new Error(`Schedulers cannot synchronously execute watches while scheduling.`);
@@ -2045,7 +2077,11 @@ var ROOT_EFFECT_NODE = /* @__PURE__ */ (() => ({
   },
   destroy() {
     consumerDestroy(this);
-    this.onDestroyFn();
+    if (this.onDestroyFns !== null) {
+      for (const fn of this.onDestroyFns) {
+        fn();
+      }
+    }
     this.cleanup();
     this.scheduler.remove(this);
   }
@@ -2066,6 +2102,10 @@ function createEffectFn(node, fn) {
   };
 }
 
+// src/import/util/noop.ts
+function noop(...args) {
+}
+
 // src/import/util/callback_scheduler.ts
 function scheduleCallbackWithMicrotask(callback) {
   queueMicrotask(() => callback());
@@ -2096,43 +2136,119 @@ var ChangeDetectionSchedulerImpl = class {
   }
 };
 
-// src/import/pending_tasks.ts
-var import_rxjs = require("rxjs");
+// src/import/resource/api.ts
+var ResourceDependencyError = class extends Error {
+  /** The dependency that errored. */
+  dependency;
+  constructor(dependency) {
+    super("Dependency error", { cause: dependency.error() });
+    this.name = "ResourceDependencyError";
+    this.dependency = dependency;
+  }
+};
+var ResourceParamsStatus = class _ResourceParamsStatus extends Error {
+  _brand;
+  constructor(msg) {
+    super(msg);
+  }
+  /** Status code that transitions the resource to `idle` status. */
+  static IDLE = new _ResourceParamsStatus("IDLE");
+  /** Status code that transitions the resource to `loading` status. */
+  static LOADING = new _ResourceParamsStatus("LOADING");
+};
 
-// src/import/error_handler.ts
-var ErrorHandler = class {
-  /**
-   * @internal
-   */
-  _console = console;
-  handleError(error) {
-    this._console.error("ERROR", error);
+// src/import/defer/idle_service.ts
+var _requestIdleCallback = () => (typeof requestIdleCallback !== "undefined" ? requestIdleCallback : (cb) => setTimeout(cb)).bind(globalThis);
+var _cancelIdleCallback = () => (typeof requestIdleCallback !== "undefined" ? cancelIdleCallback : clearTimeout).bind(globalThis);
+var IDLE_SERVICE = new InjectionToken(ngDevMode ? "IDLE_SERVICE" : "", {
+  factory: () => new RequestIdleCallbackService()
+});
+function provideIdleServiceWith(useExisting) {
+  return makeEnvironmentProviders([
+    {
+      provide: IDLE_SERVICE,
+      useExisting
+    }
+  ]);
+}
+var RequestIdleCallbackService = class {
+  requestIdleCallback = _requestIdleCallback();
+  cancelIdleCallback = _cancelIdleCallback();
+  requestOnIdle(callback, options) {
+    return this.requestIdleCallback(callback, options);
+  }
+  cancelOnIdle(id) {
+    return this.cancelIdleCallback(id);
   }
 };
-var INTERNAL_APPLICATION_ERROR_HANDLER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "internal error handler" : "", {
-  providedIn: "root",
-  factory: () => {
-    const injector = inject2(EnvironmentInjector);
-    let userErrorHandler;
-    return (e) => {
-      if (injector.destroyed && !userErrorHandler) {
-        setTimeout(() => {
-          throw e;
-        });
-      } else {
-        userErrorHandler ??= injector.get(ErrorHandler);
-        userErrorHandler.handleError(e);
-      }
-    };
+
+// src/import/util/default_export.ts
+function maybeUnwrapDefaultExport(input) {
+  return isWrappedDefaultExport(input) ? input["default"] : input;
+}
+function isWrappedDefaultExport(value) {
+  return value && typeof value === "object" && "default" in value;
+}
+
+// src/import/util/promise_with_resolvers.ts
+function promiseWithResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+// src/import/di/inject_async.ts
+function injectAsync(loader, options) {
+  if (ngDevMode) {
+    assertInInjectionContext(injectAsync);
   }
-});
+  const injector = inject2(Injector);
+  let loadedPromise = null;
+  const load = () => {
+    if (!loadedPromise) {
+      loadedPromise = loader();
+    }
+    return loadedPromise;
+  };
+  if (options?.prefetch) {
+    options.prefetch().then(() => load()).catch(() => {
+    });
+  }
+  return () => load().then((loadedToken) => injector.get(maybeUnwrapDefaultExport(loadedToken)));
+}
+function onIdle(options) {
+  if (ngDevMode) {
+    assertInInjectionContext(onIdle);
+  }
+  const idleService = inject2(IDLE_SERVICE);
+  const { promise, resolve } = promiseWithResolvers();
+  idleService.requestOnIdle(() => resolve(), options);
+  return promise;
+}
 
-// src/import/pending_tasks.ts
+// src/import/hydration/cache.ts
+var CACHE_ACTIVE = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "STATE_CACHE_ACTIVE" : "");
+
+// src/import/event_emitter.ts
+var import_rxjs2 = require("rxjs");
+
+// src/import/pending_tasks_internal.ts
+var import_rxjs = require("rxjs");
+
+// src/import/application/stability_debug.ts
+var DEBUG_TASK_TRACKER = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "DEBUG_TASK_TRACKER" : "");
+
+// src/import/pending_tasks_internal.ts
 var PendingTasksInternal = class _PendingTasksInternal {
   taskId = 0;
   pendingTasks = /* @__PURE__ */ new Set();
   destroyed = false;
   pendingTask = new import_rxjs.BehaviorSubject(false);
+  debugTaskTracker = inject2(DEBUG_TASK_TRACKER, { optional: true });
   get hasPendingTasks() {
     return this.destroyed ? false : this.pendingTask.value;
   }
@@ -2155,6 +2271,7 @@ var PendingTasksInternal = class _PendingTasksInternal {
     }
     const taskId = this.taskId++;
     this.pendingTasks.add(taskId);
+    this.debugTaskTracker?.add(taskId);
     return taskId;
   }
   has(taskId) {
@@ -2162,6 +2279,7 @@ var PendingTasksInternal = class _PendingTasksInternal {
   }
   remove(taskId) {
     this.pendingTasks.delete(taskId);
+    this.debugTaskTracker?.remove(taskId);
     if (this.pendingTasks.size === 0 && this.hasPendingTasks) {
       this.pendingTask.next(false);
     }
@@ -2184,6 +2302,232 @@ var PendingTasksInternal = class _PendingTasksInternal {
     })
   );
 };
+
+// src/import/event_emitter.ts
+var EventEmitter_ = class extends import_rxjs2.Subject {
+  // tslint:disable-next-line:require-internal-with-underscore
+  __isAsync;
+  destroyRef = void 0;
+  pendingTasks = void 0;
+  constructor(isAsync = false) {
+    super();
+    this.__isAsync = isAsync;
+    if (isInInjectionContext()) {
+      this.destroyRef = inject2(DestroyRef, { optional: true }) ?? void 0;
+      this.pendingTasks = inject2(PendingTasksInternal, { optional: true }) ?? void 0;
+    }
+  }
+  emit(value) {
+    const prevConsumer = setActiveConsumer(null);
+    try {
+      super.next(value);
+    } finally {
+      setActiveConsumer(prevConsumer);
+    }
+  }
+  subscribe(observerOrNext, error, complete) {
+    let nextFn = observerOrNext;
+    let errorFn = error || (() => null);
+    let completeFn = complete;
+    if (observerOrNext && typeof observerOrNext === "object") {
+      const observer = observerOrNext;
+      nextFn = observer.next?.bind(observer);
+      errorFn = observer.error?.bind(observer);
+      completeFn = observer.complete?.bind(observer);
+    }
+    if (this.__isAsync) {
+      errorFn = this.wrapInTimeout(errorFn);
+      if (nextFn) {
+        nextFn = this.wrapInTimeout(nextFn);
+      }
+      if (completeFn) {
+        completeFn = this.wrapInTimeout(completeFn);
+      }
+    }
+    const sink = super.subscribe({ next: nextFn, error: errorFn, complete: completeFn });
+    if (observerOrNext instanceof import_rxjs2.Subscription) {
+      observerOrNext.add(sink);
+    }
+    return sink;
+  }
+  wrapInTimeout(fn) {
+    return (value) => {
+      const taskId = this.pendingTasks?.add();
+      setTimeout(() => {
+        try {
+          fn(value);
+        } finally {
+          if (taskId !== void 0) {
+            this.pendingTasks?.remove(taskId);
+          }
+        }
+      });
+    };
+  }
+};
+var EventEmitter = EventEmitter_;
+
+// src/import/zone/ng_zone.ts
+var isAngularZoneProperty = "isAngularZone";
+var angularZoneInstanceIdProperty = isAngularZoneProperty + "_ID";
+var NgZone = class _NgZone {
+  hasPendingMacrotasks = false;
+  hasPendingMicrotasks = false;
+  /**
+   * Whether there are no outstanding microtasks or macrotasks.
+   */
+  isStable = true;
+  /**
+   * Notifies when code enters Angular Zone. This gets fired first on VM Turn.
+   */
+  onUnstable = new EventEmitter(false);
+  /**
+   * Notifies when there is no more microtasks enqueued in the current VM Turn.
+   * This is a hint for Angular to do change detection, which may enqueue more microtasks.
+   * For this reason this event can fire multiple times per VM Turn.
+   */
+  onMicrotaskEmpty = new EventEmitter(false);
+  /**
+   * Notifies when the last `onMicrotaskEmpty` has run and there are no more microtasks, which
+   * implies we are about to relinquish VM turn.
+   * This event gets called just once.
+   */
+  onStable = new EventEmitter(false);
+  /**
+   * Notifies that an error has been delivered.
+   */
+  onError = new EventEmitter(false);
+  constructor(options) {
+  }
+  /**
+    This method checks whether the method call happens within an Angular Zone instance.
+  */
+  /**
+    Assures that the method is called within the Angular Zone, otherwise throws an error.
+  */
+  /**
+    Assures that the method is called outside of the Angular Zone, otherwise throws an error.
+  */
+  /**
+   * Executes the `fn` function synchronously within the Angular zone and returns value returned by
+   * the function.
+   *
+   * Running functions via `run` allows you to reenter Angular zone from a task that was executed
+   * outside of the Angular zone (typically started via {@link #runOutsideAngular}).
+   *
+   * Any future tasks or microtasks scheduled from within this function will continue executing from
+   * within the Angular zone.
+   *
+   * If a synchronous error happens it will be rethrown and not reported via `onError`.
+   */
+  run(fn, applyThis, applyArgs) {
+    return this._inner.run(fn, applyThis, applyArgs);
+  }
+  /**
+   * Executes the `fn` function synchronously within the Angular zone as a task and returns value
+   * returned by the function.
+   *
+   * Running functions via `runTask` allows you to reenter Angular zone from a task that was executed
+   * outside of the Angular zone (typically started via {@link #runOutsideAngular}).
+   *
+   * Any future tasks or microtasks scheduled from within this function will continue executing from
+   * within the Angular zone.
+   *
+   * If a synchronous error happens it will be rethrown and not reported via `onError`.
+   */
+  runTask(fn, applyThis, applyArgs, name) {
+    const zone = this._inner;
+    const task = zone.scheduleEventTask("NgZoneEvent: " + name, fn, EMPTY_PAYLOAD, noop, noop);
+    try {
+      return zone.runTask(task, applyThis, applyArgs);
+    } finally {
+      zone.cancelTask(task);
+    }
+  }
+  /**
+   * Same as `run`, except that synchronous errors are caught and forwarded via `onError` and not
+   * rethrown.
+   */
+  runGuarded(fn, applyThis, applyArgs) {
+    return this._inner.runGuarded(fn, applyThis, applyArgs);
+  }
+  /**
+   * Executes the `fn` function synchronously in Angular's parent zone and returns value returned by
+   * the function.
+   *
+   * Running functions via {@link #runOutsideAngular} allows you to escape Angular's zone and do
+   * work that
+   * doesn't trigger Angular change-detection or is subject to Angular's error handling.
+   *
+   * Any future tasks or microtasks scheduled from within this function will continue executing from
+   * outside of the Angular zone.
+   *
+   * Use {@link #run} to reenter the Angular zone and do work that updates the application model.
+   */
+  runOutsideAngular(fn) {
+    return this._outer.run(fn);
+  }
+  /** @nocollapse */
+  static ɵprov = ɵɵdefineInjectable({
+    token: _NgZone,
+    providedIn: "root",
+    factory: () => new NoopNgZone()
+  });
+};
+var EMPTY_PAYLOAD = {};
+var NoopNgZone = class {
+  hasPendingMicrotasks = false;
+  hasPendingMacrotasks = false;
+  isStable = true;
+  onUnstable = new EventEmitter();
+  onMicrotaskEmpty = new EventEmitter();
+  onStable = new EventEmitter();
+  onError = new EventEmitter();
+  run(fn, applyThis, applyArgs) {
+    return fn.apply(applyThis, applyArgs);
+  }
+  runGuarded(fn, applyThis, applyArgs) {
+    return fn.apply(applyThis, applyArgs);
+  }
+  runOutsideAngular(fn) {
+    return fn();
+  }
+  runTask(fn, applyThis, applyArgs, name) {
+    return fn.apply(applyThis, applyArgs);
+  }
+};
+
+// src/import/error_handler.ts
+var ErrorHandler = class {
+  /**
+   * @internal
+   */
+  _console = console;
+  handleError(error) {
+    this._console.error("ERROR", error);
+  }
+};
+var INTERNAL_APPLICATION_ERROR_HANDLER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "internal error handler" : "", {
+  factory: () => {
+    const zone = inject2(NgZone);
+    const injector = inject2(EnvironmentInjector);
+    let userErrorHandler;
+    return (e) => {
+      zone.runOutsideAngular(() => {
+        if (injector.destroyed && !userErrorHandler) {
+          setTimeout(() => {
+            throw e;
+          });
+        } else {
+          userErrorHandler ??= injector.get(ErrorHandler);
+          userErrorHandler.handleError(e);
+        }
+      });
+    };
+  }
+});
+
+// src/import/pending_tasks.ts
 var PendingTasks = class _PendingTasks {
   internalPendingTasks = inject2(PendingTasksInternal);
   scheduler = inject2(ChangeDetectionScheduler);
@@ -2217,7 +2561,12 @@ var PendingTasks = class _PendingTasks {
    */
   run(fn) {
     const removeTask = this.add();
-    fn().catch(this.errorHandler).finally(removeTask);
+    try {
+      fn().catch(this.errorHandler).finally(removeTask);
+    } catch (err) {
+      this.errorHandler(err);
+      removeTask();
+    }
   }
   /** @nocollapse */
   static ɵprov = (
@@ -2230,6 +2579,91 @@ var PendingTasks = class _PendingTasks {
   );
 };
 
+// src/import/application/application_tokens.ts
+var APP_ID = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "AppId" : "", {
+  factory: () => DEFAULT_APP_ID
+});
+var DEFAULT_APP_ID = "ng";
+
+// src/import/document.ts
+var DOCUMENT = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "DocumentToken" : "");
+
+// src/import/transfer_state.ts
+function makeStateKey(key) {
+  return key;
+}
+var TransferState = class _TransferState {
+  /** @nocollapse */
+  static ɵprov = (
+    /** @pureOrBreakMyCode */
+    /* @__PURE__ */ ɵɵdefineInjectable({
+      token: _TransferState,
+      providedIn: "root",
+      factory: () => {
+        const transferState = new _TransferState();
+        if (false) {
+          transferState.store = retrieveTransferredState(inject3(DOCUMENT2), inject3(APP_ID2));
+        }
+        return transferState;
+      }
+    })
+  );
+  /** @internal */
+  store = {};
+  onSerializeCallbacks = {};
+  /**
+   * Get the value corresponding to a key. Return `defaultValue` if key is not found.
+   */
+  get(key, defaultValue) {
+    return this.store[key] !== void 0 ? this.store[key] : defaultValue;
+  }
+  /**
+   * Set the value corresponding to a key.
+   */
+  set(key, value) {
+    this.store[key] = value;
+  }
+  /**
+   * Remove a key from the store.
+   */
+  remove(key) {
+    delete this.store[key];
+  }
+  /**
+   * Test whether a key exists in the store.
+   */
+  hasKey(key) {
+    return this.store.hasOwnProperty(key);
+  }
+  /**
+   * Indicates whether the state is empty.
+   */
+  get isEmpty() {
+    return Object.keys(this.store).length === 0;
+  }
+  /**
+   * Register a callback to provide the value for a key when `toJson` is called.
+   */
+  onSerialize(key, callback) {
+    this.onSerializeCallbacks[key] = callback;
+  }
+  /**
+   * Serialize the current state of the store to JSON.
+   */
+  toJson() {
+    for (const key in this.onSerializeCallbacks) {
+      if (this.onSerializeCallbacks.hasOwnProperty(key)) {
+        try {
+          this.store[key] = this.onSerializeCallbacks[key]();
+        } catch (e) {
+          console.warn("Exception in onSerialize callback: ", e);
+        }
+      }
+    }
+    return JSON.stringify(this.store).replace(/</g, "\\u003C").replace(/\//g, "\\u002F");
+  }
+};
+
 // src/import/resource/resource.ts
 function resource(options) {
   if (ngDevMode && !options?.injector) {
@@ -2237,21 +2671,30 @@ function resource(options) {
   }
   const oldNameForParams = options.request;
   const params = options.params ?? oldNameForParams ?? (() => null);
-  return new ResourceImpl(params, getLoader(options), options.defaultValue, options.equal ? wrapEqualityFn(options.equal) : void 0, options.injector ?? inject2(Injector));
+  return new ResourceImpl(
+    params,
+    getLoader(options),
+    options.defaultValue,
+    options.equal ? wrapEqualityFn(options.equal) : void 0,
+    options.debugName,
+    options.injector ?? inject2(Injector),
+    options.id
+  );
 }
 var BaseWritableResource = class {
   value;
-  constructor(value) {
+  isLoading;
+  constructor(value, debugName) {
     this.value = value;
     this.value.set = this.set.bind(this);
     this.value.update = this.update.bind(this);
     this.value.asReadonly = signalAsReadonlyFn;
+    this.isLoading = computed(() => this.status() === "loading" || this.status() === "reloading", ngDevMode ? createDebugNameObject(debugName, "isLoading") : void 0);
   }
   isError = computed(() => this.status() === "error");
   update(updateFn) {
     this.set(updateFn(untracked2(this.value)));
   }
-  isLoading = computed(() => this.status() === "loading" || this.status() === "reloading");
   // Use a computed here to avoid triggering reactive consumers if the value changes while staying
   // either defined or undefined.
   isValueDefined = computed(() => {
@@ -2260,6 +2703,17 @@ var BaseWritableResource = class {
     }
     return this.value() !== void 0;
   });
+  _snapshot;
+  get snapshot() {
+    return this._snapshot ??= computed(() => {
+      const status = this.status();
+      if (status === "error") {
+        return { status: "error", error: this.error() };
+      } else {
+        return { status, value: this.value() };
+      }
+    });
+  }
   hasValue() {
     return this.isValueDefined();
   }
@@ -2268,7 +2722,10 @@ var BaseWritableResource = class {
   }
 };
 var ResourceImpl = class extends BaseWritableResource {
-  constructor(request, loaderFn, defaultValue, equal, injector) {
+  constructor(request, loaderFn, defaultValue, equal, debugName, injector, transferCacheKey, getInitialStream) {
+    if (isInParamsFunction()) {
+      throw invalidResourceCreationInParams();
+    }
     super(
       // Feed a computed signal for the value to `BaseWritableResource`, which will upgrade it to a
       // `WritableSignal` that delegates to `ResourceImpl.set`.
@@ -2286,45 +2743,91 @@ var ResourceImpl = class extends BaseWritableResource {
           }
           return streamValue.value;
         },
-        { equal }
-      )
+        { equal, ...ngDevMode ? createDebugNameObject(debugName, "value") : void 0 }
+      ),
+      debugName
     );
     this.loaderFn = loaderFn;
     this.equal = equal;
-    this.extRequest = linkedSignal({
-      source: request,
-      computation: (request2) => ({ request: request2, reload: 0 })
-    });
+    this.debugName = debugName;
+    this.transferCacheKey = transferCacheKey;
+    const cacheState = injector.get(CACHE_ACTIVE, void 0, { optional: true }) ?? { isActive: false };
+    this.transferState = injector.get(TransferState, void 0, { optional: true }) ?? void 0;
+    this.extRequest = linkedSignal(
+      () => {
+        try {
+          setInParamsFunction(true);
+          return { request: request(paramsContext), reload: 0 };
+        } catch (error) {
+          rethrowFatalErrors(error);
+          if (error === ResourceParamsStatus.IDLE) {
+            return { status: "idle", reload: 0 };
+          } else if (error === ResourceParamsStatus.LOADING) {
+            return { status: "loading", reload: 0 };
+          }
+          return { error, reload: 0 };
+        } finally {
+          setInParamsFunction(false);
+        }
+      },
+      ngDevMode ? createDebugNameObject(debugName, "extRequest") : void 0
+    );
     this.state = linkedSignal({
       // Whenever the request changes,
       source: this.extRequest,
       // Compute the state of the resource given a change in status.
       computation: (extRequest, previous) => {
-        const status = extRequest.request === void 0 ? "idle" : "loading";
-        if (!previous) {
-          return {
-            extRequest,
-            status,
-            previousStatus: "idle",
-            stream: void 0
-          };
-        } else {
-          return {
-            extRequest,
-            status,
-            previousStatus: projectStatusOfState(previous.value),
-            // If the request hasn't changed, keep the previous stream.
-            stream: previous.value.extRequest.request === extRequest.request ? previous.value.stream : void 0
-          };
+        let { request: request2, status, error } = extRequest;
+        let stream;
+        if (error) {
+          status = "resolved";
+          stream = signal({ error: encapsulateResourceError(error) }, ngDevMode ? createDebugNameObject(this.debugName, "stream") : void 0);
+        } else if (!status) {
+          if (!previous) {
+            const transferState = this.transferState;
+            const cacheKey = this.transferCacheKey;
+            if (cacheState.isActive && cacheKey && transferState && request2 !== void 0) {
+              const key = this.transferCacheKey;
+              if (transferState.hasKey(cacheKey)) {
+                stream = signal({ value: transferState.get(cacheKey, defaultValue) }, ngDevMode ? createDebugNameObject(this.debugName, "stream") : void 0);
+              }
+            }
+            if (!stream) {
+              stream = getInitialStream?.(extRequest.request);
+            }
+            getInitialStream = void 0;
+            status = request2 === void 0 ? "idle" : stream ? "resolved" : "loading";
+          } else {
+            status = request2 === void 0 ? "idle" : "loading";
+            if (previous.value.extRequest.request === request2) {
+              stream = previous.value.stream;
+            }
+          }
         }
-      }
+        return {
+          extRequest,
+          status,
+          previousStatus: previous ? projectStatusOfState(previous.value) : "idle",
+          stream
+        };
+      },
+      ...ngDevMode ? createDebugNameObject(debugName, "state") : void 0
     });
     this.effectRef = effect(this.loadEffect.bind(this), {
       injector,
-      manualCleanup: true
+      manualCleanup: true,
+      ...ngDevMode ? createDebugNameObject(debugName, "loadEffect") : void 0
     });
     this.pendingTasks = injector.get(PendingTasks);
     this.unregisterOnDestroy = injector.get(DestroyRef).onDestroy(() => this.destroy());
+    this.status = computed(() => projectStatusOfState(this.state()), ngDevMode ? createDebugNameObject(debugName, "status") : void 0);
+    this.error = computed(
+      () => {
+        const stream = this.state().stream?.();
+        return stream && !isResolved(stream) ? stream.error : void 0;
+      },
+      ngDevMode ? createDebugNameObject(debugName, "error") : void 0
+    );
   }
   pendingTasks;
   /**
@@ -2341,11 +2844,9 @@ var ResourceImpl = class extends BaseWritableResource {
   resolvePendingTask = void 0;
   destroyed = false;
   unregisterOnDestroy;
-  status = computed(() => projectStatusOfState(this.state()));
-  error = computed(() => {
-    const stream = this.state().stream?.();
-    return stream && !isResolved(stream) ? stream.error : void 0;
-  });
+  status;
+  error;
+  transferState;
   /**
    * Called either directly via `WritableResource.set` or via `.value.set()`.
    */
@@ -2365,7 +2866,7 @@ var ResourceImpl = class extends BaseWritableResource {
       extRequest: state.extRequest,
       status: "local",
       previousStatus: "local",
-      stream: signal({ value })
+      stream: signal({ value }, ngDevMode ? createDebugNameObject(this.debugName, "stream") : void 0)
     });
     this.abortInProgressLoad();
   }
@@ -2401,27 +2902,48 @@ var ResourceImpl = class extends BaseWritableResource {
     let resolvePendingTask = this.resolvePendingTask = this.pendingTasks.add();
     const { signal: abortSignal } = this.pendingController = new AbortController();
     try {
-      const stream = await untracked2(
+      const stream = untracked2(
         () => this.loaderFn({
           params: extRequest.request,
-          // TODO(alxhub): cleanup after g3 removal of `request` alias.
-          request: extRequest.request,
           abortSignal,
           previous: {
             status: previousStatus
           }
         })
       );
-      if (abortSignal.aborted || untracked2(this.extRequest) !== extRequest) {
-        return;
+      const shouldDiscard = () => abortSignal.aborted || untracked2(this.extRequest) !== extRequest;
+      if (isSignal2(stream)) {
+        if (shouldDiscard()) {
+          return;
+        }
+        this.state.set({
+          extRequest,
+          status: "resolved",
+          previousStatus: "resolved",
+          stream
+        });
+        const result = untracked2(stream);
+        if (true) {
+          saveToTransferState(result, this.transferCacheKey, this.transferState);
+        }
+      } else {
+        const resolvedStream = await stream;
+        if (shouldDiscard()) {
+          return;
+        }
+        this.state.set({
+          extRequest,
+          status: "resolved",
+          previousStatus: "resolved",
+          stream: resolvedStream
+        });
+        const result = resolvedStream ? untracked2(resolvedStream) : void 0;
+        if (true) {
+          saveToTransferState(result, this.transferCacheKey, this.transferState);
+        }
       }
-      this.state.set({
-        extRequest,
-        status: "resolved",
-        previousStatus: "resolved",
-        stream
-      });
     } catch (err) {
+      rethrowFatalErrors(err);
       if (abortSignal.aborted || untracked2(this.extRequest) !== extRequest) {
         return;
       }
@@ -2429,7 +2951,7 @@ var ResourceImpl = class extends BaseWritableResource {
         extRequest,
         status: "resolved",
         previousStatus: "error",
-        stream: signal({ error: encapsulateResourceError(err) })
+        stream: signal({ error: encapsulateResourceError(err) }, ngDevMode ? createDebugNameObject(this.debugName, "stream") : void 0)
       });
     } finally {
       resolvePendingTask?.();
@@ -2443,6 +2965,11 @@ var ResourceImpl = class extends BaseWritableResource {
     this.resolvePendingTask = void 0;
   }
 };
+function saveToTransferState(result, transferCacheKey, transferState) {
+  if (transferCacheKey && transferState && result && isResolved(result)) {
+    transferState.set(transferCacheKey, result.value);
+  }
+}
 function wrapEqualityFn(equal) {
   return (a, b) => a === void 0 || b === void 0 ? a === b : equal(a, b);
 }
@@ -2452,9 +2979,9 @@ function getLoader(options) {
   }
   return async (params) => {
     try {
-      return signal({ value: await options.loader(params) });
+      return signal({ value: await options.loader(params) }, ngDevMode ? createDebugNameObject(options.debugName, "stream") : void 0);
     } catch (err) {
-      return signal({ error: encapsulateResourceError(err) });
+      return signal({ error: encapsulateResourceError(err) }, ngDevMode ? createDebugNameObject(options.debugName, "stream") : void 0);
     }
   };
 }
@@ -2474,12 +3001,20 @@ function projectStatusOfState(state) {
 function isResolved(state) {
   return state.error === void 0;
 }
+function createDebugNameObject(resourceDebugName, internalSignalDebugName) {
+  return {
+    debugName: `Resource${resourceDebugName ? "#" + resourceDebugName : ""}.${internalSignalDebugName}`
+  };
+}
 function encapsulateResourceError(error) {
-  if (error instanceof Error) {
+  if (isErrorLike(error)) {
     return error;
   }
   return new ResourceWrappedError(error);
 }
+function isErrorLike(error) {
+  return error instanceof Error || typeof error === "object" && typeof error.name === "string" && typeof error.message === "string";
+}
 var ResourceValueError = class extends Error {
   constructor(error) {
     super(ngDevMode ? `Resource is currently in an error state (see Error.cause for details): ${error.message}` : error.message, { cause: error });
@@ -2490,6 +3025,146 @@ var ResourceWrappedError = class extends Error {
     super(ngDevMode ? `Resource returned an error that's not an Error instance: ${String(error)}. Check this error's .cause for the actual error.` : String(error), { cause: error });
   }
 };
+function chain(resource2) {
+  switch (resource2.status()) {
+    case "idle":
+      throw ResourceParamsStatus.IDLE;
+    case "error":
+      throw new ResourceDependencyError(resource2);
+    case "loading":
+    case "reloading":
+      throw ResourceParamsStatus.LOADING;
+  }
+  return resource2.value();
+}
+var paramsContext = {
+  chain
+};
+var inParamsFunction = false;
+function isInParamsFunction() {
+  return inParamsFunction;
+}
+function setInParamsFunction(value) {
+  inParamsFunction = value;
+}
+function invalidResourceCreationInParams() {
+  return new RuntimeError(992 /* INVALID_RESOURCE_CREATION_IN_PARAMS */, ngDevMode && `Cannot create a resource inside the \`params\` of another resource`);
+}
+function rethrowFatalErrors(error) {
+  if (error instanceof RuntimeError && error.code === 992 /* INVALID_RESOURCE_CREATION_IN_PARAMS */) {
+    throw error;
+  }
+}
+
+// src/import/resource/from_snapshots.ts
+function resourceFromSnapshots(source) {
+  return new SnapshotResource(isSignal2(source) ? source : computed(source));
+}
+var SnapshotResource = class {
+  constructor(snapshot) {
+    this.snapshot = snapshot;
+  }
+  get state() {
+    return this.snapshot();
+  }
+  value = computed(() => {
+    if (this.state.status === "error") {
+      throw new ResourceValueError(this.state.error);
+    }
+    return this.state.value;
+  });
+  status = computed(() => this.state.status);
+  error = computed(() => this.state.status === "error" ? this.state.error : void 0);
+  isLoading = computed(() => this.state.status === "loading" || this.state.status === "reloading");
+  isValueDefined = computed(() => this.state.status !== "error" && this.state.value !== void 0);
+  hasValue() {
+    return this.isValueDefined();
+  }
+};
+
+// src/import/resource/debounce.ts
+function debounced(source, wait, options) {
+  if (isInParamsFunction()) {
+    throw invalidResourceCreationInParams();
+  }
+  if (ngDevMode && !options?.injector) {
+    assertInInjectionContext(debounced);
+  }
+  const injector = options?.injector ?? inject2(Injector);
+  let active;
+  let pendingValue;
+  injector.get(DestroyRef).onDestroy(() => {
+    active = void 0;
+  });
+  const state = linkedSignal({
+    source: () => {
+      try {
+        setInParamsFunction(true);
+        return { value: source(), thrown: false };
+      } catch (err) {
+        rethrowFatalErrors(err);
+        return { error: err, thrown: true };
+      } finally {
+        setInParamsFunction(false);
+      }
+    },
+    computation: (res, previous) => {
+      if (previous !== void 0) {
+        return previous.value;
+      }
+      if (res.thrown) {
+        return { status: "error", error: res.error };
+      }
+      return { status: "resolved", value: res.value };
+    }
+  });
+  effect(
+    () => {
+      let value;
+      try {
+        setInParamsFunction(true);
+        value = source();
+      } catch (err) {
+        rethrowFatalErrors(err);
+        state.set({ status: "error", error: err });
+        active = pendingValue = void 0;
+        return;
+      } finally {
+        setInParamsFunction(false);
+      }
+      const currentState = untracked2(state);
+      const equal = options?.equal ?? Object.is;
+      if (currentState.status === "reloading" || currentState.status === "loading") {
+        if (equal(value, pendingValue)) return;
+      } else if (currentState.status === "resolved") {
+        if (equal(value, currentState.value)) return;
+      }
+      const waitFn = typeof wait === "number" ? () => new Promise((resolve) => setTimeout(resolve, wait)) : wait;
+      const result = waitFn(value, currentState);
+      if (result === void 0) {
+        state.set({ status: "resolved", value });
+        active = pendingValue = void 0;
+      } else {
+        if (currentState.status !== "loading" && currentState.status !== "error") {
+          state.set({ status: "loading", value: currentState.value });
+        }
+        active = result;
+        pendingValue = value;
+        result.then(() => {
+          if (active === result) {
+            state.set({ status: "resolved", value });
+            active = pendingValue = void 0;
+          }
+        });
+      }
+    },
+    { injector }
+  );
+  return resourceFromSnapshots(state);
+}
+
+// src/import/interface/type.ts
+var Type = Function;
 
 // src/import/index.ts
 function Injectable(args) {
@@ -2523,6 +3198,7 @@ function createRootInjector(options) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  APP_ID,
   ChangeDetectionScheduler,
   ChangeDetectionSchedulerImpl,
   DecoratorFlags,
@@ -2530,6 +3206,7 @@ function createRootInjector(options) {
   EffectScheduler,
   EnvironmentInjector,
   ErrorHandler,
+  EventEmitter,
   INJECTOR_SCOPE,
   INTERNAL_APPLICATION_ERROR_HANDLER,
   Inject,
@@ -2543,20 +3220,20 @@ function createRootInjector(options) {
   NotificationSource,
   NullInjector,
   Optional,
-  PROVIDED_ZONELESS,
   PendingTasks,
-  PendingTasksInternal,
   R3Injector,
+  ResourceDependencyError,
+  ResourceParamsStatus,
   RetrievingInjector,
   RootStaticInjectOptions,
-  SCHEDULE_IN_ROOT_ZONE,
   SOURCE,
   Self,
   SkipSelf,
   StaticInjectOptions,
   THROW_IF_NOT_FOUND,
-  ZONELESS_ENABLED,
-  ZONELESS_SCHEDULER_DISABLED,
+  TransferState,
+  Type,
+  assertInInjectionContext,
   assertNotDestroyed,
   assertNotInReactiveContext,
   attachInjectFlag,
@@ -2564,8 +3241,9 @@ function createRootInjector(options) {
   convertToBitFlags,
   createInjector,
   createRootInjector,
+  debounced,
   effect,
-  formatError,
+  forwardRef,
   getCurrentInjector,
   getInheritedInjectableDef,
   getInjectFlag,
@@ -2574,12 +3252,20 @@ function createRootInjector(options) {
   getNullInjector,
   inject,
   injectArgs,
+  injectAsync,
   injectInjectorOnly,
   isInjectable,
   isSignal,
+  isWritableSignal,
   linkedSignal,
+  makeStateKey,
+  onIdle,
+  provideIdleServiceWith,
   providerToFactory,
+  resolveForwardRef,
   resource,
+  resourceFromSnapshots,
+  runInInjectionContext,
   setCurrentInjector,
   signal,
   untracked,
@@ -2599,11 +3285,4 @@ function createRootInjector(options) {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
 //# sourceMappingURL=index.js.map